Skip to content

Variational Quantum Eigensolver (VQE)

VQE is a hybrid quantum-classical algorithm for finding the ground state energy of quantum systems, particularly molecules. QPyth provides a comprehensive VQE implementation with support for multiple molecules and execution modes.

Overview

VQE works by: 1. Preparing a parameterized quantum circuit (ansatz) 2. Measuring the expectation value of the Hamiltonian 3. Using a classical optimizer to minimize the energy 4. Iterating until convergence

Supported Molecules

QPyth includes predefined configurations for several molecules:

  • H₂ - Dihydrogen at equilibrium (0.735 Å)
  • LiH - Lithium hydride at equilibrium (1.595 Å)
  • HeH⁺ - Helium hydride ion (1.463 Å)
  • BeH₂ - Beryllium hydride linear geometry
  • H₂O - Water molecule at equilibrium geometry

Basic Usage

CLI

qpy
# Select option 7: Molecular Ground-State (VQE Sim)

Python API

from quantumpytho.modules.vqe_h2_cli import run_vqe_h2_cli

# Run VQE for H2 molecule
run_vqe_h2_cli()

Web UI

  1. Start the web UI (see Web UI)
  2. Navigate to the VQE tab
  3. Select a molecule
  4. Choose execution mode
  5. Click "Run VQE"

Execution Modes

Ideal Simulator

Default mode using Qiskit Aer with no noise:

from quantumpytho.config import ExecutionMode, QuantumConfig

config = QuantumConfig(mode=ExecutionMode.SIMULATOR)

Noisy Simulator

Realistic simulation using IBM calibration data:

config = QuantumConfig(
    mode=ExecutionMode.NOISY_SIMULATOR,
    noise_profile="ibm_brisbane"
)

IBM Quantum Hardware

Run on real IBM Quantum hardware:

config = QuantumConfig(
    mode=ExecutionMode.HARDWARE,
    backend="ibm_brisbane"
)

Advanced Usage

Custom Molecules

Define custom molecules:

from quantumpytho.modules.vqe_molecules import MoleculeConfig

custom_molecule = MoleculeConfig(
    name="Custom",
    formula="AB",
    geometry=[(0, 0, 0), (1.0, 0, 0)],
    charge=0,
    multiplicity=1,
    basis="sto3g"
)

Custom Ansatz

Use custom parameterized circuits:

from qiskit.circuit import QuantumCircuit, ParameterVector

def custom_ansatz(num_qubits, depth):
    qc = QuantumCircuit(num_qubits)
    params = ParameterVector('θ', num_qubits * depth)

    for d in range(depth):
        for i in range(num_qubits):
            qc.ry(params[d * num_qubits + i], i)
        for i in range(num_qubits - 1):
            qc.cx(i, i + 1)

    return qc

Custom Optimizer

Use different classical optimizers:

from qiskit_algorithms.optimizers import SPSA, COBYLA, SLSQP

# Use SPSA optimizer
optimizer = SPSA(maxiter=100)

# Use COBYLA optimizer
optimizer = COBYLA(maxiter=100)

# Use SLSQP optimizer
optimizer = SLSQP(maxiter=100)

Physical vs Lightweight VQE

Physical VQE

Calculates actual physical energies using PySCF:

from quantumpytho.modules.vqe_h2_exact import run_vqe_h2_physical

result = run_vqe_h2_physical()
print(f"Physical energy: {result['energy']} Hartree")

Requirements: 

pip install QPyth[physical]

Lightweight VQE

Faster simulation without physical energies:

from quantumpytho.modules.vqe_h2_cli import run_vqe_h2_cli

run_vqe_h2_cli()

Bond Distance Scanning

Scan bond distances to find equilibrium geometry:

from quantumpytho.modules.vqe_utils import scan_h2_bond_distances

# Scan H2 bond distances
result = scan_h2_bond_distances(
    distances=[0.5, 0.6, 0.735, 0.8, 0.9, 1.0],
    max_iters=50
)

print(f"Equilibrium distance: {result['equilibrium_distance']} Å")
print(f"Minimum energy: {result['min_energy']} Hartree")

Results Interpretation

Energy Convergence

VQE produces an energy convergence curve:

result = {
    'energies': [
        {'iteration': 0, 'energy': -1.1},
        {'iteration': 1, 'energy': -1.15},
        {'iteration': 2, 'energy': -1.16},
        # ...
    ],
    'final_energy': -1.16,
    'iterations': 50,
    'converged': True
}

Comparison with Reference

Compare VQE results with reference energies:

from quantumpytho.modules.vqe_molecules import get_reference_energy

# Get reference energy for H2
ref_energy = get_reference_energy('H2')
print(f"Reference energy: {ref_energy} Hartree")

# Calculate error
error = abs(result['final_energy'] - ref_energy)
print(f"Error: {error:.6f} Hartree")

Performance Tips

  1. Start with ideal simulator - Use noisy simulator or hardware only for final validation
  2. Optimize circuit depth - Balance accuracy and computational cost
  3. Choose appropriate optimizer - SPSA is robust for noisy environments
  4. Use appropriate shots - More shots = better statistics but slower
  5. Leverage symmetry - Reduce problem size using molecular symmetries

Troubleshooting

Missing Dependencies

For physical VQE:

pip install QPyth[physical]

Convergence Issues

  • Increase max iterations
  • Try different optimizers
  • Check initial parameters
  • Verify ansatz expressibility

Hardware Execution Issues

  • Verify IBM Quantum token
  • Check backend availability
  • Ensure sufficient qubits
  • Monitor queue times

References

Next Steps