quantum-boltzmann-bilevel

name: quantum-boltzmann-bilevel description: "Build fully connected Quantum Boltzmann Machines using bilevel optimization to overcome QAOA's fixed target Hamiltonian limitation and classical Boltzmann machines' partial connectivity constraint. Use when designing quantum generative models, energy-based quantum models, quantum sampling algorithms, or quantum optimization circuits. Triggers: quantum Boltzmann machine, QAOA, bilevel optimization, fully connected Boltzmann, quantum generative model, energy-based quantum model, quantum sampling, quantum annealing, Hamiltonian learning"

Quantum Boltzmann Machine via Bilevel Optimization

Overview

This skill provides techniques for building fully connected Quantum Boltzmann Machines (QBMs) by extending QAOA circuits with bilevel optimization. This overcomes two fundamental limitations: QAOA's fixed target Hamiltonian constraint and classical Boltzmann machines' partial connectivity.

Based on: Breaking QAOA's Fixed Target Hamiltonian Barrier: A Fully Connected Quantum Boltzmann Machine via Bilevel Optimization (arxiv:2605.07473, May 2026).

Core Problems Addressed

Problem 1: QAOA's Fixed Target Hamiltonian

Standard QAOA uses a fixed mixer + problem Hamiltonian:

|ψ⟩ = e^(-iβₚH_M) e^(-iγₚH_C) ... e^(-iβ₁H_M) e^(-iγ₁H_C) |+⟩ⁿ

The target Hamiltonian H_C is fixed by the problem — QAOA cannot learn or optimize the Hamiltonian itself.

Problem 2: Classical Boltzmann Machines Are Partially Connected

Classical BMs require tractable sampling, limiting them to:

• Restricted Boltzmann Machines (RBM): bipartite, no visible-visible or hidden-hidden connections
• Deep Belief Networks: layered, limited connectivity

Fully connected classical BMs have intractable partition functions.

The Solution: Bilevel QAOA for QBMs

The key insight: use bilevel optimization where the outer loop learns the optimal target Hamiltonian and the inner loop optimizes circuit parameters:

Outer loop (Hamiltonian learning):
    min_H  L(H, θ*(H))

Inner loop (circuit optimization):
    θ*(H) = argmin_θ  E_θ[H] - S(ρ_θ)  (free energy minimization)

Technique 1: Bilevel Optimization Framework

def bilevel_qbm_optimization(data, n_qubits, p_layers, lr_outer=0.01, lr_inner=0.1):
    """
    Bilevel optimization for Quantum Boltzmann Machine.
    
    Outer loop: Learn Hamiltonian parameters J_ij, h_i
    Inner loop: Optimize QAOA circuit angles γ, β
    """
    # Initialize Hamiltonian parameters (fully connected)
    J = np.zeros((n_qubits, n_qubits))  # Coupling matrix
    h = np.zeros(n_qubits)               # Local fields
    
    for outer_step in range(n_outer_steps):
        # === INNER LOOP: Circuit optimization ===
        gamma, beta = initialize_angles(p_layers)
        
        for inner_step in range(n_inner_steps):
            # Build QAOA circuit with current Hamiltonian
            state = build_qaoa_circuit(gamma, beta, J, h)
            
            # Compute free energy gradient
            energy_grad = compute_energy_gradient(state, J, h)
            entropy_grad = compute_entropy_gradient(state)
            
            # Update angles to minimize free energy
            gamma -= lr_inner * (energy_grad - temperature * entropy_grad)
            beta -= lr_inner * compute_mixer_gradient(state)
        
        # === OUTER LOOP: Hamiltonian learning ===
        # Compute gradient of outer objective w.r.t. Hamiltonian
        # Using implicit differentiation through inner solution
        dL_dJ = compute_outer_gradient(data, state, gamma, beta)
        dL_dh = compute_local_field_gradient(data, state, gamma, beta)
        
        # Update Hamiltonian parameters
        J -= lr_outer * dL_dJ
        h -= lr_outer * dL_dh
        
        # Enforce symmetry: J_ij = J_ji
        J = (J + J.T) / 2
    
    return J, h

