PyQPanda Tutorial (originq/pyqpanda-toturial)

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
Show doc for...
Context Summary (auto-generated)
Raw
# 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.