Qiskit - Quantum Computing Framework
Open-source quantum computing framework for building, simulating, and running quantum algorithms on quantum computers and simulators.
When to Use
- Building quantum circuits and gates
- Running quantum algorithms (VQE, QAOA, Grover, Shor)
- Quantum chemistry calculations (integration with PySCF)
- Quantum machine learning
- Quantum simulation and noise modeling
- Transpiling circuits for real quantum hardware
- Quantum optimization problems
- Quantum error correction
- Quantum cryptography
- Educational quantum computing demonstrations
Reference Documentation
Official docs: https://qiskit.org/documentation/
Search patterns: qiskit.circuit.QuantumCircuit, qiskit.algorithms.VQE, qiskit.quantum_info, qiskit_nature
Core Principles
Use Qiskit For
| Task |
Module |
Example |
| Circuit building |
qiskit |
QuantumCircuit(2, 2) |
| Quantum algorithms |
qiskit.algorithms |
VQE(ansatz, optimizer) |
| Quantum simulation |
qiskit.providers.aer |
AerSimulator() |
| Quantum chemistry |
qiskit_nature |
GroundStateEigensolver() |
| Noise modeling |
qiskit.providers.aer.noise |
NoiseModel() |
| Transpilation |
qiskit.transpiler |
transpile(circuit, backend) |
| Quantum ML |
qiskit_machine_learning |
VQC(feature_map, ansatz) |
| Visualization |
qiskit.visualization |
plot_histogram(counts) |
Do NOT Use For
- Classical machine learning (use scikit-learn, PyTorch)
- Classical optimization (use SciPy)
- General numerical computing (use NumPy)
- Classical cryptography (use cryptography package)
- Large-scale classical simulation (use classical simulators)
Quick Reference
Installation
# Core Qiskit
pip install qiskit
# With visualization tools
pip install qiskit[visualization]
# Quantum chemistry extension
pip install qiskit-nature qiskit-nature-pyscf
# Machine learning extension
pip install qiskit-machine-learning
# Optimization extension
pip install qiskit-optimization
# Full installation
pip install 'qiskit[all]' qiskit-nature qiskit-machine-learning qiskit-optimization
Standard Imports
# Core imports
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import transpile, assemble
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram, plot_bloch_multivector
# Quantum algorithms
from qiskit.algorithms import VQE, QAOA, Grover, Shor
from qiskit.algorithms.optimizers import SLSQP, COBYLA, SPSA
# Quantum info
from qiskit.quantum_info import Statevector, DensityMatrix, Operator
from qiskit.quantum_info import entropy, entanglement_of_formation
# Circuit library
from qiskit.circuit.library import QFT, RealAmplitudes, EfficientSU2
Basic Pattern - Circuit Building
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
# Create circuit
qc = QuantumCircuit(2, 2)
# Add gates
qc.h(0) # Hadamard on qubit 0
qc.cx(0, 1) # CNOT from 0 to 1
# Measure
qc.measure([0, 1], [0, 1])
# Simulate
simulator = AerSimulator()
job = simulator.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(f"Results: {counts}")
Basic Pattern - Quantum Algorithm
from qiskit import QuantumCircuit
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
# Define Hamiltonian
hamiltonian = SparsePauliOp(['ZZ', 'IZ', 'ZI'], coeffs=[1.0, -0.5, -0.5])
# Create ansatz
ansatz = RealAmplitudes(num_qubits=2, reps=1)
# Setup VQE
optimizer = SLSQP(maxiter=100)
estimator = Estimator()
vqe = VQE(estimator, ansatz, optimizer)
# Run
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(f"Ground state energy: {result.eigenvalue:.6f}")
Critical Rules
✅ DO
- Use simulators for development - Test on simulators before real hardware
- Transpile for target backend - Always transpile circuits for specific hardware
- Handle measurement statistics - Work with shot counts, not single results
- Use primitives for algorithms - Use Estimator/Sampler primitives
- Check circuit depth - Monitor gate count and depth for real hardware
- Implement error mitigation - Use error mitigation for noisy hardware
- Validate quantum states - Check state validity and normalization
- Use appropriate basis gates - Match hardware native gates
- Set random seed for reproducibility - Use seed for consistent results
- Monitor job status - Check if quantum jobs complete successfully
❌ DON'T
- Ignore hardware constraints - Real quantum computers have limitations
- Use too many qubits on simulators - Memory grows exponentially
- Forget to measure - Quantum states collapse on measurement
- Mix classical and quantum incorrectly - Understand measurement timing
- Ignore decoherence - Quantum states decay over time
- Over-transpile - Unnecessary transpilation adds gates
- Assume perfect gates - Real gates have errors
- Ignore topology - Not all qubits are connected
- Use deprecated APIs - Qiskit evolves rapidly
- Run without error handling - Quantum jobs can fail
Anti-Patterns (NEVER)
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
from qiskit.primitives import Estimator
# ❌ BAD: No measurement
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
# Forgot qc.measure()!
# ✅ GOOD: Always measure when needed
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
# ❌ BAD: Using deprecated execute()
from qiskit import execute
result = execute(qc, backend, shots=1024).result()
# ✅ GOOD: Use new run() method
simulator = AerSimulator()
job = simulator.run(qc, shots=1024)
result = job.result()
# ❌ BAD: Assuming perfect measurement
counts = result.get_counts()
# Assuming exactly 50/50 split!
assert counts['00'] == 512
# ✅ GOOD: Handle statistical variation
counts = result.get_counts()
ratio = counts.get('00', 0) / sum(counts.values())
print(f"Measured |00⟩ with probability {ratio:.3f}")
# ❌ BAD: Not checking circuit properties
qc = QuantumCircuit(20) # Many qubits!
# Adding many gates...
# Trying to simulate without checking depth/size!
# ✅ GOOD: Check circuit properties
qc = QuantumCircuit(20)
# ... add gates ...
print(f"Circuit depth: {qc.depth()}")
print(f"Gate count: {len(qc.data)}")
print(f"Qubits: {qc.num_qubits}")
# ❌ BAD: Ignoring transpilation
job = backend.run(qc) # May fail on real hardware!
# ✅ GOOD: Transpile for backend
from qiskit import transpile
transpiled_qc = transpile(qc, backend=backend, optimization_level=3)
job = backend.run(transpiled_qc)
Quantum Circuits (qiskit.QuantumCircuit)
Basic Circuit Construction
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
# Method 1: Simple initialization
qc = QuantumCircuit(3, 3) # 3 qubits, 3 classical bits
# Method 2: Using registers
qr = QuantumRegister(3, 'q')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qr, cr)
# Method 3: Multiple registers
qr1 = QuantumRegister(2, 'data')
qr2 = QuantumRegister(1, 'ancilla')
cr = ClassicalRegister(2, 'meas')
qc = QuantumCircuit(qr1, qr2, cr)
print(f"Number of qubits: {qc.num_qubits}")
print(f"Number of classical bits: {qc.num_clbits}")
print(f"Circuit depth: {qc.depth()}")
Single-Qubit Gates
from qiskit import QuantumCircuit
import numpy as np
qc = QuantumCircuit(1)
# Pauli gates
qc.x(0) # Pauli X (NOT gate)
qc.y(0) # Pauli Y
qc.z(0) # Pauli Z
# Hadamard gate
qc.h(0) # Creates superposition
# Phase gates
qc.s(0) # S gate (π/2 phase)
qc.t(0) # T gate (π/4 phase)
qc.sdg(0) # S dagger
qc.tdg(0) # T dagger
# Rotation gates
qc.rx(np.pi/4, 0) # Rotation around X
qc.ry(np.pi/4, 0) # Rotation around Y
qc.rz(np.pi/4, 0) # Rotation around Z
# General rotation
qc.u(np.pi/4, np.pi/2, np.pi, 0) # U gate
# Identity (wait)
qc.id(0)
print(f"Gate count: {len(qc.data)}")
Two-Qubit Gates
from qiskit import QuantumCircuit
import numpy as np
qc = QuantumCircuit(2)
# CNOT (Controlled-NOT)
qc.cx(0, 1) # Control: 0, Target: 1
# Other controlled gates
qc.cy(0, 1) # Controlled-Y
qc.cz(0, 1) # Controlled-Z
qc.ch(0, 1) # Controlled-Hadamard
# SWAP gate
qc.swap(0, 1)
# Controlled phase
qc.cp(np.pi/4, 0, 1)
# Controlled-U
qc.cu(np.pi/4, np.pi/2, np.pi, 0, 0, 1)
# Toffoli (CCX) - needs 3 qubits
qc_3 = QuantumCircuit(3)
qc_3.ccx(0, 1, 2) # Controls: 0,1, Target: 2
print(qc.draw())
Creating Entanglement
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
from qiskit.quantum_info import Statevector
# Bell state (maximally entangled)
def create_bell_state():
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
return qc
bell = create_bell_state()
state = Statevector.from_instruction(bell)
print(f"Bell state: {state}")
# GHZ state (3-qubit entanglement)
def create_ghz_state(n):
qc = QuantumCircuit(n)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
return qc
ghz = create_ghz_state(3)
state_ghz = Statevector.from_instruction(ghz)
print(f"GHZ state: {state_ghz}")
# W state (another type of 3-qubit entanglement)
def create_w_state():
qc = QuantumCircuit(3)
qc.ry(1.9106, 0)
qc.ch(0, 1)
qc.x(0)
qc.cy(0, 1)
qc.ccx(0, 1, 2)
qc.x(0)
return qc
w = create_w_state()
print(f"W state circuit depth: {w.depth()}")
Parameterized Circuits
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter, ParameterVector
import numpy as np
# Single parameter
theta = Parameter('θ')
qc = QuantumCircuit(1)
qc.ry(theta, 0)
# Bind parameter
bound_qc = qc.bind_parameters({theta: np.pi/4})
print(f"Unbound: {qc}")
print(f"Bound: {bound_qc}")
# Multiple parameters
params = ParameterVector('θ', 4)
qc_param = QuantumCircuit(2)
qc_param.ry(params[0], 0)
qc_param.ry(params[1], 1)
qc_param.cx(0, 1)
qc_param.ry(params[2], 0)
qc_param.ry(params[3], 1)
# Bind all parameters
values = [np.pi/4, np.pi/3, np.pi/2, np.pi/6]
bound = qc_param.bind_parameters(dict(zip(params, values)))
print(f"Number of parameters: {qc_param.num_parameters}")
Quantum Algorithms
Variational Quantum Eigensolver (VQE)
from qiskit import QuantumCircuit
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP, COBYLA
from qiskit.circuit.library import RealAmplitudes, EfficientSU2
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
import numpy as np
# Define Hamiltonian (e.g., H2 molecule)
# H = -1.05 * ZZ + 0.39 * XX - 0.39 * YY - 0.01 * ZI
hamiltonian = SparsePauliOp(
['ZZ', 'XX', 'YY', 'ZI', 'IZ'],
coeffs=[-1.05, 0.39, -0.39, -0.01, -0.01]
)
# Create ansatz (variational form)
ansatz = RealAmplitudes(num_qubits=2, reps=2)
# Alternative: EfficientSU2
# ansatz = EfficientSU2(num_qubits=2, reps=2)
# Setup optimizer
optimizer = SLSQP(maxiter=100)
# Create estimator primitive
estimator = Estimator()
# Setup and run VQE
vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(f"Ground state energy: {result.eigenvalue:.6f}")
print(f"Optimal parameters: {result.optimal_parameters}")
print(f"Optimizer evaluations: {result.cost_function_evals}")
# Get optimal circuit
optimal_circuit = ansatz.bind_parameters(result.optimal_point)
print(f"\nOptimal circuit depth: {optimal_circuit.depth()}")
QAOA (Quantum Approximate Optimization Algorithm)
from qiskit import QuantumCircuit
from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit.quantum_info import SparsePauliOp
import numpy as np
# Max-Cut problem on a triangle graph
# Cost Hamiltonian: H = (1-Z0*Z1)/2 + (1-Z1*Z2)/2 + (1-Z0*Z2)/2
cost_hamiltonian = SparsePauliOp(
['ZZ', 'ZI', 'IZ'],
coeffs=[0.5, -0.5, -0.5]
)
# Setup QAOA
optimizer = COBYLA(maxiter=100)
sampler = Sampler()
qaoa = QAOA(sampler, optimizer, reps=2)
# Run QAOA
result = qaoa.compute_minimum_eigenvalue(cost_hamiltonian)
print(f"Optimal objective: {result.eigenvalue:.6f}")
print(f"Optimal parameters: {result.optimal_parameters}")
# Most probable solution
from qiskit.result import QuasiDistribution
prob_dist = result.eigenstate
if isinstance(prob_dist, QuasiDistribution):
most_likely = max(prob_dist, key=prob_dist.get)
print(f"Most likely solution: {bin(most_likely)[2:].zfill(2)}")
Grover's Algorithm (Quantum Search)
from qiskit import QuantumCircuit
from qiskit.algorithms import Grover, AmplificationProblem
from qiskit.circuit.library import GroverOperator
from qiskit.primitives import Sampler
import numpy as np
def grover_search(marked_states, n_qubits):
"""
Grover's algorithm to find marked states.
Args:
marked_states: List of marked states (e.g., ['101', '110'])
n_qubits: Number of qubits
"""
# Create oracle that marks the target states
oracle = QuantumCircuit(n_qubits)
# Mark state |101⟩ by flipping phase
if '101' in marked_states:
oracle.x([0, 2]) # Flip to make 101 -> 111
oracle.h(2)
oracle.ccx(0, 1, 2)
oracle.h(2)
oracle.x([0, 2]) # Flip back
# Grover diffusion operator
diffusion = QuantumCircuit(n_qubits)
diffusion.h(range(n_qubits))
diffusion.x(range(n_qubits))
diffusion.h(n_qubits - 1)
diffusion.mcx(list(range(n_qubits - 1)), n_qubits - 1)
diffusion.h(n_qubits - 1)
diffusion.x(range(n_qubits))
diffusion.h(range(n_qubits))
# Complete Grover iteration
grover_op = oracle.compose(diffusion)
# Setup and run
problem = AmplificationProblem(oracle, is_good_state=marked_states)
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
return result
# Example: Search for |101⟩ in 3-qubit space
result = grover_search(['101'], 3)
print(f"Top measurement: {result.top_measurement}")
print(f"Oracle evaluations: {result.oracle_evaluation}")
# Simpler example: 2-qubit search
qc = QuantumCircuit(2, 2)
qc.h([0, 1]) # Superposition
# Oracle marks |11⟩
qc.cz(0, 1)
# Diffusion
qc.h([0, 1])
qc.x([0, 1])
qc.cz(0, 1)
qc.x([0, 1])
qc.h([0, 1])
qc.measure([0, 1], [0, 1])
from qiskit.providers.aer import AerSimulator
simulator = AerSimulator()
job = simulator.run(qc, shots=1000)
counts = job.result().get_counts()
print(f"Grover results: {counts}")
Quantum Phase Estimation (QPE)
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
from qiskit.providers.aer import AerSimulator
import numpy as np
def quantum_phase_estimation(unitary, n_counting_qubits):
"""
Estimate the phase of an eigenstate of a unitary operator.
Args:
unitary: Unitary operator as a QuantumCircuit
n_counting_qubits: Precision qubits
"""
n_system_qubits = unitary.num_qubits
qc = QuantumCircuit(n_counting_qubits + n_system_qubits, n_counting_qubits)
# Initialize eigenstate (simplified: use |1⟩)
qc.x(n_counting_qubits)
# Hadamard on counting qubits
for i in range(n_counting_qubits):
qc.h(i)
# Controlled-U^(2^i) operations
repetitions = 1
for counting_qubit in range(n_counting_qubits):
for _ in range(repetitions):
qc.append(unitary.control(), [counting_qubit] +
list(range(n_counting_qubits, n_counting_qubits + n_system_qubits)))
repetitions *= 2
# Inverse QFT
qc.append(QFT(n_counting_qubits, inverse=True), range(n_counting_qubits))
# Measure counting qubits
qc.measure(range(n_counting_qubits), range(n_counting_qubits))
return qc
# Example: Phase estimation for T gate (phase π/4)
t_gate = QuantumCircuit(1)
t_gate.t(0)
qpe_circuit = quantum_phase_estimation(t_gate, n_counting_qubits=3)
simulator = AerSimulator()
job = simulator.run(qpe_circuit, shots=1000)
counts = job.result().get_counts()
print(f"Phase estimation results: {counts}")
# Most common result gives phase
most_common = max(counts, key=counts.get)
phase_estimate = int(most_common, 2) / (2**3)
print(f"Estimated phase: {phase_estimate * 2 * np.pi:.4f} rad")
print(f"True phase: {np.pi/4:.4f} rad")
Quantum Chemistry with Qiskit Nature
Molecular Ground State Calculation
# Requires: pip install qiskit-nature qiskit-nature-pyscf
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper, ParityMapper
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
import numpy as np
# Define molecule (H2)
driver = PySCFDriver(
atom='H 0 0 0; H 0 0 0.735',
basis='sto3g',
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM
)
# Get problem
problem = driver.run()
hamiltonian = problem.hamiltonian.second_q_op()
# Map to qubits
mapper = JordanWignerMapper()
qubit_op = mapper.map(hamiltonian)
print(f"Number of qubits required: {qubit_op.num_qubits}")
# Initial state (Hartree-Fock)
num_particles = problem.num_particles
num_spatial_orbitals = problem.num_spatial_orbitals
init_state = HartreeFock(
num_spatial_orbitals=num_spatial_orbitals,
num_particles=num_particles,
qubit_mapper=mapper
)
# Ansatz (UCCSD)
ansatz = UCCSD(
num_spatial_orbitals=num_spatial_orbitals,
num_particles=num_particles,
qubit_mapper=mapper,
initial_state=init_state
)
# VQE calculation
optimizer = SLSQP(maxiter=100)
estimator = Estimator()
vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(qubit_op)
print(f"\nVQE Ground State Energy: {result.eigenvalue:.6f} Ha")
print(f"Reference HF energy: {problem.reference_energy:.6f} Ha")
Excited States Calculation
from qiskit_nature.second_q.algorithms import GroundStateEigensolver, ExcitedStatesEigensolver
from qiskit_nature.second_q.algorithms import QEOM
from qiskit_nature.second_q.mappers import JordanWignerMapper
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
# Setup molecule
driver = PySCFDriver(atom='H 0 0 0; H 0 0 0.735', basis='sto3g')
problem = driver.run()
# Mapper
mapper = JordanWignerMapper()
# Ground state solver
optimizer = SLSQP(maxiter=100)
estimator = Estimator()
# Simple ansatz for demonstration
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=4, reps=2)
vqe = VQE(estimator, ansatz, optimizer)
ground_solver = GroundStateEigensolver(mapper, vqe)
# Calculate ground state
ground_result = ground_solver.solve(problem)
print(f"Ground state energy: {ground_result.total_energies[0]:.6f} Ha")
# Excited states with QEOM
qeom = QEOM(ground_solver, 'sd') # singles and doubles
excited_solver = ExcitedStatesEigensolver(mapper, qeom)
# Calculate excited states
excited_result = excited_solver.solve(problem)
print(f"\nExcited state energies:")
for i, energy in enumerate(excited_result.total_energies):
print(f"State {i}: {energy:.6f} Ha")
Molecular Potential Energy Surface
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit.circuit.library import RealAmplitudes
import numpy as np
def calculate_pes(distances, molecule_template, basis='sto3g'):
"""
Calculate potential energy surface for a diatomic molecule.
Args:
distances: Array of interatomic distances
molecule_template: Molecule string with {} for distance
basis: Basis set
"""
energies = []
for distance in distances:
# Setup molecule at this distance
atom_string = molecule_template.format(distance)
driver = PySCFDriver(atom=atom_string, basis=basis)
problem = driver.run()
# Map to qubits
mapper = JordanWignerMapper()
# Simple VQE calculation
ansatz = RealAmplitudes(num_qubits=4, reps=1)
optimizer = SLSQP(maxiter=50)
estimator = Estimator()
vqe = VQE(estimator, ansatz, optimizer)
solver = GroundStateEigensolver(mapper, vqe)
# Calculate energy
result = solver.solve(problem)
energies.append(result.total_energies[0])
print(f"Distance {distance:.2f} Å: Energy = {energies[-1]:.6f} Ha")
return np.array(energies)
# Calculate PES for H2
distances = np.linspace(0.5, 2.5, 5) # Angstroms
molecule_template = 'H 0 0 0; H 0 0 {}'
energies = calculate_pes(distances, molecule_template)
# Find equilibrium bond length
min_idx = np.argmin(energies)
print(f"\nEquilibrium bond length: {distances[min_idx]:.2f} Å")
print(f"Minimum energy: {energies[min_idx]:.6f} Ha")
Quantum Simulation
Hamiltonian Simulation with Trotter
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp, Statevector
from qiskit.synthesis import SuzukiTrotter
import numpy as np
def trotter_simulation(hamiltonian, time, n_steps):
"""
Simulate time evolution under Hamiltonian using Trotter decomposition.
Args:
hamiltonian: SparsePauliOp Hamiltonian
time: Total evolution time
n_steps: Number of Trotter steps
"""
dt = time / n_steps
# Create Trotter circuit
n_qubits = hamiltonian.num_qubits
qc = QuantumCircuit(n_qubits)
# Initial state (e.g., |0⟩)
# Apply Trotter steps
for _ in range(n_steps):
# For each Pauli term in Hamiltonian
for pauli, coeff in zip(hamiltonian.paulis, hamiltonian.coeffs):
# Apply exp(-i * coeff * dt * pauli)
angle = 2 * float(coeff.real) * dt
# Simple implementation for single Pauli terms
pauli_str = str(pauli)
# Apply appropriate rotation
if 'Z' in pauli_str and pauli_str.count('I') == n_qubits - 1:
idx = pauli_str.index('Z')
qc.rz(angle, n_qubits - 1 - idx)
elif 'X' in pauli_str and pauli_str.count('I') == n_qubits - 1:
idx = pauli_str.index('X')
qc.rx(angle, n_qubits - 1 - idx)
return qc
# Example: Ising model Hamiltonian
hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5])
# Simulate for time t=1.0 with 10 Trotter steps
qc = trotter_simulation(hamiltonian, time=1.0, n_steps=10)
print(f"Trotter circuit depth: {qc.depth()}")
print(f"Gate count: {len(qc.data)}")
# Get final state
state = Statevector.from_instruction(qc)
print(f"Final state vector: {state[:4]}") # First 4 amplitudes
Variational Quantum Simulation
from qiskit import QuantumCircuit
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
import numpy as np
def simulate_dynamics(hamiltonian, initial_state_circuit, times, ansatz_reps=2):
"""
Simulate quantum dynamics using VQE at different times.
Args:
hamiltonian: Time-evolution Hamiltonian
initial_state_circuit: Circuit preparing initial state
times: Array of times to simulate
ansatz_reps: Repetitions in ansatz
"""
n_qubits = hamiltonian.num_qubits
results = []
for t in times:
# Time-evolved Hamiltonian: H(t) = exp(-iHt) ρ(0) exp(iHt)
# Approximate with VQE
ansatz = RealAmplitudes(num_qubits=n_qubits, reps=ansatz_reps)
# Combine initial state + ansatz
full_circuit = initial_state_circuit.copy()
full_circuit.compose(ansatz, inplace=True)
optimizer = SLSQP(maxiter=100)
estimator = Estimator()
vqe = VQE(estimator, full_circuit, optimizer)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
results.append({
'time': t,
'energy': result.eigenvalue,
'parameters': result.optimal_parameters
})
print(f"Time {t:.2f}: Energy = {result.eigenvalue:.6f}")
return results
# Example: Simulate Heisenberg model
hamiltonian = SparsePauliOp(
['XX', 'YY', 'ZZ'],
coeffs=[0.5, 0.5, 0.5]
)
# Initial state: |01⟩
initial_state = QuantumCircuit(2)
initial_state.x(1)
# Simulate at different times
times = np.linspace(0, 2, 5)
results = simulate_dynamics(hamiltonian, initial_state, times)
Quantum Machine Learning
Quantum Kernel Method
# Requires: pip install qiskit-machine-learning
from qiskit_machine_learning.kernels import FidelityQuantumKernel
from qiskit.circuit.library import ZZFeatureMap
from qiskit.primitives import Sampler
from sklearn.svm import SVC
import numpy as np
# Generate synthetic data
np.random.seed(42)
X_train = np.random.rand(20, 2) * 2 * np.pi
y_train = (X_train[:, 0] + X_train[:, 1] > np.pi).astype(int)
X_test = np.random.rand(10, 2) * 2 * np.pi
y_test = (X_test[:, 0] + X_test[:, 1] > np.pi).astype(int)
# Create feature map
feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
# Create quantum kernel
sampler = Sampler()
quantum_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=sampler)
# Compute kernel matrix
kernel_matrix_train = quantum_kernel.evaluate(x_vec=X_train)
kernel_matrix_test = quantum_kernel.evaluate(x_vec=X_test, y_vec=X_train)
print(f"Training kernel matrix shape: {kernel_matrix_train.shape}")
print(f"Test kernel matrix shape: {kernel_matrix_test.shape}")
# Use with SVM
svc = SVC(kernel='precomputed')
svc.fit(kernel_matrix_train, y_train)
# Predict
predictions = svc.predict(kernel_matrix_test)
accuracy = np.mean(predictions == y_test)
print(f"\nQuantum Kernel SVM Accuracy: {accuracy:.2%}")
Variational Quantum Classifier (VQC)
from qiskit_machine_learning.algorithms import VQC
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
import numpy as np
# Generate training data
np.random.seed(42)
X_train = np.random.rand(40, 2) * 2 - 1 # [-1, 1]
y_train = (X_train[:, 0]**2 + X_train[:, 1]**2 < 0.5).astype(int)
X_test = np.random.rand(20, 2) * 2 - 1
y_test = (X_test[:, 0]**2 + X_test[:, 1]**2 < 0.5).astype(int)
# Feature map
feature_map = ZZFeatureMap(2)
# Ansatz
ansatz = RealAmplitudes(2, reps=2)
# Create VQC
optimizer = COBYLA(maxiter=100)
sampler = Sampler()
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
)
# Train
vqc.fit(X_train, y_train)
# Predict
train_score = vqc.score(X_train, y_train)
test_score = vqc.score(X_test, y_test)
print(f"Training accuracy: {train_score:.2%}")
print(f"Test accuracy: {test_score:.2%}")
# Predictions
predictions = vqc.predict(X_test)
print(f"Sample predictions: {predictions[:5]}")
print(f"True labels: {y_test[:5]}")
Quantum Neural Network (QNN)
from qiskit_machine_learning.neural_networks import SamplerQNN
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.circuit.library import RealAmplitudes
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
import numpy as np
# Create parameterized quantum circuit
def create_qnn_circuit(num_qubits, num_features):
qc = QuantumCircuit(num_qubits)
# Feature map parameters
feature_params = [Parameter(f'x{i}') for i in range(num_features)]
# Encode features
for i, param in enumerate(feature_params):
if i < num_qubits:
qc.ry(param, i)
# Variational part
ansatz = RealAmplitudes(num_qubits, reps=1)
qc.compose(ansatz, inplace=True)
return qc, feature_params, ansatz.parameters
num_qubits = 2
num_features = 2
qc, feature_params, weight_params = create_qnn_circuit(num_qubits, num_features)
# Create QNN
sampler = Sampler()
qnn = SamplerQNN(
circuit=qc,
input_params=feature_params,
weight_params=weight_params,
sampler=sampler,
)
# Create classifier
optimizer = COBYLA(maxiter=50)
classifier = NeuralNetworkClassifier(
neural_network=qnn,
optimizer=optimizer,
)
# Training data
X_train = np.random.rand(30, 2)
y_train = (X_train[:, 0] > X_train[:, 1]).astype(int)
# Train
classifier.fit(X_train, y_train)
# Test
X_test = np.random.rand(10, 2)
y_test = (X_test[:, 0] > X_test[:, 1]).astype(int)
score = classifier.score(X_test, y_test)
print(f"QNN Classifier accuracy: {score:.2%}")
Noise Modeling and Error Mitigation
Noise Models
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise import depolarizing_error, thermal_relaxation_error
from qiskit import QuantumCircuit
import numpy as np
# Create noise model
noise_model = NoiseModel()
# Depolarizing error on single-qubit gates
error_1q = depolarizing_error(0.001, 1) # 0.1% error
noise_model.add_all_qubit_quantum_error(error_1q, ['u1', 'u2', 'u3', 'rx', 'ry', 'rz'])
# Depolarizing error on two-qubit gates
error_2q = depolarizing_error(0.01, 2) # 1% error
noise_model.add_all_qubit_quantum_error(error_2q, ['cx', 'cz', 'swap'])
# Thermal relaxation error
# T1 = 50 microseconds, T2 = 70 microseconds, gate_time = 0.1 microseconds
t1 = 50e3 # ns
t2 = 70e3 # ns
gate_time = 100 # ns
error_thermal = thermal_relaxation_error(t1, t2, gate_time)
noise_model.add_all_qubit_quantum_error(error_thermal, ['id'])
# Measurement error
from qiskit.providers.aer.noise import ReadoutError
prob_meas0_prep1 = 0.05 # Prob of measuring 0 when prepared in 1
prob_meas1_prep0 = 0.10 # Prob of measuring 1 when prepared in 0
readout_error = ReadoutError([[1 - prob_meas1_prep0, prob_meas1_prep0],
[prob_meas0_prep1, 1 - prob_meas0_prep1]])
noise_model.add_all_qubit_readout_error(readout_error)
print(f"Noise model: {noise_model}")
# Run circuit with noise
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
# Noiseless simulation
simulator_ideal = AerSimulator()
job_ideal = simulator_ideal.run(qc, shots=1000)
counts_ideal = job_ideal.result().get_counts()
# Noisy simulation
simulator_noisy = AerSimulator(noise_model=noise_model)
job_noisy = simulator_noisy.run(qc, shots=1000)
counts_noisy = job_noisy.result().get_counts()
print(f"\nIdeal results: {counts_ideal}")
print(f"Noisy results: {counts_noisy}")
Zero-Noise Extrapolation (ZNE)
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel, depolarizing_error
import numpy as np
from scipy.optimize import curve_fit
def run_circuit_with_noise(circuit, noise_level, shots=1000):
"""Run circuit with scaled noise."""
# Create noise model
noise_model = NoiseModel()
error = depolarizing_error(noise_level, 1)
noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])
# Simulate
simulator = AerSimulator(noise_model=noise_model)
job = simulator.run(circuit, shots=shots)
result = job.result()
# Extract expectation value (simplified)
counts = result.get_counts()
expectation = sum(counts.get(bitstring, 0) * (-1)**bitstring.count('1')
for bitstring in counts) / shots
return expectation
def zero_noise_extrapolation(circuit, noise_levels, shots=1000):
"""
Perform zero-noise extrapolation.
Args:
circuit: Quantum circuit
noise_levels: List of noise scaling factors
shots: Number of shots per simulation
"""
expectations = []
for noise in noise_levels:
exp_val = run_circuit_with_noise(circuit, noise, shots)
expectations.append(exp_val)
print(f"Noise {noise:.4f}: Expectation = {exp_val:.4f}")
# Fit exponential model: E(λ) = A + B * exp(-C * λ)
def exp_model(x, a, b, c):
return a + b * np.exp(-c * x)
# Fit
popt, _ = curve_fit(exp_model, noise_levels, expectations)
# Extrapolate to zero noise
zero_noise_value = exp_model(0, *popt)
print(f"\nZero-noise extrapolated value: {zero_noise_value:.4f}")
return zero_noise_value, expectations
# Example circuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
# Run ZNE
noise_levels = np.array([0.001, 0.005, 0.01, 0.02])
zne_value, measured_values = zero_noise_extrapolation(qc, noise_levels)
Measurement Error Mitigation
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel, ReadoutError
from qiskit.result import marginal_counts
from qiskit.ignis.mitigation.measurement import (
complete_meas_cal,
CompleteMeasFitter
)
# Create readout noise
prob_meas0_prep1 = 0.1
prob_meas1_prep0 = 0.05
readout_error = ReadoutError([[1 - prob_meas1_prep0, prob_meas1_prep0],
[prob_meas0_prep1, 1 - prob_meas0_prep1]])
noise_model = NoiseModel()
noise_model.add_all_qubit_readout_error(readout_error)
# Generate calibration circuits
n_qubits = 2
meas_calibs, state_labels = complete_meas_cal(qr=list(range(n_qubits)))
# Run calibration
simulator = AerSimulator(noise_model=noise_model)
cal_results = []
for circuit in meas_calibs:
job = simulator.run(circuit, shots=1000)
cal_results.append(job.result())
# Fit the calibration
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
# Get mitigation matrix
print("Calibration matrix:")
print(meas_fitter.cal_matrix)
# Run actual circuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
job = simulator.run(qc, shots=1000)
result = job.result()
noisy_counts = result.get_counts()
# Apply mitigation
mitigated_counts = meas_fitter.filter.apply(noisy_counts)
print(f"\nNoisy counts: {noisy_counts}")
print(f"Mitigated counts: {mitigated_counts}")
Transpilation and Optimization
Basic Transpilation
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeMontreal
from qiskit.visualization import plot_circuit_layout
import matplotlib.pyplot as plt
# Create circuit
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.cx(0, 2)
# Get fake backend (simulates real hardware)
backend = FakeMontreal()
# Transpile with different optimization levels
for level in range(4):
transpiled = transpile(qc, backend=backend, optimization_level=level)
print(f"\nOptimization level {level}:")
print(f" Depth: {transpiled.depth()}")
print(f" Gate count: {len(transpiled.data)}")
print(f" CNOT count: {transpiled.count_ops().get('cx', 0)}")
# Best transpilation
best_transpiled = transpile(qc, backend=backend, optimization_level=3)
print(f"\nOriginal circuit:")
print(f" Depth: {qc.depth()}")
print(f" Gates: {len(qc.data)}")
print(f"\nTranspiled circuit:")
print(f" Depth: {best_transpiled.depth()}")
print(f" Gates: {len(best_transpiled.data)}")
Custom Transpilation Pass
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Optimize1qGates, CommutativeCancellation
from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore
# Create circuit with redundant gates
qc = QuantumCircuit(2)
qc.h(0)
qc.h(0) # Redundant - cancels previous H
qc.x(1)
qc.x(1) # Redundant - cancels previous X
qc.cx(0, 1)
print(f"Original circuit depth: {qc.depth()}")
print(f"Original gate count: {len(qc.data)}")
# Create custom pass manager
pm = PassManager()
# Add optimization passes
pm.append(Optimize1qGates()) # Optimize single-qubit gates
pm.append(CommutativeCancellation()) # Cancel commuting gates
pm.append(Unroll3qOrMore()) # Decompose 3+ qubit gates
pm.append(UnitarySynthesis()) # Synthesize unitaries
# Run pass manager
optimized_qc = pm.run(qc)
print(f"\nOptimized circuit depth: {optimized_qc.depth()}")
print(f"Optimized gate count: {len(optimized_qc.data)}")
print("\nOriginal circuit:")
print(qc.draw())
print("\nOptimized circuit:")
print(optimized_qc.draw())
Layout and Routing
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeMontreal
from qiskit.transpiler import CouplingMap
# Create circuit that requires routing
qc = QuantumCircuit(5)
qc.h(0)
qc.cx(0, 4) # Long-range connection
qc.cx(1, 3)
qc.cx(2, 4)
# Fake backend with specific topology
backend = FakeMontreal()
coupling_map = backend.configuration().coupling_map
print(f"Backend coupling map: {coupling_map[:10]}...") # First 10 edges
# Transpile with layout awareness
transpiled = transpile(
qc,
backend=backend,
optimization_level=3,
seed_transpiler=42 # For reproducibility
)
# Get final layout
final_layout = transpiled.layout.final_index_layout()
print(f"\nFinal qubit layout: {final_layout}")
print(f"\nOriginal circuit:")
print(f" Depth: {qc.depth()}")
print(f" CNOT count: {qc.count_ops().get('cx', 0)}")
print(f"\nTranspiled circuit (with routing):")
print(f" Depth: {transpiled.depth()}")
print(f" CNOT count: {transpiled.count_ops().get('cx', 0)}")
print(f" SWAP count: {transpiled.count_ops().get('swap', 0)}")
Quantum Information Theory
Entanglement Measures
from qiskit.quantum_info import Statevector, DensityMatrix, partial_trace
from qiskit.quantum_info import entropy, entanglement_of_formation
from qiskit import QuantumCircuit
import numpy as np
# Create entangled state (Bell state)
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector.from_instruction(qc)
density_matrix = DensityMatrix(state)
print(f"Bell state: {state}")
# Von Neumann entropy (should be 0 for pure states)
entropy_full = entropy(density_matrix)
print(f"\nFull system entropy: {entropy_full:.6f}")
# Reduced density matrix (trace out qubit 1)
rho_0 = partial_trace(density_matrix, [1])
entropy_reduced = entropy(rho_0)
print(f"Reduced density matrix entropy: {entropy_reduced:.6f}")
# Entanglement of formation
# For Bell state, should be 1
eof = entanglement_of_formation(density_matrix)
print(f"Entanglement of formation: {eof:.6f}")
# Compare with separable state
qc_sep = QuantumCircuit(2)
qc_sep.h(0)
qc_sep.h(1)
state_sep = Statevector.from_instruction(qc_sep)
dm_sep = DensityMatrix(state_sep)
rho_0_sep = partial_trace(dm_sep, [1])
entropy_sep = entropy(rho_0_sep)
print(f"\nSeparable state reduced entropy: {entropy_sep:.6f}")
Quantum Channels and Process Tomography
from qiskit.quantum_info import Choi, SuperOp, Kraus
from qiskit import QuantumCircuit
import numpy as np
# Define a quantum channel (amplitude damping)
def amplitude_damping_channel(gamma):
"""
Amplitude damping channel with damping parameter gamma.
Models energy dissipation.
"""
K0 = np.array([[1, 0], [0, np.sqrt(1 - gamma)]])
K1 = np.array([[0, np.sqrt(gamma)], [0, 0]])
return Kraus([K0, K1])
# Create channel
gamma = 0.3
channel = a
…(truncated)
1---2name: qiskit3description: Comprehensive guide for Qiskit - IBM's quantum computing framework. Use for quantum circuit design, quantum algorithms (VQE, QAOA, Grover, Shor), quantum simulation, noise modeling, quantum machine learning, and quantum chemistry calculations. Essential for quantum computing research and applications.4version: 1.05license: Apache-2.06metadata:7 source: https://skillmd.com/skills/diegosouzapw/qiskit8---910# Qiskit - Quantum Computing Framework1112Open-source quantum computing framework for building, simulating, and running quantum algorithms on quantum computers and simulators.1314## When to Use1516- Building quantum circuits and gates17- Running quantum algorithms (VQE, QAOA, Grover, Shor)18- Quantum chemistry calculations (integration with PySCF)19- Quantum machine learning20- Quantum simulation and noise modeling21- Transpiling circuits for real quantum hardware22- Quantum optimization problems23- Quantum error correction24- Quantum cryptography25- Educational quantum computing demonstrations2627## Reference Documentation2829**Official docs**: https://qiskit.org/documentation/ 30**Search patterns**: `qiskit.circuit.QuantumCircuit`, `qiskit.algorithms.VQE`, `qiskit.quantum_info`, `qiskit_nature`3132## Core Principles3334### Use Qiskit For3536| Task | Module | Example |37|------|--------|---------|38| Circuit building | `qiskit` | `QuantumCircuit(2, 2)` |39| Quantum algorithms | `qiskit.algorithms` | `VQE(ansatz, optimizer)` |40| Quantum simulation | `qiskit.providers.aer` | `AerSimulator()` |41| Quantum chemistry | `qiskit_nature` | `GroundStateEigensolver()` |42| Noise modeling | `qiskit.providers.aer.noise` | `NoiseModel()` |43| Transpilation | `qiskit.transpiler` | `transpile(circuit, backend)` |44| Quantum ML | `qiskit_machine_learning` | `VQC(feature_map, ansatz)` |45| Visualization | `qiskit.visualization` | `plot_histogram(counts)` |4647### Do NOT Use For4849- Classical machine learning (use scikit-learn, PyTorch)50- Classical optimization (use SciPy)51- General numerical computing (use NumPy)52- Classical cryptography (use cryptography package)53- Large-scale classical simulation (use classical simulators)5455## Quick Reference5657### Installation5859```bash60# Core Qiskit61pip install qiskit6263# With visualization tools64pip install qiskit[visualization]6566# Quantum chemistry extension67pip install qiskit-nature qiskit-nature-pyscf6869# Machine learning extension70pip install qiskit-machine-learning7172# Optimization extension73pip install qiskit-optimization7475# Full installation76pip install 'qiskit[all]' qiskit-nature qiskit-machine-learning qiskit-optimization77```7879### Standard Imports8081```python82# Core imports83from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister84from qiskit import transpile, assemble85from qiskit.providers.aer import AerSimulator86from qiskit.visualization import plot_histogram, plot_bloch_multivector8788# Quantum algorithms89from qiskit.algorithms import VQE, QAOA, Grover, Shor90from qiskit.algorithms.optimizers import SLSQP, COBYLA, SPSA9192# Quantum info93from qiskit.quantum_info import Statevector, DensityMatrix, Operator94from qiskit.quantum_info import entropy, entanglement_of_formation9596# Circuit library97from qiskit.circuit.library import QFT, RealAmplitudes, EfficientSU298```99100### Basic Pattern - Circuit Building101102```python103from qiskit import QuantumCircuit104from qiskit.providers.aer import AerSimulator105106# Create circuit107qc = QuantumCircuit(2, 2)108109# Add gates110qc.h(0) # Hadamard on qubit 0111qc.cx(0, 1) # CNOT from 0 to 1112113# Measure114qc.measure([0, 1], [0, 1])115116# Simulate117simulator = AerSimulator()118job = simulator.run(qc, shots=1000)119result = job.result()120counts = result.get_counts()121122print(f"Results: {counts}")123```124125### Basic Pattern - Quantum Algorithm126127```python128from qiskit import QuantumCircuit129from qiskit.algorithms import VQE130from qiskit.algorithms.optimizers import SLSQP131from qiskit.circuit.library import RealAmplitudes132from qiskit.primitives import Estimator133from qiskit.quantum_info import SparsePauliOp134135# Define Hamiltonian136hamiltonian = SparsePauliOp(['ZZ', 'IZ', 'ZI'], coeffs=[1.0, -0.5, -0.5])137138# Create ansatz139ansatz = RealAmplitudes(num_qubits=2, reps=1)140141# Setup VQE142optimizer = SLSQP(maxiter=100)143estimator = Estimator()144vqe = VQE(estimator, ansatz, optimizer)145146# Run147result = vqe.compute_minimum_eigenvalue(hamiltonian)148print(f"Ground state energy: {result.eigenvalue:.6f}")149```150151## Critical Rules152153### ✅ DO154155- **Use simulators for development** - Test on simulators before real hardware156- **Transpile for target backend** - Always transpile circuits for specific hardware157- **Handle measurement statistics** - Work with shot counts, not single results158- **Use primitives for algorithms** - Use Estimator/Sampler primitives159- **Check circuit depth** - Monitor gate count and depth for real hardware160- **Implement error mitigation** - Use error mitigation for noisy hardware161- **Validate quantum states** - Check state validity and normalization162- **Use appropriate basis gates** - Match hardware native gates163- **Set random seed for reproducibility** - Use seed for consistent results164- **Monitor job status** - Check if quantum jobs complete successfully165166### ❌ DON'T167168- **Ignore hardware constraints** - Real quantum computers have limitations169- **Use too many qubits on simulators** - Memory grows exponentially170- **Forget to measure** - Quantum states collapse on measurement171- **Mix classical and quantum incorrectly** - Understand measurement timing172- **Ignore decoherence** - Quantum states decay over time173- **Over-transpile** - Unnecessary transpilation adds gates174- **Assume perfect gates** - Real gates have errors175- **Ignore topology** - Not all qubits are connected176- **Use deprecated APIs** - Qiskit evolves rapidly177- **Run without error handling** - Quantum jobs can fail178179## Anti-Patterns (NEVER)180181```python182from qiskit import QuantumCircuit183from qiskit.providers.aer import AerSimulator184from qiskit.primitives import Estimator185186# ❌ BAD: No measurement187qc = QuantumCircuit(2, 2)188qc.h(0)189qc.cx(0, 1)190# Forgot qc.measure()!191192# ✅ GOOD: Always measure when needed193qc = QuantumCircuit(2, 2)194qc.h(0)195qc.cx(0, 1)196qc.measure([0, 1], [0, 1])197198# ❌ BAD: Using deprecated execute()199from qiskit import execute200result = execute(qc, backend, shots=1024).result()201202# ✅ GOOD: Use new run() method203simulator = AerSimulator()204job = simulator.run(qc, shots=1024)205result = job.result()206207# ❌ BAD: Assuming perfect measurement208counts = result.get_counts()209# Assuming exactly 50/50 split!210assert counts['00'] == 512211212# ✅ GOOD: Handle statistical variation213counts = result.get_counts()214ratio = counts.get('00', 0) / sum(counts.values())215print(f"Measured |00⟩ with probability {ratio:.3f}")216217# ❌ BAD: Not checking circuit properties218qc = QuantumCircuit(20) # Many qubits!219# Adding many gates...220# Trying to simulate without checking depth/size!221222# ✅ GOOD: Check circuit properties223qc = QuantumCircuit(20)224# ... add gates ...225print(f"Circuit depth: {qc.depth()}")226print(f"Gate count: {len(qc.data)}")227print(f"Qubits: {qc.num_qubits}")228229# ❌ BAD: Ignoring transpilation230job = backend.run(qc) # May fail on real hardware!231232# ✅ GOOD: Transpile for backend233from qiskit import transpile234transpiled_qc = transpile(qc, backend=backend, optimization_level=3)235job = backend.run(transpiled_qc)236```237238## Quantum Circuits (qiskit.QuantumCircuit)239240### Basic Circuit Construction241242```python243from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister244import numpy as np245246# Method 1: Simple initialization247qc = QuantumCircuit(3, 3) # 3 qubits, 3 classical bits248249# Method 2: Using registers250qr = QuantumRegister(3, 'q')251cr = ClassicalRegister(3, 'c')252qc = QuantumCircuit(qr, cr)253254# Method 3: Multiple registers255qr1 = QuantumRegister(2, 'data')256qr2 = QuantumRegister(1, 'ancilla')257cr = ClassicalRegister(2, 'meas')258qc = QuantumCircuit(qr1, qr2, cr)259260print(f"Number of qubits: {qc.num_qubits}")261print(f"Number of classical bits: {qc.num_clbits}")262print(f"Circuit depth: {qc.depth()}")263```264265### Single-Qubit Gates266267```python268from qiskit import QuantumCircuit269import numpy as np270271qc = QuantumCircuit(1)272273# Pauli gates274qc.x(0) # Pauli X (NOT gate)275qc.y(0) # Pauli Y276qc.z(0) # Pauli Z277278# Hadamard gate279qc.h(0) # Creates superposition280281# Phase gates282qc.s(0) # S gate (π/2 phase)283qc.t(0) # T gate (π/4 phase)284qc.sdg(0) # S dagger285qc.tdg(0) # T dagger286287# Rotation gates288qc.rx(np.pi/4, 0) # Rotation around X289qc.ry(np.pi/4, 0) # Rotation around Y290qc.rz(np.pi/4, 0) # Rotation around Z291292# General rotation293qc.u(np.pi/4, np.pi/2, np.pi, 0) # U gate294295# Identity (wait)296qc.id(0)297298print(f"Gate count: {len(qc.data)}")299```300301### Two-Qubit Gates302303```python304from qiskit import QuantumCircuit305import numpy as np306307qc = QuantumCircuit(2)308309# CNOT (Controlled-NOT)310qc.cx(0, 1) # Control: 0, Target: 1311312# Other controlled gates313qc.cy(0, 1) # Controlled-Y314qc.cz(0, 1) # Controlled-Z315qc.ch(0, 1) # Controlled-Hadamard316317# SWAP gate318qc.swap(0, 1)319320# Controlled phase321qc.cp(np.pi/4, 0, 1)322323# Controlled-U324qc.cu(np.pi/4, np.pi/2, np.pi, 0, 0, 1)325326# Toffoli (CCX) - needs 3 qubits327qc_3 = QuantumCircuit(3)328qc_3.ccx(0, 1, 2) # Controls: 0,1, Target: 2329330print(qc.draw())331```332333### Creating Entanglement334335```python336from qiskit import QuantumCircuit337from qiskit.providers.aer import AerSimulator338from qiskit.quantum_info import Statevector339340# Bell state (maximally entangled)341def create_bell_state():342 qc = QuantumCircuit(2)343 qc.h(0)344 qc.cx(0, 1)345 return qc346347bell = create_bell_state()348state = Statevector.from_instruction(bell)349print(f"Bell state: {state}")350351# GHZ state (3-qubit entanglement)352def create_ghz_state(n):353 qc = QuantumCircuit(n)354 qc.h(0)355 for i in range(n-1):356 qc.cx(i, i+1)357 return qc358359ghz = create_ghz_state(3)360state_ghz = Statevector.from_instruction(ghz)361print(f"GHZ state: {state_ghz}")362363# W state (another type of 3-qubit entanglement)364def create_w_state():365 qc = QuantumCircuit(3)366 qc.ry(1.9106, 0)367 qc.ch(0, 1)368 qc.x(0)369 qc.cy(0, 1)370 qc.ccx(0, 1, 2)371 qc.x(0)372 return qc373374w = create_w_state()375print(f"W state circuit depth: {w.depth()}")376```377378### Parameterized Circuits379380```python381from qiskit import QuantumCircuit382from qiskit.circuit import Parameter, ParameterVector383import numpy as np384385# Single parameter386theta = Parameter('θ')387qc = QuantumCircuit(1)388qc.ry(theta, 0)389390# Bind parameter391bound_qc = qc.bind_parameters({theta: np.pi/4})392print(f"Unbound: {qc}")393print(f"Bound: {bound_qc}")394395# Multiple parameters396params = ParameterVector('θ', 4)397qc_param = QuantumCircuit(2)398qc_param.ry(params[0], 0)399qc_param.ry(params[1], 1)400qc_param.cx(0, 1)401qc_param.ry(params[2], 0)402qc_param.ry(params[3], 1)403404# Bind all parameters405values = [np.pi/4, np.pi/3, np.pi/2, np.pi/6]406bound = qc_param.bind_parameters(dict(zip(params, values)))407408print(f"Number of parameters: {qc_param.num_parameters}")409```410411## Quantum Algorithms412413### Variational Quantum Eigensolver (VQE)414415```python416from qiskit import QuantumCircuit417from qiskit.algorithms import VQE418from qiskit.algorithms.optimizers import SLSQP, COBYLA419from qiskit.circuit.library import RealAmplitudes, EfficientSU2420from qiskit.primitives import Estimator421from qiskit.quantum_info import SparsePauliOp422import numpy as np423424# Define Hamiltonian (e.g., H2 molecule)425# H = -1.05 * ZZ + 0.39 * XX - 0.39 * YY - 0.01 * ZI426hamiltonian = SparsePauliOp(427 ['ZZ', 'XX', 'YY', 'ZI', 'IZ'],428 coeffs=[-1.05, 0.39, -0.39, -0.01, -0.01]429)430431# Create ansatz (variational form)432ansatz = RealAmplitudes(num_qubits=2, reps=2)433434# Alternative: EfficientSU2435# ansatz = EfficientSU2(num_qubits=2, reps=2)436437# Setup optimizer438optimizer = SLSQP(maxiter=100)439440# Create estimator primitive441estimator = Estimator()442443# Setup and run VQE444vqe = VQE(estimator, ansatz, optimizer)445result = vqe.compute_minimum_eigenvalue(hamiltonian)446447print(f"Ground state energy: {result.eigenvalue:.6f}")448print(f"Optimal parameters: {result.optimal_parameters}")449print(f"Optimizer evaluations: {result.cost_function_evals}")450451# Get optimal circuit452optimal_circuit = ansatz.bind_parameters(result.optimal_point)453print(f"\nOptimal circuit depth: {optimal_circuit.depth()}")454```455456### QAOA (Quantum Approximate Optimization Algorithm)457458```python459from qiskit import QuantumCircuit460from qiskit.algorithms import QAOA461from qiskit.algorithms.optimizers import COBYLA462from qiskit.primitives import Sampler463from qiskit.quantum_info import SparsePauliOp464import numpy as np465466# Max-Cut problem on a triangle graph467# Cost Hamiltonian: H = (1-Z0*Z1)/2 + (1-Z1*Z2)/2 + (1-Z0*Z2)/2468cost_hamiltonian = SparsePauliOp(469 ['ZZ', 'ZI', 'IZ'],470 coeffs=[0.5, -0.5, -0.5]471)472473# Setup QAOA474optimizer = COBYLA(maxiter=100)475sampler = Sampler()476qaoa = QAOA(sampler, optimizer, reps=2)477478# Run QAOA479result = qaoa.compute_minimum_eigenvalue(cost_hamiltonian)480481print(f"Optimal objective: {result.eigenvalue:.6f}")482print(f"Optimal parameters: {result.optimal_parameters}")483484# Most probable solution485from qiskit.result import QuasiDistribution486prob_dist = result.eigenstate487if isinstance(prob_dist, QuasiDistribution):488 most_likely = max(prob_dist, key=prob_dist.get)489 print(f"Most likely solution: {bin(most_likely)[2:].zfill(2)}")490```491492### Grover's Algorithm (Quantum Search)493494```python495from qiskit import QuantumCircuit496from qiskit.algorithms import Grover, AmplificationProblem497from qiskit.circuit.library import GroverOperator498from qiskit.primitives import Sampler499import numpy as np500501def grover_search(marked_states, n_qubits):502 """503 Grover's algorithm to find marked states.504 505 Args:506 marked_states: List of marked states (e.g., ['101', '110'])507 n_qubits: Number of qubits508 """509 # Create oracle that marks the target states510 oracle = QuantumCircuit(n_qubits)511 512 # Mark state |101⟩ by flipping phase513 if '101' in marked_states:514 oracle.x([0, 2]) # Flip to make 101 -> 111515 oracle.h(2)516 oracle.ccx(0, 1, 2)517 oracle.h(2)518 oracle.x([0, 2]) # Flip back519 520 # Grover diffusion operator521 diffusion = QuantumCircuit(n_qubits)522 diffusion.h(range(n_qubits))523 diffusion.x(range(n_qubits))524 diffusion.h(n_qubits - 1)525 diffusion.mcx(list(range(n_qubits - 1)), n_qubits - 1)526 diffusion.h(n_qubits - 1)527 diffusion.x(range(n_qubits))528 diffusion.h(range(n_qubits))529 530 # Complete Grover iteration531 grover_op = oracle.compose(diffusion)532 533 # Setup and run534 problem = AmplificationProblem(oracle, is_good_state=marked_states)535 grover = Grover(sampler=Sampler())536 result = grover.amplify(problem)537 538 return result539540# Example: Search for |101⟩ in 3-qubit space541result = grover_search(['101'], 3)542print(f"Top measurement: {result.top_measurement}")543print(f"Oracle evaluations: {result.oracle_evaluation}")544545# Simpler example: 2-qubit search546qc = QuantumCircuit(2, 2)547qc.h([0, 1]) # Superposition548549# Oracle marks |11⟩550qc.cz(0, 1)551552# Diffusion553qc.h([0, 1])554qc.x([0, 1])555qc.cz(0, 1)556qc.x([0, 1])557qc.h([0, 1])558559qc.measure([0, 1], [0, 1])560561from qiskit.providers.aer import AerSimulator562simulator = AerSimulator()563job = simulator.run(qc, shots=1000)564counts = job.result().get_counts()565print(f"Grover results: {counts}")566```567568### Quantum Phase Estimation (QPE)569570```python571from qiskit import QuantumCircuit572from qiskit.circuit.library import QFT573from qiskit.providers.aer import AerSimulator574import numpy as np575576def quantum_phase_estimation(unitary, n_counting_qubits):577 """578 Estimate the phase of an eigenstate of a unitary operator.579 580 Args:581 unitary: Unitary operator as a QuantumCircuit582 n_counting_qubits: Precision qubits583 """584 n_system_qubits = unitary.num_qubits585 586 qc = QuantumCircuit(n_counting_qubits + n_system_qubits, n_counting_qubits)587 588 # Initialize eigenstate (simplified: use |1⟩)589 qc.x(n_counting_qubits)590 591 # Hadamard on counting qubits592 for i in range(n_counting_qubits):593 qc.h(i)594 595 # Controlled-U^(2^i) operations596 repetitions = 1597 for counting_qubit in range(n_counting_qubits):598 for _ in range(repetitions):599 qc.append(unitary.control(), [counting_qubit] + 600 list(range(n_counting_qubits, n_counting_qubits + n_system_qubits)))601 repetitions *= 2602 603 # Inverse QFT604 qc.append(QFT(n_counting_qubits, inverse=True), range(n_counting_qubits))605 606 # Measure counting qubits607 qc.measure(range(n_counting_qubits), range(n_counting_qubits))608 609 return qc610611# Example: Phase estimation for T gate (phase π/4)612t_gate = QuantumCircuit(1)613t_gate.t(0)614615qpe_circuit = quantum_phase_estimation(t_gate, n_counting_qubits=3)616617simulator = AerSimulator()618job = simulator.run(qpe_circuit, shots=1000)619counts = job.result().get_counts()620print(f"Phase estimation results: {counts}")621622# Most common result gives phase623most_common = max(counts, key=counts.get)624phase_estimate = int(most_common, 2) / (2**3)625print(f"Estimated phase: {phase_estimate * 2 * np.pi:.4f} rad")626print(f"True phase: {np.pi/4:.4f} rad")627```628629## Quantum Chemistry with Qiskit Nature630631### Molecular Ground State Calculation632633```python634# Requires: pip install qiskit-nature qiskit-nature-pyscf635636from qiskit_nature.units import DistanceUnit637from qiskit_nature.second_q.drivers import PySCFDriver638from qiskit_nature.second_q.mappers import JordanWignerMapper, ParityMapper639from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD640from qiskit.algorithms import VQE641from qiskit.algorithms.optimizers import SLSQP642from qiskit.primitives import Estimator643import numpy as np644645# Define molecule (H2)646driver = PySCFDriver(647 atom='H 0 0 0; H 0 0 0.735',648 basis='sto3g',649 charge=0,650 spin=0,651 unit=DistanceUnit.ANGSTROM652)653654# Get problem655problem = driver.run()656hamiltonian = problem.hamiltonian.second_q_op()657658# Map to qubits659mapper = JordanWignerMapper()660qubit_op = mapper.map(hamiltonian)661662print(f"Number of qubits required: {qubit_op.num_qubits}")663664# Initial state (Hartree-Fock)665num_particles = problem.num_particles666num_spatial_orbitals = problem.num_spatial_orbitals667668init_state = HartreeFock(669 num_spatial_orbitals=num_spatial_orbitals,670 num_particles=num_particles,671 qubit_mapper=mapper672)673674# Ansatz (UCCSD)675ansatz = UCCSD(676 num_spatial_orbitals=num_spatial_orbitals,677 num_particles=num_particles,678 qubit_mapper=mapper,679 initial_state=init_state680)681682# VQE calculation683optimizer = SLSQP(maxiter=100)684estimator = Estimator()685686vqe = VQE(estimator, ansatz, optimizer)687result = vqe.compute_minimum_eigenvalue(qubit_op)688689print(f"\nVQE Ground State Energy: {result.eigenvalue:.6f} Ha")690print(f"Reference HF energy: {problem.reference_energy:.6f} Ha")691```692693### Excited States Calculation694695```python696from qiskit_nature.second_q.algorithms import GroundStateEigensolver, ExcitedStatesEigensolver697from qiskit_nature.second_q.algorithms import QEOM698from qiskit_nature.second_q.mappers import JordanWignerMapper699from qiskit_nature.second_q.drivers import PySCFDriver700from qiskit.algorithms import VQE701from qiskit.algorithms.optimizers import SLSQP702from qiskit.primitives import Estimator703704# Setup molecule705driver = PySCFDriver(atom='H 0 0 0; H 0 0 0.735', basis='sto3g')706problem = driver.run()707708# Mapper709mapper = JordanWignerMapper()710711# Ground state solver712optimizer = SLSQP(maxiter=100)713estimator = Estimator()714715# Simple ansatz for demonstration716from qiskit.circuit.library import RealAmplitudes717ansatz = RealAmplitudes(num_qubits=4, reps=2)718719vqe = VQE(estimator, ansatz, optimizer)720ground_solver = GroundStateEigensolver(mapper, vqe)721722# Calculate ground state723ground_result = ground_solver.solve(problem)724print(f"Ground state energy: {ground_result.total_energies[0]:.6f} Ha")725726# Excited states with QEOM727qeom = QEOM(ground_solver, 'sd') # singles and doubles728excited_solver = ExcitedStatesEigensolver(mapper, qeom)729730# Calculate excited states731excited_result = excited_solver.solve(problem)732print(f"\nExcited state energies:")733for i, energy in enumerate(excited_result.total_energies):734 print(f"State {i}: {energy:.6f} Ha")735```736737### Molecular Potential Energy Surface738739```python740from qiskit_nature.second_q.drivers import PySCFDriver741from qiskit_nature.second_q.mappers import JordanWignerMapper742from qiskit_nature.second_q.algorithms import GroundStateEigensolver743from qiskit.algorithms import VQE744from qiskit.algorithms.optimizers import SLSQP745from qiskit.primitives import Estimator746from qiskit.circuit.library import RealAmplitudes747import numpy as np748749def calculate_pes(distances, molecule_template, basis='sto3g'):750 """751 Calculate potential energy surface for a diatomic molecule.752 753 Args:754 distances: Array of interatomic distances755 molecule_template: Molecule string with {} for distance756 basis: Basis set757 """758 energies = []759 760 for distance in distances:761 # Setup molecule at this distance762 atom_string = molecule_template.format(distance)763 driver = PySCFDriver(atom=atom_string, basis=basis)764 problem = driver.run()765 766 # Map to qubits767 mapper = JordanWignerMapper()768 769 # Simple VQE calculation770 ansatz = RealAmplitudes(num_qubits=4, reps=1)771 optimizer = SLSQP(maxiter=50)772 estimator = Estimator()773 774 vqe = VQE(estimator, ansatz, optimizer)775 solver = GroundStateEigensolver(mapper, vqe)776 777 # Calculate energy778 result = solver.solve(problem)779 energies.append(result.total_energies[0])780 781 print(f"Distance {distance:.2f} Å: Energy = {energies[-1]:.6f} Ha")782 783 return np.array(energies)784785# Calculate PES for H2786distances = np.linspace(0.5, 2.5, 5) # Angstroms787molecule_template = 'H 0 0 0; H 0 0 {}'788789energies = calculate_pes(distances, molecule_template)790791# Find equilibrium bond length792min_idx = np.argmin(energies)793print(f"\nEquilibrium bond length: {distances[min_idx]:.2f} Å")794print(f"Minimum energy: {energies[min_idx]:.6f} Ha")795```796797## Quantum Simulation798799### Hamiltonian Simulation with Trotter800801```python802from qiskit import QuantumCircuit803from qiskit.quantum_info import SparsePauliOp, Statevector804from qiskit.synthesis import SuzukiTrotter805import numpy as np806807def trotter_simulation(hamiltonian, time, n_steps):808 """809 Simulate time evolution under Hamiltonian using Trotter decomposition.810 811 Args:812 hamiltonian: SparsePauliOp Hamiltonian813 time: Total evolution time814 n_steps: Number of Trotter steps815 """816 dt = time / n_steps817 818 # Create Trotter circuit819 n_qubits = hamiltonian.num_qubits820 qc = QuantumCircuit(n_qubits)821 822 # Initial state (e.g., |0⟩)823 # Apply Trotter steps824 for _ in range(n_steps):825 # For each Pauli term in Hamiltonian826 for pauli, coeff in zip(hamiltonian.paulis, hamiltonian.coeffs):827 # Apply exp(-i * coeff * dt * pauli)828 angle = 2 * float(coeff.real) * dt829 830 # Simple implementation for single Pauli terms831 pauli_str = str(pauli)832 833 # Apply appropriate rotation834 if 'Z' in pauli_str and pauli_str.count('I') == n_qubits - 1:835 idx = pauli_str.index('Z')836 qc.rz(angle, n_qubits - 1 - idx)837 elif 'X' in pauli_str and pauli_str.count('I') == n_qubits - 1:838 idx = pauli_str.index('X')839 qc.rx(angle, n_qubits - 1 - idx)840 841 return qc842843# Example: Ising model Hamiltonian844hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5])845846# Simulate for time t=1.0 with 10 Trotter steps847qc = trotter_simulation(hamiltonian, time=1.0, n_steps=10)848849print(f"Trotter circuit depth: {qc.depth()}")850print(f"Gate count: {len(qc.data)}")851852# Get final state853state = Statevector.from_instruction(qc)854print(f"Final state vector: {state[:4]}") # First 4 amplitudes855```856857### Variational Quantum Simulation858859```python860from qiskit import QuantumCircuit861from qiskit.algorithms import VQE862from qiskit.algorithms.optimizers import SLSQP863from qiskit.circuit.library import RealAmplitudes864from qiskit.primitives import Estimator865from qiskit.quantum_info import SparsePauliOp866import numpy as np867868def simulate_dynamics(hamiltonian, initial_state_circuit, times, ansatz_reps=2):869 """870 Simulate quantum dynamics using VQE at different times.871 872 Args:873 hamiltonian: Time-evolution Hamiltonian874 initial_state_circuit: Circuit preparing initial state875 times: Array of times to simulate876 ansatz_reps: Repetitions in ansatz877 """878 n_qubits = hamiltonian.num_qubits879 results = []880 881 for t in times:882 # Time-evolved Hamiltonian: H(t) = exp(-iHt) ρ(0) exp(iHt)883 # Approximate with VQE884 885 ansatz = RealAmplitudes(num_qubits=n_qubits, reps=ansatz_reps)886 887 # Combine initial state + ansatz888 full_circuit = initial_state_circuit.copy()889 full_circuit.compose(ansatz, inplace=True)890 891 optimizer = SLSQP(maxiter=100)892 estimator = Estimator()893 894 vqe = VQE(estimator, full_circuit, optimizer)895 result = vqe.compute_minimum_eigenvalue(hamiltonian)896 897 results.append({898 'time': t,899 'energy': result.eigenvalue,900 'parameters': result.optimal_parameters901 })902 903 print(f"Time {t:.2f}: Energy = {result.eigenvalue:.6f}")904 905 return results906907# Example: Simulate Heisenberg model908hamiltonian = SparsePauliOp(909 ['XX', 'YY', 'ZZ'],910 coeffs=[0.5, 0.5, 0.5]911)912913# Initial state: |01⟩914initial_state = QuantumCircuit(2)915initial_state.x(1)916917# Simulate at different times918times = np.linspace(0, 2, 5)919results = simulate_dynamics(hamiltonian, initial_state, times)920```921922## Quantum Machine Learning923924### Quantum Kernel Method925926```python927# Requires: pip install qiskit-machine-learning928929from qiskit_machine_learning.kernels import FidelityQuantumKernel930from qiskit.circuit.library import ZZFeatureMap931from qiskit.primitives import Sampler932from sklearn.svm import SVC933import numpy as np934935# Generate synthetic data936np.random.seed(42)937X_train = np.random.rand(20, 2) * 2 * np.pi938y_train = (X_train[:, 0] + X_train[:, 1] > np.pi).astype(int)939940X_test = np.random.rand(10, 2) * 2 * np.pi941y_test = (X_test[:, 0] + X_test[:, 1] > np.pi).astype(int)942943# Create feature map944feature_map = ZZFeatureMap(feature_dimension=2, reps=2)945946# Create quantum kernel947sampler = Sampler()948quantum_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=sampler)949950# Compute kernel matrix951kernel_matrix_train = quantum_kernel.evaluate(x_vec=X_train)952kernel_matrix_test = quantum_kernel.evaluate(x_vec=X_test, y_vec=X_train)953954print(f"Training kernel matrix shape: {kernel_matrix_train.shape}")955print(f"Test kernel matrix shape: {kernel_matrix_test.shape}")956957# Use with SVM958svc = SVC(kernel='precomputed')959svc.fit(kernel_matrix_train, y_train)960961# Predict962predictions = svc.predict(kernel_matrix_test)963accuracy = np.mean(predictions == y_test)964965print(f"\nQuantum Kernel SVM Accuracy: {accuracy:.2%}")966```967968### Variational Quantum Classifier (VQC)969970```python971from qiskit_machine_learning.algorithms import VQC972from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap973from qiskit.algorithms.optimizers import COBYLA974from qiskit.primitives import Sampler975import numpy as np976977# Generate training data978np.random.seed(42)979X_train = np.random.rand(40, 2) * 2 - 1 # [-1, 1]980y_train = (X_train[:, 0]**2 + X_train[:, 1]**2 < 0.5).astype(int)981982X_test = np.random.rand(20, 2) * 2 - 1983y_test = (X_test[:, 0]**2 + X_test[:, 1]**2 < 0.5).astype(int)984985# Feature map986feature_map = ZZFeatureMap(2)987988# Ansatz989ansatz = RealAmplitudes(2, reps=2)990991# Create VQC992optimizer = COBYLA(maxiter=100)993sampler = Sampler()994995vqc = VQC(996 sampler=sampler,997 feature_map=feature_map,998 ansatz=ansatz,999 optimizer=optimizer,1000)10011002# Train1003vqc.fit(X_train, y_train)10041005# Predict1006train_score = vqc.score(X_train, y_train)1007test_score = vqc.score(X_test, y_test)10081009print(f"Training accuracy: {train_score:.2%}")1010print(f"Test accuracy: {test_score:.2%}")10111012# Predictions1013predictions = vqc.predict(X_test)1014print(f"Sample predictions: {predictions[:5]}")1015print(f"True labels: {y_test[:5]}")1016```10171018### Quantum Neural Network (QNN)10191020```python1021from qiskit_machine_learning.neural_networks import SamplerQNN1022from qiskit_machine_learning.algorithms import NeuralNetworkClassifier1023from qiskit.circuit import QuantumCircuit, Parameter1024from qiskit.circuit.library import RealAmplitudes1025from qiskit.algorithms.optimizers import COBYLA1026from qiskit.primitives import Sampler1027import numpy as np10281029# Create parameterized quantum circuit1030def create_qnn_circuit(num_qubits, num_features):1031 qc = QuantumCircuit(num_qubits)1032 1033 # Feature map parameters1034 feature_params = [Parameter(f'x{i}') for i in range(num_features)]1035 1036 # Encode features1037 for i, param in enumerate(feature_params):1038 if i < num_qubits:1039 qc.ry(param, i)1040 1041 # Variational part1042 ansatz = RealAmplitudes(num_qubits, reps=1)1043 qc.compose(ansatz, inplace=True)1044 1045 return qc, feature_params, ansatz.parameters10461047num_qubits = 21048num_features = 210491050qc, feature_params, weight_params = create_qnn_circuit(num_qubits, num_features)10511052# Create QNN1053sampler = Sampler()1054qnn = SamplerQNN(1055 circuit=qc,1056 input_params=feature_params,1057 weight_params=weight_params,1058 sampler=sampler,1059)10601061# Create classifier1062optimizer = COBYLA(maxiter=50)1063classifier = NeuralNetworkClassifier(1064 neural_network=qnn,1065 optimizer=optimizer,1066)10671068# Training data1069X_train = np.random.rand(30, 2)1070y_train = (X_train[:, 0] > X_train[:, 1]).astype(int)10711072# Train1073classifier.fit(X_train, y_train)10741075# Test1076X_test = np.random.rand(10, 2)1077y_test = (X_test[:, 0] > X_test[:, 1]).astype(int)10781079score = classifier.score(X_test, y_test)1080print(f"QNN Classifier accuracy: {score:.2%}")1081```10821083## Noise Modeling and Error Mitigation10841085### Noise Models10861087```python1088from qiskit.providers.aer import AerSimulator1089from qiskit.providers.aer.noise import NoiseModel1090from qiskit.providers.aer.noise import depolarizing_error, thermal_relaxation_error1091from qiskit import QuantumCircuit1092import numpy as np10931094# Create noise model1095noise_model = NoiseModel()10961097# Depolarizing error on single-qubit gates1098error_1q = depolarizing_error(0.001, 1) # 0.1% error1099noise_model.add_all_qubit_quantum_error(error_1q, ['u1', 'u2', 'u3', 'rx', 'ry', 'rz'])11001101# Depolarizing error on two-qubit gates1102error_2q = depolarizing_error(0.01, 2) # 1% error1103noise_model.add_all_qubit_quantum_error(error_2q, ['cx', 'cz', 'swap'])11041105# Thermal relaxation error1106# T1 = 50 microseconds, T2 = 70 microseconds, gate_time = 0.1 microseconds1107t1 = 50e3 # ns1108t2 = 70e3 # ns1109gate_time = 100 # ns11101111error_thermal = thermal_relaxation_error(t1, t2, gate_time)1112noise_model.add_all_qubit_quantum_error(error_thermal, ['id'])11131114# Measurement error1115from qiskit.providers.aer.noise import ReadoutError1116prob_meas0_prep1 = 0.05 # Prob of measuring 0 when prepared in 11117prob_meas1_prep0 = 0.10 # Prob of measuring 1 when prepared in 011181119readout_error = ReadoutError([[1 - prob_meas1_prep0, prob_meas1_prep0],1120 [prob_meas0_prep1, 1 - prob_meas0_prep1]])1121noise_model.add_all_qubit_readout_error(readout_error)11221123print(f"Noise model: {noise_model}")11241125# Run circuit with noise1126qc = QuantumCircuit(2, 2)1127qc.h(0)1128qc.cx(0, 1)1129qc.measure([0, 1], [0, 1])11301131# Noiseless simulation1132simulator_ideal = AerSimulator()1133job_ideal = simulator_ideal.run(qc, shots=1000)1134counts_ideal = job_ideal.result().get_counts()11351136# Noisy simulation1137simulator_noisy = AerSimulator(noise_model=noise_model)1138job_noisy = simulator_noisy.run(qc, shots=1000)1139counts_noisy = job_noisy.result().get_counts()11401141print(f"\nIdeal results: {counts_ideal}")1142print(f"Noisy results: {counts_noisy}")1143```11441145### Zero-Noise Extrapolation (ZNE)11461147```python1148from qiskit import QuantumCircuit, transpile1149from qiskit.providers.aer import AerSimulator1150from qiskit.providers.aer.noise import NoiseModel, depolarizing_error1151import numpy as np1152from scipy.optimize import curve_fit11531154def run_circuit_with_noise(circuit, noise_level, shots=1000):1155 """Run circuit with scaled noise."""1156 # Create noise model1157 noise_model = NoiseModel()1158 error = depolarizing_error(noise_level, 1)1159 noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])1160 1161 # Simulate1162 simulator = AerSimulator(noise_model=noise_model)1163 job = simulator.run(circuit, shots=shots)1164 result = job.result()1165 1166 # Extract expectation value (simplified)1167 counts = result.get_counts()1168 expectation = sum(counts.get(bitstring, 0) * (-1)**bitstring.count('1') 1169 for bitstring in counts) / shots1170 1171 return expectation11721173def zero_noise_extrapolation(circuit, noise_levels, shots=1000):1174 """1175 Perform zero-noise extrapolation.1176 1177 Args:1178 circuit: Quantum circuit1179 noise_levels: List of noise scaling factors1180 shots: Number of shots per simulation1181 """1182 expectations = []1183 1184 for noise in noise_levels:1185 exp_val = run_circuit_with_noise(circuit, noise, shots)1186 expectations.append(exp_val)1187 print(f"Noise {noise:.4f}: Expectation = {exp_val:.4f}")1188 1189 # Fit exponential model: E(λ) = A + B * exp(-C * λ)1190 def exp_model(x, a, b, c):1191 return a + b * np.exp(-c * x)1192 1193 # Fit1194 popt, _ = curve_fit(exp_model, noise_levels, expectations)1195 1196 # Extrapolate to zero noise1197 zero_noise_value = exp_model(0, *popt)1198 1199 print(f"\nZero-noise extrapolated value: {zero_noise_value:.4f}")1200 1201 return zero_noise_value, expectations12021203# Example circuit1204qc = QuantumCircuit(2, 2)1205qc.h(0)1206qc.cx(0, 1)1207qc.measure([0, 1], [0, 1])12081209# Run ZNE1210noise_levels = np.array([0.001, 0.005, 0.01, 0.02])1211zne_value, measured_values = zero_noise_extrapolation(qc, noise_levels)1212```12131214### Measurement Error Mitigation12151216```python1217from qiskit import QuantumCircuit1218from qiskit.providers.aer import AerSimulator1219from qiskit.providers.aer.noise import NoiseModel, ReadoutError1220from qiskit.result import marginal_counts1221from qiskit.ignis.mitigation.measurement import (1222 complete_meas_cal,1223 CompleteMeasFitter1224)12251226# Create readout noise1227prob_meas0_prep1 = 0.11228prob_meas1_prep0 = 0.0512291230readout_error = ReadoutError([[1 - prob_meas1_prep0, prob_meas1_prep0],1231 [prob_meas0_prep1, 1 - prob_meas0_prep1]])12321233noise_model = NoiseModel()1234noise_model.add_all_qubit_readout_error(readout_error)12351236# Generate calibration circuits1237n_qubits = 21238meas_calibs, state_labels = complete_meas_cal(qr=list(range(n_qubits)))12391240# Run calibration1241simulator = AerSimulator(noise_model=noise_model)1242cal_results = []12431244for circuit in meas_calibs:1245 job = simulator.run(circuit, shots=1000)1246 cal_results.append(job.result())12471248# Fit the calibration1249meas_fitter = CompleteMeasFitter(cal_results, state_labels)12501251# Get mitigation matrix1252print("Calibration matrix:")1253print(meas_fitter.cal_matrix)12541255# Run actual circuit1256qc = QuantumCircuit(2, 2)1257qc.h(0)1258qc.cx(0, 1)1259qc.measure([0, 1], [0, 1])12601261job = simulator.run(qc, shots=1000)1262result = job.result()1263noisy_counts = result.get_counts()12641265# Apply mitigation1266mitigated_counts = meas_fitter.filter.apply(noisy_counts)12671268print(f"\nNoisy counts: {noisy_counts}")1269print(f"Mitigated counts: {mitigated_counts}")1270```12711272## Transpilation and Optimization12731274### Basic Transpilation12751276```python1277from qiskit import QuantumCircuit, transpile1278from qiskit.providers.fake_provider import FakeMontreal1279from qiskit.visualization import plot_circuit_layout1280import matplotlib.pyplot as plt12811282# Create circuit1283qc = QuantumCircuit(3)1284qc.h(0)1285qc.cx(0, 1)1286qc.cx(1, 2)1287qc.cx(0, 2)12881289# Get fake backend (simulates real hardware)1290backend = FakeMontreal()12911292# Transpile with different optimization levels1293for level in range(4):1294 transpiled = transpile(qc, backend=backend, optimization_level=level)1295 1296 print(f"\nOptimization level {level}:")1297 print(f" Depth: {transpiled.depth()}")1298 print(f" Gate count: {len(transpiled.data)}")1299 print(f" CNOT count: {transpiled.count_ops().get('cx', 0)}")13001301# Best transpilation1302best_transpiled = transpile(qc, backend=backend, optimization_level=3)13031304print(f"\nOriginal circuit:")1305print(f" Depth: {qc.depth()}")1306print(f" Gates: {len(qc.data)}")13071308print(f"\nTranspiled circuit:")1309print(f" Depth: {best_transpiled.depth()}")1310print(f" Gates: {len(best_transpiled.data)}")1311```13121313### Custom Transpilation Pass13141315```python1316from qiskit import QuantumCircuit1317from qiskit.transpiler import PassManager1318from qiskit.transpiler.passes import Optimize1qGates, CommutativeCancellation1319from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore13201321# Create circuit with redundant gates1322qc = QuantumCircuit(2)1323qc.h(0)1324qc.h(0) # Redundant - cancels previous H1325qc.x(1)1326qc.x(1) # Redundant - cancels previous X1327qc.cx(0, 1)13281329print(f"Original circuit depth: {qc.depth()}")1330print(f"Original gate count: {len(qc.data)}")13311332# Create custom pass manager1333pm = PassManager()13341335# Add optimization passes1336pm.append(Optimize1qGates()) # Optimize single-qubit gates1337pm.append(CommutativeCancellation()) # Cancel commuting gates1338pm.append(Unroll3qOrMore()) # Decompose 3+ qubit gates1339pm.append(UnitarySynthesis()) # Synthesize unitaries13401341# Run pass manager1342optimized_qc = pm.run(qc)13431344print(f"\nOptimized circuit depth: {optimized_qc.depth()}")1345print(f"Optimized gate count: {len(optimized_qc.data)}")13461347print("\nOriginal circuit:")1348print(qc.draw())13491350print("\nOptimized circuit:")1351print(optimized_qc.draw())1352```13531354### Layout and Routing13551356```python1357from qiskit import QuantumCircuit, transpile1358from qiskit.providers.fake_provider import FakeMontreal1359from qiskit.transpiler import CouplingMap13601361# Create circuit that requires routing1362qc = QuantumCircuit(5)1363qc.h(0)1364qc.cx(0, 4) # Long-range connection1365qc.cx(1, 3)1366qc.cx(2, 4)13671368# Fake backend with specific topology1369backend = FakeMontreal()1370coupling_map = backend.configuration().coupling_map13711372print(f"Backend coupling map: {coupling_map[:10]}...") # First 10 edges13731374# Transpile with layout awareness1375transpiled = transpile(1376 qc,1377 backend=backend,1378 optimization_level=3,1379 seed_transpiler=42 # For reproducibility1380)13811382# Get final layout1383final_layout = transpiled.layout.final_index_layout()1384print(f"\nFinal qubit layout: {final_layout}")13851386print(f"\nOriginal circuit:")1387print(f" Depth: {qc.depth()}")1388print(f" CNOT count: {qc.count_ops().get('cx', 0)}")13891390print(f"\nTranspiled circuit (with routing):")1391print(f" Depth: {transpiled.depth()}")1392print(f" CNOT count: {transpiled.count_ops().get('cx', 0)}")1393print(f" SWAP count: {transpiled.count_ops().get('swap', 0)}")1394```13951396## Quantum Information Theory13971398### Entanglement Measures13991400```python1401from qiskit.quantum_info import Statevector, DensityMatrix, partial_trace1402from qiskit.quantum_info import entropy, entanglement_of_formation1403from qiskit import QuantumCircuit1404import numpy as np14051406# Create entangled state (Bell state)1407qc = QuantumCircuit(2)1408qc.h(0)1409qc.cx(0, 1)14101411state = Statevector.from_instruction(qc)1412density_matrix = DensityMatrix(state)14131414print(f"Bell state: {state}")14151416# Von Neumann entropy (should be 0 for pure states)1417entropy_full = entropy(density_matrix)1418print(f"\nFull system entropy: {entropy_full:.6f}")14191420# Reduced density matrix (trace out qubit 1)1421rho_0 = partial_trace(density_matrix, [1])1422entropy_reduced = entropy(rho_0)1423print(f"Reduced density matrix entropy: {entropy_reduced:.6f}")14241425# Entanglement of formation1426# For Bell state, should be 11427eof = entanglement_of_formation(density_matrix)1428print(f"Entanglement of formation: {eof:.6f}")14291430# Compare with separable state1431qc_sep = QuantumCircuit(2)1432qc_sep.h(0)1433qc_sep.h(1)14341435state_sep = Statevector.from_instruction(qc_sep)1436dm_sep = DensityMatrix(state_sep)14371438rho_0_sep = partial_trace(dm_sep, [1])1439entropy_sep = entropy(rho_0_sep)1440print(f"\nSeparable state reduced entropy: {entropy_sep:.6f}")1441```14421443### Quantum Channels and Process Tomography14441445```python1446from qiskit.quantum_info import Choi, SuperOp, Kraus1447from qiskit import QuantumCircuit1448import numpy as np14491450# Define a quantum channel (amplitude damping)1451def amplitude_damping_channel(gamma):1452 """1453 Amplitude damping channel with damping parameter gamma.1454 1455 Models energy dissipation.1456 """1457 K0 = np.array([[1, 0], [0, np.sqrt(1 - gamma)]])1458 K1 = np.array([[0, np.sqrt(gamma)], [0, 0]])1459 1460 return Kraus([K0, K1])14611462# Create channel1463gamma = 0.31464channel = amplitude_damping_channel(gamma)14651466print(f"Amplitude damping channel (γ={gamma}):")1467print(f"Number of Kraus operators: {len(channel)}")14681469# Convert to different representations1470superop = SuperOp(channel)1471choi = Choi(channel)14721473print(f"\nSuperoperator shape: {superop.dim}")1474print(f"Choi matrix shape: {choi.dim}")14751476# Apply channel to a state1477from qiskit.quantum_info import Statevector, DensityMatrix14781479# Initial state |1⟩1480state = Statevector([0, 1])1481dm = DensityMatrix(state)14821483# Apply channel1484dm_evolved = dm.evolve(channel)14851486print(f"\nInitial state: {state}")1487print(f"After channel: {dm_evolved}")14881489# Measure fidelity1490from qiskit.quantum_info import state_fidelity1491fidelity = state_fidelity(dm, dm_evolved)1492print(f"Fidelity: {fidelity:.6f}")1493```14941495### Quantum State Tomography14961497```python1498from qiskit.quantum_info import Statevector, DensityMatrix1499from qiskit import QuantumCircuit1500from qiskit.providers.aer import AerSimulator1501from qiskit.quantum_info.states import state_fidelity1502import numpy as np15031504def perform_state_tomography(qc, shots=1000):1505 """1506 Simplified quantum state tomography.1507 1508 Measures in X, Y, Z bases to reconstruct density matrix.1509 """1510 simulator = AerSimulator()1511 1512 # Measurement circuits in different bases1513 measurements = {1514 'Z': QuantumCircuit(qc.num_qubits, qc.num_qubits),1515 'X': QuantumCircuit(qc.num_qubits, qc.num_qubits),1516 'Y': QuantumCircuit(qc.num_qubits, qc.num_qubits)1517 }1518 1519 # X basis: apply H before measurement1520 measurements['X'].h(range(qc.num_qubits))1521 1522 # Y basis: apply S†H before measurement1523 measurements['Y'].sdg(range(qc.num_qubits))1524 measurements['Y'].h(range(qc.num_qubits))1525 1526 # Measure all1527 for basis_circ in measurements.values():1528 basis_circ.measure(range(qc.num_qubits), range(qc.num_qubits))1529 1530 # Run measurements1531 results = {}1532 for basis, meas_circ in measurements.items():1533 full_circ = qc.copy()1534 full_circ.compose(meas_circ, inplace=True)1535 1536 job = simulator.run(full_circ, shots=shots)1537 results[basis] = job.result().get_counts()1538 1539 print(f"Z-basis measurements: {results['Z']}")1540 print(f"X-basis measurements: {results['X']}")1541 print(f"Y-basis measurements: {results['Y']}")1542 1543 # Simplified reconstruction (for single qubit)1544 if qc.num_qubits == 1:1545 # Extract Pauli expectation values1546 z_exp = (results['Z'].get('0', 0) - results['Z'].get('1', 0)) / shots1547 x_exp = (results['X'].get('0', 0) - results['X'].get('1', 0)) / shots1548 y_exp = (results['Y'].get('0', 0) - results['Y'].get('1', 0)) / shots1549 1550 # Reconstruct density matrix: ρ = (I + x⟨X⟩ + y⟨Y⟩ + z⟨Z⟩)/21551 rho = np.array([1552 [0.5 + 0.5*z_exp, 0.5*x_exp - 0.5j*y_exp],1553 [0.5*x_exp + 0.5j*y_exp, 0.5 - 0.5*z_exp]1554 ])1555 1556 return DensityMatrix(rho)1557 1558 return None15591560# Test on a known state1561qc = QuantumCircuit(1)1562qc.ry(np.pi/3, 0) # Rotate to create superposition15631564# True state1565true_state = Statevector.from_instruction(qc)1566true_dm = DensityMatrix(true_state)15671568# Tomography1569reconstructed_dm = perform_state_tomography(qc, shots=10000)15701571if reconstructed_dm is not None:1572 fidelity = state_fidelity(true_dm, reconstructed_dm)1573 print(f"\nReconstruction fidelity: {fidelity:.6f}")1574 print(f"\nTrue density matrix:\n{np.array(true_dm)}")1575 print(f"\nReconstructed density matrix:\n{np.array(reconstructed_dm)}")1576```15771578## Visualization15791580### Circuit Visualization15811582```python1583from qiskit import QuantumCircuit1584from qiskit.visualization import circuit_drawer1585import matplotlib.pyplot as plt15861587# Create complex circuit1588qc = QuantumCircuit(3, 3)1589qc.h(0)1590qc.cx(0, 1)1591qc.cx(1, 2)1592qc.barrier()1593qc.measure([0, 1, 2], [0, 1, 2])15941595# Different drawing styles1596print("Text representation:")1597print(qc.draw(output='text'))15981599# Matplotlib style (most common)1600print("\nMatplotlib style:")1601qc.draw(output='mpl')1602plt.show()16031604# LaTeX style (for publications)1605# qc.draw(output='latex')16061607# With gate labels1608qc_labeled = QuantumCircuit(2, 2)1609qc_labeled.h(0)1610qc_labeled.cx(0, 1)1611qc_labeled.measure_all()16121613qc_labeled.draw(output='mpl', style={'name': 'bw'})1614plt.show()1615```16161617### Result Visualization16181619```python1620from qiskit import QuantumCircuit1621from qiskit.providers.aer import AerSimulator1622from qiskit.visualization import plot_histogram, plot_bloch_multivector1623from qiskit.quantum_info import Statevector1624import matplotlib.pyplot as plt16251626# Run circuit1627qc = QuantumCircuit(2, 2)1628qc.h(0)1629qc.cx(0, 1)1630qc.measure([0, 1], [0, 1])16311632simulator = AerSimulator()1633job = simulator.run(qc, shots=1000)1634counts = job.result().get_counts()16351636# Histogram1637plot_histogram(counts, title='Bell State Measurement')1638plt.show()16391640# Multiple result comparison1641qc2 = QuantumCircuit(2, 2)1642qc2.h(0)1643qc2.h(1)1644qc2.measure([0, 1], [0, 1])16451646job2 = simulator.run(qc2, shots=1000)1647counts2 = job2.result().get_counts()16481649plot_histogram([counts, counts2], 1650 legend=['Bell State', 'Product State'],1651 title='State Comparison')1652plt.show()16531654# Bloch sphere visualization1655qc_bloch = QuantumCircuit(1)1656qc_bloch.ry(np.pi/4, 0)16571658state = Statevector.from_instruction(qc_bloch)1659plot_bloch_multivector(state)1660plt.show()1661```16621663### State Visualization16641665```python1666from qiskit.quantum_info import Statevector, DensityMatrix1667from qiskit.visualization import plot_state_qsphere, plot_state_city1668from qiskit.visualization import plot_state_hinton, plot_state_paulivec1669import matplotlib.pyplot as plt16701671# Create an interesting state1672from qiskit import QuantumCircuit1673qc = QuantumCircuit(2)1674qc.h(0)1675qc.ry(np.pi/4, 1)1676qc.cx(0, 1)16771678state = Statevector.from_instruction(qc)16791680# Q-sphere1681plot_state_qsphere(state, title='Q-sphere')1682plt.show()16831684# City plot1685plot_state_city(state, title='State City')1686plt.show()16871688# Hinton plot1689dm = DensityMatrix(state)1690plot_state_hinton(dm, title='Density Matrix')1691plt.show()16921693# Pauli vector representation1694plot_state_paulivec(state, title='Pauli Vector')1695plt.show()1696```16971698## Practical Workflows16991700### Complete VQE Workflow for Molecule17011702```python1703from qiskit_nature.second_q.drivers import PySCFDriver1704from qiskit_nature.second_q.mappers import JordanWignerMapper1705from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock1706from qiskit.algorithms import VQE1707from qiskit.algorithms.optimizers import SLSQP1708from qiskit.primitives import Estimator1709import numpy as np17101711def calculate_molecule_energy(atom_string, basis='sto3g', charge=0, spin=0):1712 """1713 Complete workflow for molecular energy calculation.1714 1715 Args:1716 atom_string: Atomic coordinates (e.g., 'H 0 0 0; H 0 0 0.735')1717 basis: Basis set1718 charge: Molecular charge1719 spin: Spin multiplicity1720 """1721 print(f"Calculating energy for: {atom_string}")1722 print(f"Basis: {basis}, Charge: {charge}, Spin: {spin}\n")1723 1724 # 1. Setup driver1725 driver = PySCFDriver(1726 atom=atom_string,1727 basis=basis,1728 charge=charge,1729 spin=spin1730 )1731 1732 # 2. Get electronic structure problem1733 problem = driver.run()1734 1735 # 3. Setup mapper1736 mapper = JordanWignerMapper()1737 1738 # 4. Get Hamiltonian1739 hamiltonian = problem.hamiltonian.second_q_op()1740 qubit_op = mapper.map(hamiltonian)1741 1742 print(f"Number of qubits: {qubit_op.num_qubits}")1743 print(f"Number of Hamiltonian terms: {len(qubit_op)}")1744 1745 # 5. Setup initial state and ansatz1746 num_particles = problem.num_particles1747 num_spatial_orbitals = problem.num_spatial_orbitals1748 1749 init_state = HartreeFock(1750 num_spatial_orbitals=num_spatial_orbitals,1751 num_particles=num_particles,1752 qubit_mapper=mapper1753 )1754 1755 ansatz = UCCSD(1756 num_spatial_orbitals=num_spatial_orbitals,1757 num_particles=num_particles,1758 qubit_mapper=mapper,1759 initial_state=init_state1760 )1761 1762 print(f"Ansatz circuit depth: {ansatz.depth()}")1763 print(f"Number of parameters: {ansatz.num_parameters}\n")1764 1765 # 6. Run VQE1766 optimizer = SLSQP(maxiter=100)1767 estimator = Estimator()1768 1769 vqe = VQE(estimator, ansatz, optimizer)1770 result = vqe.compute_minimum_eigenvalue(qubit_op)1771 1772 # 7. Extract results1773 vqe_energy = result.eigenvalue1774 hf_energy = problem.reference_energy1775 1776 print(f"Hartree-Fock energy: {hf_energy:.6f} Ha")1777 print(f"VQE energy: {vqe_energy:.6f} Ha")1778 print(f"Correlation energy: {vqe_energy - hf_energy:.6f} Ha")1779 print(f"Optimizer evaluations: {result.cost_function_evals}")1780 1781 return {1782 'vqe_energy': vqe_energy,1783 'hf_energy': hf_energy,1784 'correlation': vqe_energy - hf_energy,1785 'optimal_parameters': result.optimal_parameters,1786 'num_qubits': qubit_op.num_qubits1787 }17881789# Example: H2 molecule1790results = calculate_molecule_energy('H 0 0 0; H 0 0 0.735')1791```17921793### Quantum Circuit Optimization Pipeline17941795```python1796from qiskit import QuantumCircuit, transpile1797from qiskit.providers.fake_provider import FakeMontreal1798from qiskit.transpiler import PassManager, CouplingMap1799from qiskit.transpiler.passes import *1800import matplotlib.pyplot as plt18011802def optimize_circuit_for_hardware(qc, backend=None, optimization_level=3):1803 """1804 Complete circuit optimization pipeline.1805 1806 Args:1807 qc: Input quantum circuit1808 backend: Target backend (or None for generic optimization)1809 optimization_level: 0-31810 """1811 print(f"Original circuit:")1812 print(f" Qubits: {qc.num_qubits}")1813 print(f" Depth: {qc.depth()}")1814 print(f" Gate count: {len(qc.data)}")1815 print(f" Operations: {qc.count_ops()}\n")1816 1817 if backend is None:1818 backend = FakeMontreal()1819 1820 # Standard transpilation1821 transpiled = transpile(1822 qc,1823 backend=backend,1824 optimization_level=optimization_level,1825 seed_transpiler=421826 )1827 1828 print(f"After transpilation (level {optimization_level}):")1829 print(f" Depth: {transpiled.depth()}")1830 print(f" Gate count: {len(transpiled.data)}")1831 print(f" Operations: {transpiled.count_ops()}")1832 print(f" SWAP gates: {transpiled.count_ops().get('swap', 0)}\n")1833 1834 # Custom optimization passes1835 pm = PassManager()1836 1837 # Add passes1838 pm.append(Optimize1qGates())1839 pm.append(CommutativeCancellation())1840 pm.append(CXCancellation())1841 1842 further_optimized = pm.run(transpiled)1843 1844 print(f"After custom optimization:")1845 print(f" Depth: {further_optimized.depth()}")1846 print(f" Gate count: {len(further_optimized.data)}")1847 print(f" Operations: {further_optimized.count_ops()}\n")1848 1849 # Calculate reduction1850 depth_reduction = (1 - further_optimized.depth() / qc.depth()) * 1001851 gate_reduction = (1 - len(further_optimized.data) / len(qc.data)) * 1001852 1853 print(f"Optimization results:")1854 print(f" Depth reduction: {depth_reduction:.1f}%")1855 print(f" Gate count reduction: {gate_reduction:.1f}%")1856 1857 return further_optimized18581859# Example: Complex circuit1860qc = QuantumCircuit(4)1861qc.h(range(4))1862for i in range(3):1863 qc.cx(i, i+1)1864qc.barrier()1865for i in range(4):1866 qc.ry(np.pi/4, i)1867qc.barrier()1868for i in range(2):1869 qc.cx(i, i+2)18701871optimized = optimize_circuit_for_hardware(qc)1872```18731874### Quantum Algorithm Benchmarking18751876```python1877from qiskit import QuantumCircuit1878from qiskit.algorithms import VQE, QAOA1879from qiskit.algorithms.optimizers import SLSQP, COBYLA, SPSA1880from qiskit.circuit.library import RealAmplitudes1881from qiskit.primitives import Estimator1882from qiskit.quantum_info import SparsePauliOp1883import time1884import numpy as np18851886def benchmark_vqe_optimizers(hamiltonian, ansatz, optimizers_dict, trials=3):1887 """1888 Benchmark different optimizers for VQE.1889 1890 Args:1891 hamiltonian: Problem Hamiltonian1892 ansatz: Variational ansatz1893 optimizers_dict: Dict of optimizer name -> optimizer instance1894 trials: Number of trials per optimizer1895 """1896 results = {}1897 1898 for opt_name, optimizer in optimizers_dict.items():1899 print(f"\nBenchmarking {opt_name}...")1900 1901 trial_results = []1902 1903 for trial in range(trials):1904 estimator = Estimator()1905 vqe = VQE(estimator, ansatz, optimizer)1906 1907 start_time = time.time()1908 result = vqe.compute_minimum_eigenvalue(hamiltonian)1909 elapsed_time = time.time() - start_time1910 1911 trial_results.append({1912 'energy': result.eigenvalue,1913 'time': elapsed_time,1914 'evals': result.cost_function_evals1915 })1916 1917 print(f" Trial {trial + 1}: E = {result.eigenvalue:.6f}, "1918 f"Time = {elapsed_time:.2f}s, Evals = {result.cost_function_evals}")1919 1920 # Aggregate results1921 energies = [r['energy'] for r in trial_results]1922 times = [r['time'] for r in trial_results]1923 evals = [r['evals'] for r in trial_results]1924 1925 results[opt_name] = {1926 'mean_energy': np.mean(energies),1927 'std_energy': np.std(energies),1928 'mean_time': np.mean(times),1929 'mean_evals': np.mean(evals),1930 'best_energy': min(energies)1931 }1932 1933 # Print summary1934 print("\n" + "="*60)1935 print("BENCHMARK SUMMARY")1936 print("="*60)1937 print(f"{'Optimizer':<15} {'Best Energy':>12} {'Mean Time':>12} {'Mean Evals':>12}")1938 print("-"*60)1939 1940 for opt_name, res in results.items():1941 print(f"{opt_name:<15} {res['best_energy']:>12.6f} "1942 f"{res['mean_time']:>12.2f}s {res['mean_evals']:>12.0f}")1943 1944 return results19451946# Example: Benchmark for simple Hamiltonian1947hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5])1948ansatz = RealAmplitudes(num_qubits=2, reps=2)19491950optimizers = {1951 'SLSQP': SLSQP(maxiter=100),1952 'COBYLA': COBYLA(maxiter=100),1953 'SPSA': SPSA(maxiter=100)1954}19551956benchmark_results = benchmark_vqe_optimizers(hamiltonian, ansatz, optimizers, trials=3)1957```19581959## Common Pitfalls and Solutions19601961### Memory Management for Large Circuits19621963```python1964from qiskit import QuantumCircuit1965from qiskit.providers.aer import AerSimulator1966import numpy as np19671968# Problem: Simulating too many qubits1969def bad_simulation():1970 # DON'T DO THIS - will use ~2^25 * 16 bytes = 512 MB per state vector1971 qc = QuantumCircuit(25)1972 for i in range(25):1973 qc.h(i)1974 1975 # This will be very slow or crash1976 # simulator = AerSimulator(method='statevector')1977 # result = simulator.run(qc).result()19781979# Solution 1: Use sampling instead of statevector1980def good_simulation_sampling():1981 qc = QuantumCircuit(25, 25)1982 for i in range(25):1983 qc.h(i)1984 qc.measure_all()1985 1986 # Much more efficient - doesn't store full state vector1987 simulator = AerSimulator(method='automatic') # Chooses best method1988 result = simulator.run(qc, shots=1000).result()1989 counts = result.get_counts()1990 1991 return counts19921993# Solution 2: Use Matrix Product State for certain circuits1994def good_simulation_mps():1995 qc = QuantumCircuit(50) # Can handle more qubits!1996 1997 # MPS works well for circuits with limited entanglement1998 for i in range(49):1999 qc.h(i)2000 qc.cx(i, i+1) # Nearest-neighbor only2001 2002 simulator = AerSimulator(method='matrix_product_state')2003 qc.measure_all()2004 result = simulator.run(qc, shots=1000).result()2005 2006 return result.get_counts()20072008# Solution 3: Reduce circuit size2009def good_simulation_reduced():2010 # Use fewer qubits or simpler circuits2011 qc = QuantumCircuit(10) # More manageable2012 for i in range(10):2013 qc.h(i)2014 2015 simulator = AerSimulator()2016 qc.measure_all()2017 result = simulator.run(qc, shots=1000).result()2018 2019 return result.get_counts()20202021# Test solutions2022counts = good_simulation_sampling()2023print(f"Sampling method: {len(counts)} unique outcomes")2024```20252026### Handling Convergence Issues in VQE20272028```python2029from qiskit.algorithms import VQE2030from qiskit.algorithms.optimizers import SLSQP, COBYLA2031from qiskit.circuit.library import RealAmplitudes2032from qiskit.primitives import Estimator2033from qiskit.quantum_info import SparsePauliOp2034import numpy as np20352036def robust_vqe(hamiltonian, n_qubits, max_attempts=5):2037 """2038 VQE with multiple restart attempts and parameter initialization.2039 2040 Args:2041 hamiltonian: Problem Hamiltonian2042 n_qubits: Number of qubits2043 max_attempts: Maximum restart attempts2044 """2045 best_result = None2046 best_energy = float('inf')2047 2048 for attempt in range(max_attempts):2049 print(f"\nAttempt {attempt + 1}/{max_attempts}")2050 2051 # Create fresh ansatz2052 ansatz = RealAmplitudes(num_qubits=n_qubits, reps=2)2053 2054 # Initialize parameters randomly (but bounded)2055 initial_point = np.random.uniform(-np.pi, np.pi, ansatz.num_parameters)2056 2057 # Try different optimizers2058 if attempt < max_attempts // 2:2059 optimizer = COBYLA(maxiter=200)2060 else:2061 optimizer = SLSQP(maxiter=200)2062 2063 estimator = Estimator()2064 vqe = VQE(estimator, ansatz, optimizer, initial_point=initial_point)2065 2066 try:2067 result = vqe.compute_minimum_eigenvalue(hamiltonian)2068 2069 print(f" Energy: {result.eigenvalue:.6f}")2070 print(f" Evaluations: {result.cost_function_evals}")2071 2072 if result.eigenvalue < best_energy:2073 best_energy = result.eigenvalue2074 best_result = result2075 print(f" ✓ New best energy!")2076 2077 except Exception as e:2078 print(f" ✗ Failed: {e}")2079 continue2080 2081 if best_result is None:2082 raise RuntimeError("All VQE attempts failed")2083 2084 print(f"\nBest energy found: {best_energy:.6f}")2085 return best_result20862087# Example usage2088hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5])2089result = robust_vqe(hamiltonian, n_qubits=2, max_attempts=3)2090```