Variational quantum algorithms (VQAs) bridge classical optimization with quantum computation, offering a practical approach for near-term quantum hardware. Within the Noisy Intermediate-Scale Quantum (NISQ) era, frameworks like Qiskit enable efficient prototyping of hybrid quantum-classical workflows.

Core Principles and Architecture

VQAs rely on parameterized quantum circuits—known as ansätze—to prepare trial quantum states. The algorithm iteratively:

1. Executes the circuit on a quantum backend to estimate the expectation value of a target observable (e.g., a Hamiltonian)
2. Feeds this value to a classical optimizer
3. Updates circuit parameters to minimize the cost function

This loop conitnues until convergence to a local or global minimum.

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter

phi = Parameter('φ')
qc = QuantumCircuit(2)
qc.ry(phi, 0)
qc.cx(0, 1)
qc.ry(-phi, 1)

This minimal two-qubit ansatz uses a single trainable parameter to generate entangled states via Y-rotations and a CNOT gate.

Theoretical Underpinnings

The variational principle asserts that for any normalized trial state |ψ(θ)⟩, the expectation ⟨ψ(θ)|H|ψ(θ)⟩ is always greater than or equal to the ground-state energy of H. VQAs exploit this by treating θ as optimization variables.

A typical cost evaluation involves measuring Pauli strings. For instance, estimating ⟨Z₀ ⊗ Z₁⟩ requires correlating measurement outcomes across qubits.

from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp

hamiltonian = SparsePauliOp.from_list([("ZZ", 1.0)])
estimator = Estimator()
job = estimator.run([qc], [hamiltonian], [[0.5]])
result = job.result()
print(result.values[0])

Ansatz Design Guidelines

Effective parameterized circuits balance expressivity and trainability:

• Use rotation gates (RX, RY, RZ) for tunable single-qubit operations
• Incorporate entangling gates (e.g., CNOT, CZ) to model correlations
• Limit depth to mitigate noise accumulation on real devices

Hardware-aware design respects connectivity constraints. For example, on a linear topology, only adjacent qubits can intercat directly.

Optimization Integration

Qiskit’s VQE and QAOA classes abstract the hybrid loop. Optimizers like SPSA (Simultaneous Perturbation Stochastic Approximation) are robust to measurement noise:

from qiskit.algorithms.optimizers import SPSA
from qiskit.algorithms.minimum_eigensolvers import VQE

optimizer = SPSA(maxiter=80)
vqe_solver = VQE(ansatz=qc, optimizer=optimizer, estimator=Estimator())
ground_energy = vqe_solver.compute_minimum_eigenvalue(hamiltonian).eigenvalue

Practical Applications

Molecular Ground-State Estimation

For H₂ in the STO-3G basis, the electronic Hamiltonian reduces to a 2-qubit operator. A hardware-efficient ansatz suffices for accurate energy estimation.

Combinatorial Optimization with QAOA

The Max-Cut problem maps naturally to an Ising Hamiltonian. QAOA alternates between problem-inspired and mixer unitaries:

from qiskit.algorithms.minimum_eigensolvers import QAOA
from qiskit_optimization.applications import Maxcut

graph = [(0, 1, 1.0), (1, 2, 1.0)]  # edge list
maxcut = Maxcut(graph)
ising_op, offset = maxcut.to_quadratic_program().to_ising()

qaoa_solver = QAOA(reps=2, optimizer=SPSA(maxiter=50), estimator=Estimator())
result = qaoa_solver.compute_minimum_eigenvalue(ising_op)

Variational Quantum Classifiers

In supervised learning, input features are encoded into quantum states, followed by a trainable layer. The final measurement yields a class prediction:

def build_vqc(num_qubits, num_features):
    from qiskit.circuit.library import RealAmplitudes, ZFeatureMap
    feature_map = ZFeatureMap(feature_dimension=num_features, reps=1)
    variational_form = RealAmplitudes(num_qubits, reps=2)
    return feature_map + variational_form

Challenges and Mitigations

VQAs face several limitations:

• Barren plateaus: Gradients vanish exponentially with qubit count. Mitigation includes structured ansätze or layer-wise training.
• Noise sensitivity: Measurement error mitigation (e.g., using LocalReadoutMitigator) improves result fidelity.
• Local minima: Multi-start optimization or warm starts from classical heuristics enhance robustness.

Current benchmarks show reliable performance up to ~12 qubits for chemistry and ~8 for optimization, constrained by classical optimizer scalability and quantum coherence times.