Technique 2: Fully Connected Hamiltonian Parameterization

The learned Hamiltonian allows arbitrary connectivity:

def build_fully_connected_hamiltonian(J, h, n_qubits):
    """
    Build fully connected Ising-type Hamiltonian:
    
    H = -Σ_{i<j} J_ij Z_i Z_j - Σ_i h_i Z_i
    
    Unlike classical BMs, all pairs (i,j) can have non-zero couplings.
    """
    H = np.zeros((2**n_qubits, 2**n_qubits), dtype=complex)
    
    for i in range(n_qubits):
        # Local field term
        for state in range(2**n_qubits):
            spin_i = 1 if (state >> i) & 1 else -1
            H[state, state] -= h[i] * spin_i
        
        # Coupling terms (fully connected!)
        for j in range(i+1, n_qubits):
            for state in range(2**n_qubits):
                spin_i = 1 if (state >> i) & 1 else -1
                spin_j = 1 if (state >> j) & 1 else -1
                H[state, state] -= J[i, j] * spin_i * spin_j
    
    return H

Key advantage: Classical RBMs cannot model these interactions directly because the partition function becomes intractable. The quantum circuit provides efficient sampling.

Technique 3: Quantum-Classical Nested Optimization

The nested loop structure:

┌─────────────────────────────────────────────┐
│ Outer Loop: Learn H (Hamiltonian)           │
│                                             │
│   ┌───────────────────────────────────┐     │
│   │ Inner Loop: Optimize θ (angles)   │     │
│   │                                   │     │
│   │  min_θ  F(θ; H) = ⟨H⟩_θ - TS(θ)  │     │
│   │  where F = free energy            │     │
│   │                                   │     │
│   └───────────────────────────────────┘     │
│                                             │
│   Update H: min_H D_KL(p_data || p_model)  │
│                                             │
└─────────────────────────────────────────────┘

Implementation considerations:

• Inner loop converges when free energy change < ε
• Outer loop uses implicit differentiation or finite differences
• Number of QAOA layers p controls expressivity (typically p=2-8)
• Temperature T controls exploration vs. exploitation

Technique 4: Energy-Based Quantum Generative Modeling

Once trained, the QBM generates samples:

def qbm_sample(J, h, gamma, beta, n_samples):
    """
    Generate samples from the trained QBM by running the optimized
    QAOA circuit and measuring in the computational basis.
    """
    samples = []
    for _ in range(n_samples):
        # Run optimized circuit
        state = build_qaoa_circuit(gamma, beta, J, h)
        # Measure to get bitstring
        sample = measure_computational_basis(state)
        samples.append(sample)
    return np.array(samples)

The distribution p(x) ∝ exp(-E(x)/T) where E(x) is determined by the learned Hamiltonian — the QBM naturally captures complex, multi-modal distributions.

Activation Scenarios

Use this skill when:

• Building quantum generative models that surpass classical RBMs
• Need fully connected energy-based models (classical BMs are limited)
• Extending QAOA beyond fixed problem Hamiltonians
• Designing quantum sampling algorithms for complex distributions
• Working on combinatorial optimization via quantum annealing
• Implementing quantum approximate thermal states
• Comparing quantum vs. classical generative models

Comparison: QBM vs. Classical Alternatives

Anti-Patterns to Avoid

1. Too few QAOA layers — p=1 is essentially classical; use p≥3 for quantum advantage
2. Ignoring temperature — Temperature is a critical hyperparameter; don't set T=0
3. Overfitting Hamiltonian — Regularize J matrix (e.g., sparsity penalty) to prevent overfitting
4. No convergence check — Inner loop must converge before outer step; don't use fixed iteration counts
5. Classical simulation limits — Full state vector simulation is O(2ⁿ); use tensor network or sampling-based methods for n>20