Try Live
Add Docs
Rankings
Pricing
Enterprise
Docs
Install
Install
Docs
Pricing
Enterprise
More...
More...
Try Live
Rankings
Add Docs
PyQPanda Tutorial
https://github.com/originq/pyqpanda-toturial
Admin
A collection of tutorials and examples designed to help users learn and utilize the pyQPanda quantum
...
Tokens:
32,418
Snippets:
161
Trust Score:
7.3
Update:
5 months ago
Context
Skills
Chat
Benchmark
93.3
Suggestions
Latest
Show doc for...
Code
Info
Show Results
Context Summary (auto-generated)
Raw
Copy
Link
# PyQPanda PyQPanda is a comprehensive Python quantum computing framework developed by Origin Quantum Computing. It provides a full-featured quantum software development kit for building, simulating, and executing quantum algorithms on both simulators and real quantum hardware. The framework is built as a Python wrapper around the C++ QPanda 2 library using pybind11, offering high-performance quantum circuit simulation with multiple backend options including CPU, GPU, MPS (Matrix Product State), and stabilizer-based simulators. The library serves as a complete quantum programming environment, integrating quantum circuit construction, multiple virtual machine backends, quantum cloud services for accessing real quantum chips, visualization tools, and a rich set of quantum algorithm components. PyQPanda supports various quantum computing paradigms including gate-based quantum computing, variational quantum algorithms, and quantum-classical hybrid computing, making it suitable for quantum computing education, algorithm research, and practical quantum application development. ## APIs and Key Functions ### Quantum Virtual Machine Initialization Initialize and configure quantum computing backends for circuit simulation and execution. ```python from pyqpanda import * # CPU-based quantum simulator qvm = CPUQVM() qvm.init_qvm() qvm.set_configure(25, 25) # max_qubit, max_cbit # Allocate quantum and classical resources qubits = qvm.qAlloc_many(4) cbits = qvm.cAlloc_many(4) # Alternative: GPU-accelerated simulator gpu_qvm = GPUQVM() gpu_qvm.init_qvm() gpu_qvm.set_configure(25, 25) # Noise-aware simulation noise_qvm = NoiseQVM() noise_qvm.init_qvm() noise_qvm.set_configure(25, 25) # Clean up resources qvm.finalize() ``` ### Quantum Gate Operations Apply single-qubit, multi-qubit, and parameterized quantum gates to build quantum circuits. ```python from pyqpanda import * import math qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(5) cbits = qvm.cAlloc_many(5) prog = QProg() # Single-qubit gates prog << H(qubits[0]) # Hadamard prog << X(qubits[1]) # Pauli-X (NOT) prog << Y(qubits[2]) # Pauli-Y prog << Z(qubits[3]) # Pauli-Z prog << S(qubits[4]) # Phase gate prog << T(qubits[0]) # T gate # Rotation gates with parameters prog << RX(qubits[0], math.pi/4) # Rotate around X-axis prog << RY(qubits[1], math.pi/2) # Rotate around Y-axis prog << RZ(qubits[2], math.pi) # Rotate around Z-axis # Universal single-qubit gates prog << U1(qubits[0], math.pi/4) prog << U2(qubits[1], math.pi/2, -math.pi) prog << U3(qubits[2], math.pi/2, math.pi, math.pi/2) # Two-qubit gates prog << CNOT(qubits[0], qubits[1]) # Controlled-NOT prog << CZ(qubits[0], qubits[2]) # Controlled-Z prog << SWAP(qubits[1], qubits[2]) # Swap gate prog << iSWAP(qubits[3], qubits[4]) # iSWAP gate # Parameterized two-qubit gates prog << CR(qubits[0], qubits[1], math.pi/3) prog << RXX(qubits[2], qubits[3], math.pi/4) prog << RYY(qubits[1], qubits[4], math.pi/6) # Three-qubit gate prog << Toffoli(qubits[0], qubits[1], qubits[2]) # CCX gate # Execute and get results qvm.directly_run(prog) result = qvm.get_qstate() print(f"Quantum state: {result[:8]}") # First 8 amplitudes ``` ### Quantum Circuit Construction and Measurement Build quantum circuits with measurements and classical control flow. ```python from pyqpanda import * qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(3) cbits = qvm.cAlloc_many(3) # Create a Bell state circuit circuit = QCircuit() circuit << H(qubits[0]) circuit << CNOT(qubits[0], qubits[1]) # Build quantum program with measurements prog = QProg() prog << circuit prog << Measure(qubits[0], cbits[0]) prog << Measure(qubits[1], cbits[1]) prog << Measure(qubits[2], cbits[2]) # Execute with shots result = qvm.run_with_configuration(prog, shots=1000, cbit_list=cbits) print(f"Measurement results: {result}") # Output: {'000': 501, '110': 499} (approximately) # Get probability distribution without measurement prog_no_meas = QProg() prog_no_meas << circuit qvm.directly_run(prog_no_meas) prob_dict = qvm.get_prob_dict(qubits, select_max=-1) print(f"Probability distribution: {prob_dict}") # PMeasure for probability amplitudes pmeas_result = qvm.pmeasure(qubits, -1) for state, prob in pmeas_result: print(f"State |{bin(state)[2:].zfill(3)}⟩: {prob:.4f}") ``` ### Quantum Algorithms - Quantum Fourier Transform Apply Quantum Fourier Transform for phase estimation and other quantum algorithms. ```python from pyqpanda import * import math qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(4) # Prepare initial state |3⟩ = |0011⟩ prog = QProg() prog << X(qubits[0]) prog << X(qubits[1]) # Apply QFT qft_circuit = QFT(qubits) prog << qft_circuit # Execute and analyze qvm.directly_run(prog) state = qvm.get_qstate() print("QFT Result (first 8 amplitudes):") for i in range(min(8, len(state))): amplitude = state[i] print(f" |{bin(i)[2:].zfill(4)}⟩: {amplitude.real:.4f} + {amplitude.imag:.4f}i") # Inverse QFT prog_inv = QProg() prog_inv << qft_circuit prog_inv << qft_circuit.dagger() # Apply inverse qvm.directly_run(prog_inv) final_state = qvm.get_qstate() print(f"\nAfter QFT and inverse QFT: {final_state[:4]}") ``` ### Quantum Cloud Service - QCloud Submit quantum circuits to Origin Quantum's cloud platform for execution on simulators or real quantum hardware. ```python from pyqpanda import * # Initialize quantum cloud service qcloud = QCloud() qcloud.init_qvm( token="your_api_token_here", is_logged=True, use_bin_or_hex=True, enable_pqc_encryption=False ) # Build quantum circuit qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(6) prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << RY(qubits[3], 0.5) prog << CNOT(qubits[3], qubits[4]) # Full amplitude measurement on cloud result = qcloud.full_amplitude_measure( prog, shot=1000, task_name="Bell State Test" ) print(f"Cloud simulation result: {result}") # Probability measurement (no sampling) prob_result = qcloud.full_amplitude_pmeasure( prog, qubits[:3], task_name="Probability Query" ) print(f"Probability distribution: {prob_result}") # Execute on real quantum chip real_chip_result = qcloud.real_chip_measure( prog, shot=1000, chip_id=72, # Origin 72-qubit chip is_amend=True, # Apply error mitigation is_mapping=True, # Enable qubit mapping is_optimization=True # Optimize circuit ) print(f"Real chip result: {real_chip_result}") ``` ### Quantum Cloud Service - Batch Processing Submit multiple quantum circuits efficiently for parallel execution. ```python from pyqpanda import * qcloud = QCloud() qcloud.init_qvm(token="your_api_token_here") qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(4) # Create multiple quantum programs prog_array = [] # Program 1: GHZ state prog1 = QProg() prog1 << H(qubits[0]) prog1 << CNOT(qubits[0], qubits[1]) prog1 << CNOT(qubits[1], qubits[2]) prog_array.append(prog1) # Program 2: W state preparation prog2 = QProg() prog2 << RY(qubits[0], 1.91) prog2 << CNOT(qubits[0], qubits[1]) prog2 << X(qubits[0]) prog2 << CNOT(qubits[0], qubits[2]) prog_array.append(prog2) # Program 3: Random circuit prog3 = QProg() prog3 << H(qubits[0]) prog3 << H(qubits[1]) prog3 << CZ(qubits[0], qubits[2]) prog3 << RX(qubits[3], 0.7) prog_array.append(prog3) # Batch submit to real chip batch_result = qcloud.batch_real_chip_measure( prog_array, shot=1000, chip_id=72, is_amend=True, is_mapping=True, is_optimization=True ) print(f"Batch execution results:") for idx, result in enumerate(batch_result): print(f" Program {idx + 1}: {result}") ``` ### Quantum Cloud Service - Async Operations Submit long-running quantum tasks asynchronously and query results later. ```python from pyqpanda import * import time qcloud = QCloud() qcloud.init_qvm(token="your_api_token_here", is_logged=True) qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(8) # Build complex quantum circuit prog = QProg() for i in range(8): prog << H(qubits[i]) for i in range(7): prog << CNOT(qubits[i], qubits[i+1]) for i in range(8): prog << RZ(qubits[i], 0.314) # Async submit to real chip task_id = qcloud.async_real_chip_measure( prog, shot=2000, chip_id=72, is_amend=True, is_mapping=True, is_optimization=True ) print(f"Task submitted with ID: {task_id}") # Poll for task completion max_retries = 30 retry_interval = 5 # seconds for attempt in range(max_retries): result = qcloud.query_task_state_result(task_id, is_real_chip_task=True) if "status" in result: status = result["status"] print(f"Attempt {attempt + 1}: Task status = {status}") if status == "FINISHED": print(f"Task completed successfully!") print(f"Result: {result.get('result', {})}") break elif status == "FAILED": print(f"Task failed: {result.get('message', 'Unknown error')}") break time.sleep(retry_interval) else: print("Task timed out after maximum retries") ``` ### Quantum Cloud Service - Error Mitigation Apply advanced error mitigation techniques for real quantum hardware execution. ```python from pyqpanda import * qcloud = QCloud() qcloud.init_qvm(token="your_api_token_here") qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(4) # Build quantum circuit prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << CNOT(qubits[2], qubits[3]) # Define expectation values (Pauli operators) expectations = ["Z0 Z1", "X0 X1 X2", "Y0"] # PEC (Probabilistic Error Cancellation) pec_result = qcloud.pec_error_mitigation( prog, shot=2000, expectations=expectations, chip_id=72 ) print(f"PEC Error Mitigation Result: {pec_result}") # Readout Error Mitigation readout_result = qcloud.read_out_error_mitigation( prog, shot=2000, expectations=expectations, chip_id=72 ) print(f"Readout Error Mitigation Result: {readout_result}") # ZNE (Zero Noise Extrapolation) zne_result = qcloud.zne_error_mitigation( prog, shot=2000, expectations=expectations, noise_strength=[1.0, 1.5, 2.0], # Noise scaling factors chip_id=72 ) print(f"ZNE Error Mitigation Result: {zne_result}") # Get quantum state fidelity fidelity_result = qcloud.get_state_fidelity( prog, shot=1000, chip_id=72, is_amend=True, is_mapping=True ) print(f"State Fidelity: {fidelity_result}") ``` ### PilotOS Quantum Computing Platform Access PilotOS quantum operating system for direct quantum chip interaction. ```python from pyqpanda import * # Initialize PilotOS machine pilot = QPilotOSMachine() pilot.init( url="https://pilot.originqc.com.cn", log_cout=True, api_key="your_api_key_here" ) pilot.set_config(max_qubit=72, max_cbit=72) # Allocate qubits and classical bits qubits = pilot.qAlloc_many(4) cbits = pilot.cAlloc_many(4) # Build quantum circuit prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << CNOT(qubits[2], qubits[3]) # Execute on real chip (synchronous) result = pilot.real_chip_measure( prog, shot=1000, chip_id="Origin72", is_amend=True, is_mapping=True, is_optimization=True ) print(f"PilotOS execution result: {result}") # Calculate expectation value from pyqpanda import PauliOperator hamiltonian = PauliOperator("Z0 Z1", 1.0) + PauliOperator("X0 X1", 0.5) expectation = pilot.real_chip_expectation( prog, hamiltonian, qubits, shot=2000, chip_id="Origin72", is_amend=True ) print(f"Expectation value: {expectation}") # Async quantum state tomography qst_task_id = pilot.async_real_chip_qst( prog, shot=2000, chip_id="Origin72" ) print(f"QST Task ID: {qst_task_id}") # Query QST result import time time.sleep(30) # Wait for computation qst_result = pilot.get_qst_result(qst_task_id) print(f"Quantum State Tomography Result: {qst_result}") ``` ### Circuit Visualization - Text and Image Visualize quantum circuits in multiple formats including console text, images, and LaTeX. ```python from pyqpanda import * from pyqpanda.Visualization import draw_qprog qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(4) cbits = qvm.cAlloc_many(4) # Create quantum circuit prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << RY(qubits[3], 0.5) prog << CZ(qubits[0], qubits[3]) prog << Measure(qubits[0], cbits[0]) prog << Measure(qubits[1], cbits[1]) prog << Measure(qubits[2], cbits[2]) prog << Measure(qubits[3], cbits[3]) # Draw as console text (ASCII art) text_output = draw_qprog( prog, output='text', line_length=100, console_encode_type='utf8' ) print(text_output) # Draw as image file (PNG/JPG) draw_qprog( prog, output='pic', filename='quantum_circuit.png', scale=0.8, fold=30 # Gates per line before folding ) print("Circuit saved to quantum_circuit.png") # Draw as LaTeX source latex_output = draw_qprog( prog, output='latex', filename='quantum_circuit.tex', with_logo=True, line_length=100 ) print("LaTeX source saved to quantum_circuit.tex") ``` ### Probability Distribution Visualization Visualize measurement results and probability distributions. ```python from pyqpanda import * from pyqpanda.Visualization import draw_probability, draw_probability_dict qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(3) cbits = qvm.cAlloc_many(3) # Create quantum circuit prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << Measure(qubits[0], cbits[0]) prog << Measure(qubits[1], cbits[1]) prog << Measure(qubits[2], cbits[2]) # Execute with shots result = qvm.run_with_configuration(prog, shots=1000, cbit_list=cbits) print(f"Measurement results: {result}") # Draw probability from measurement results draw_probability(result) # Displays bar chart # Get probability distribution without measurement prog_no_meas = QProg() prog_no_meas << H(qubits[0]) prog_no_meas << CNOT(qubits[0], qubits[1]) prog_no_meas << CNOT(qubits[1], qubits[2]) qvm.directly_run(prog_no_meas) prob_dict = qvm.get_prob_dict(qubits, select_max=-1) # Draw probability distribution draw_probability_dict(prob_dict) # Displays bar chart print(f"Probability distribution: {prob_dict}") ``` ### Quantum State Visualization - Bloch Sphere Visualize quantum states on the Bloch sphere for single and multi-qubit systems. ```python from pyqpanda import * from pyqpanda.Visualization import ( plot_bloch_circuit, plot_bloch_vector, plot_bloch_multivector ) import math qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(3) # Create quantum circuit prog = QProg() prog << RY(qubits[0], math.pi/4) prog << RX(qubits[1], math.pi/3) prog << H(qubits[2]) # Visualize circuit evolution on Bloch sphere (animated) plot_bloch_circuit( prog, trace=True, # Show trajectory saveas='bloch_evolution.gif' ) # Get quantum state qvm.directly_run(prog) state = qvm.get_qstate() # Plot multi-qubit state on separate Bloch spheres plot_bloch_multivector( state, title="Three-Qubit State Visualization" ) # Single Bloch vector (for single qubit) # Bloch vector: [x, y, z] bloch_vector = [0.707, 0, 0.707] # |+⟩ state plot_bloch_vector( bloch_vector, title="Single Qubit on Bloch Sphere" ) ``` ### Quantum State Visualization - Density Matrix Visualize quantum states as 3D city plots and density matrices. ```python from pyqpanda import * from pyqpanda.Visualization import ( state_to_density_matrix, plot_state_city, plot_density_matrix ) qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(3) # Create quantum circuit (GHZ state) prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) qvm.directly_run(prog) state = qvm.get_qstate() # 3D city plot of quantum state amplitudes plot_state_city( state, title="GHZ State - Amplitude Distribution", figsize=(10, 8), color='blue' ) # Convert to density matrix density_matrix = state_to_density_matrix(state) print(f"Density matrix shape: {density_matrix.shape}") # Visualize density matrix as heatmap plot_density_matrix( density_matrix, title="GHZ State - Density Matrix", figsize=(10, 8) ) ``` ### Utility Functions for Quantum Programming Helper functions for common quantum operations and state analysis. ```python from pyqpanda import * from pyqpanda.utils import ( single_gate_apply_to_all, meas_all, get_fidelity ) qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(5) cbits = qvm.cAlloc_many(5) # Apply Hadamard gate to all qubits prog = QProg() hadamard_circuit = single_gate_apply_to_all(H, qubits) prog << hadamard_circuit # Measure all qubits meas_prog = meas_all(qubits, cbits) prog << meas_prog # Execute result = qvm.run_with_configuration(prog, shots=1000, cbit_list=cbits) print(f"Measurement results: {result}") # Calculate fidelity with target result target_result = { '00000': 31.25, '00001': 31.25, '00010': 31.25, '00011': 31.25, '00100': 31.25, # ... other uniform distribution entries } fidelity = get_fidelity(result, shots=1000, target_result=target_result) print(f"Fidelity with target state: {fidelity:.4f}") # Apply rotation gate with angle from pyqpanda.utils import single_gate prog2 = QProg() prog2 << single_gate(RY, qubits[0], angle=0.785) prog2 << single_gate(RX, qubits[1], angle=1.57) prog2 << single_gate(H, qubits[2]) # No angle needed qvm.directly_run(prog2) state = qvm.get_qstate() print(f"State after gates: {state[:4]}") ``` ### Quantum Circuit Conversion Convert quantum circuits between different formats including OriginIR, QASM, and Quil. ```python from pyqpanda import * qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(3) cbits = qvm.cAlloc_many(3) # Build quantum circuit prog = QProg() prog << H(qubits[0]) prog << CNOT(qubits[0], qubits[1]) prog << CNOT(qubits[1], qubits[2]) prog << Measure(qubits[0], cbits[0]) prog << Measure(qubits[1], cbits[1]) prog << Measure(qubits[2], cbits[2]) # Convert to OriginIR (native format) originir = convert_qprog_to_originir(prog, qvm) print("OriginIR:") print(originir) print() # Convert to OpenQASM 2.0 qasm = convert_qprog_to_qasm(prog, qvm) print("OpenQASM 2.0:") print(qasm) print() # Convert to Quil quil = convert_qprog_to_quil(prog, qvm) print("Quil:") print(quil) print() # Convert back from QASM to QProg qasm_code = """ OPENQASM 2.0; include "qelib1.inc"; qreg q[3]; creg c[3]; h q[0]; cx q[0],q[1]; cx q[1],q[2]; measure q[0] -> c[0]; measure q[1] -> c[1]; measure q[2] -> c[2]; """ prog_from_qasm = convert_qasm_to_qprog(qasm_code, qvm) result = qvm.run_with_configuration(prog_from_qasm, shots=1000, cbit_list=cbits) print(f"Execution result from QASM: {result}") ``` ### Grover's Search Algorithm Implement quantum search algorithm for finding marked items in unsorted database. ```python from pyqpanda import * qvm = CPUQVM() qvm.init_qvm() # Define search space: 2^n elements n_qubits = 4 # Search space of 16 elements qubits = qvm.qAlloc_many(n_qubits) cbits = qvm.cAlloc_many(n_qubits) # Target to find: element |1010⟩ (10 in decimal) target_list = [10] # Classical condition (not used in this example) classical_cond = cbits[0] == cbits[0] # Number of Grover iterations (optimal: π/4 * sqrt(N/M)) # N = 16 elements, M = 1 target optimal_iterations = 3 # Run Grover's algorithm result = Grover_search( target_list, classical_cond, qvm, repeat=optimal_iterations ) print(f"Grover's Algorithm Result: {result}") print(f"Target element: {target_list[0]} (binary: {bin(target_list[0])[2:].zfill(n_qubits)})") # Verify by building Grover circuit manually prog = QProg() # Initialize to uniform superposition for q in qubits: prog << H(q) # Oracle: mark target state |1010⟩ prog << X(qubits[0]) prog << X(qubits[2]) prog << Toffoli(qubits[0], qubits[1], qubits[3]) # Simplified oracle prog << X(qubits[0]) prog << X(qubits[2]) # Diffusion operator for q in qubits: prog << H(q) for q in qubits: prog << X(q) prog << H(qubits[n_qubits-1]) # Multi-controlled NOT (simplified) prog << H(qubits[n_qubits-1]) for q in qubits: prog << X(q) for q in qubits: prog << H(q) # Measure for i in range(n_qubits): prog << Measure(qubits[i], cbits[i]) result_manual = qvm.run_with_configuration(prog, shots=1000, cbit_list=cbits) print(f"Manual Grover execution result: {result_manual}") ``` ### Variational Quantum Eigensolver (VQE) Implement VQE for finding ground state energy of quantum systems. ```python from pyqpanda import * import numpy as np qvm = CPUQVM() qvm.init_qvm() qubits = qvm.qAlloc_many(2) # Define Hamiltonian: H = 0.5 * Z0 + 0.3 * Z1 - 0.2 * X0*X1 from pyqpanda import PauliOperator hamiltonian = ( PauliOperator("Z0", 0.5) + PauliOperator("Z1", 0.3) + PauliOperator("X0 X1", -0.2) ) # Parameterized ansatz circuit def create_ansatz(qubits, params): """Create variational ansatz with parameters""" circuit = QCircuit() circuit << RY(qubits[0], params[0]) circuit << RY(qubits[1], params[1]) circuit << CNOT(qubits[0], qubits[1]) circuit << RY(qubits[0], params[2]) circuit << RY(qubits[1], params[3]) return circuit # Cost function for optimization def cost_function(params): """Calculate expectation value of Hamiltonian""" prog = QProg() prog << create_ansatz(qubits, params) qvm.directly_run(prog) # Calculate expectation manually state = qvm.get_qstate() # Simplified expectation calculation # In practice, use get_expectation from cloud service energy = 0.0 # Z0 term: ⟨ψ|Z0|ψ⟩ energy += 0.5 * (abs(state[0])**2 + abs(state[1])**2 - abs(state[2])**2 - abs(state[3])**2) # Z1 term: ⟨ψ|Z1|ψ⟩ energy += 0.3 * (abs(state[0])**2 - abs(state[1])**2 + abs(state[2])**2 - abs(state[3])**2) return energy # Optimization using classical optimizer from scipy.optimize import minimize initial_params = np.random.rand(4) * 2 * np.pi result = minimize( cost_function, initial_params, method='COBYLA', options={'maxiter': 100} ) print(f"Optimal parameters: {result.x}") print(f"Ground state energy: {result.fun:.6f}") # Verify final state final_prog = QProg() final_prog << create_ansatz(qubits, result.x) qvm.directly_run(final_prog) final_state = qvm.get_qstate() print(f"Ground state amplitudes: {final_state}") ``` ## Summary PyQPanda provides a comprehensive quantum computing toolkit for researchers, educators, and developers working with quantum algorithms and quantum hardware. The framework excels in educational contexts, quantum algorithm prototyping, hybrid quantum-classical workflows, and real quantum hardware access through cloud services. Its multiple backend simulators enable efficient development cycles, from rapid prototyping on CPU simulators to large-scale simulations on GPU clusters, culminating in deployment on real quantum chips through the Origin Quantum cloud platform. The library's integration patterns support end-to-end quantum application development workflows including algorithm design using high-level quantum gates and circuits, local testing with various simulator backends, circuit optimization and compilation for target hardware, cloud-based execution on real quantum processors with error mitigation, comprehensive result visualization and analysis, and seamless conversion between quantum circuit formats. PyQPanda's rich ecosystem of quantum algorithm components (QFT, Grover, Shor, VQE, QAOA), combined with its visualization tools and cloud service integration, makes it suitable for quantum computing education, quantum algorithm research, variational quantum computing applications, quantum machine learning experiments, and production quantum computing workflows.