UCCSD Wavefunction Ansatz

Unitary Coupled Cluster with Singles and Doubles — the chemically-motivated ansatz behind most quantum chemistry VQE workflows. First understand what it is trying to express physically, then see how qalgora-Q assembles it into an optimizable circuit.

The problem it solves — which trial state to use

VQE needs a parameter-controlled trial state |ψ(θ)⟩, but you cannot pick the form of the ansatz arbitrarily: too rigid and it can never reach the true ground state; too unconstrained and the optimizer has nothing to grip onto, with no chemical meaning to boot. UCCSD's answer is to borrow a physically well-grounded ansatz from decades of quantum-chemistry coupled-cluster theory — expressive enough to capture electron correlation, yet carrying interpretable structure of its own.

Intuition — correcting outward from Hartree–Fock

The starting point is the Hartree–Fock reference state: fill electrons one by one into the lowest-energy orbitals to get a single determinant. It already captures most of the energy, but it misses electron correlation — the part of the physics where electrons avoid one another and refuse to crowd together. To recover it, you must let electrons "jump" from occupied orbitals into empty ones, i.e. apply excitations: a single excitation moves one electron to a different orbital, a double excitation moves two at once. UCCSD superposes all of these single and double excitations parametrically, and lets the optimizer decide how much of each to mix in.

The math — the unitary coupled-cluster operator

Sum all single and double excitation operators weighted by their parameters into the cluster operator T = T1 + T2. What UCCSD applies to the reference state is not T itself but its unitary form

|ψ(θ)⟩ = exp(T − T†) |HF⟩.

Here T − T† is anti-Hermitian, so exp(T − T†) is guaranteed unitary and maps directly onto reversible evolution in a quantum circuit — exactly why it suits a quantum machine better than classical coupled cluster (classical CCSD uses the non-unitary exp(T)). Each excitation contributes one parameter θ, and the whole thing is a family of trial states continuously controlled by θ.

The mechanism — Trotterizing into a circuit

The individual excitation operators inside the exponential generally do not commute, so you cannot cleanly split exp(T − T†) into a product of independent single-excitation exponentials. The practical recipe is Trotter decomposition: approximate the big exponential as a sequence of single-excitation exponentials multiplied in turn, and compile each excitation exponential into circuit blocks. After a Jordan–Wigner or Bravyi–Kitaev mapping, each fermionic single/double excitation generally becomes the exponential of several Pauli strings; each Pauli rotation in turn compiles into a basis change, a CNOT ladder, and a parameterized Rz(θ) — so one excitation corresponds to a group of gate blocks rather than a single CNOT plus one Rz. The Trotter error shrinks as the number of steps grows; most VQE workflows take a single first-order step, because the subsequent parameter optimization can partly absorb the residual error itself. Note that the gate ordering, the number of Trotter steps, and the ordering of the excitation operators all affect the ansatz's expressivity and how easy it is to optimize.

How the parameter count grows with size

The number of parameters equals the number of excitations. The count of single excitations is roughly the number of occupied orbitals times the number of virtual orbitals; the count of doubles is the number of ways to choose two occupied orbitals and two virtual orbitals, which grows far faster with system size. Roughly speaking the parameter count scales as O(Nocc2 · Nvirt2), with the doubles as the dominant term. This is the source of UCCSD's expressive power and also the reason it becomes expensive on large molecules — both the circuit depth and the number of parameters to optimize swell along with it. The exact count depends on whether you use a spin-orbital or a spin-adapted form, on symmetry tapering, and on the implementation, so uccsd_num_parameters may differ across frameworks.

Honest limitations

• "Singles + doubles" is a deliberate truncation. Omitting triple and higher excitations may not be accurate enough for strongly correlated, multireference systems, which can require triples (UCCSDT) or adaptive methods such as ADAPT-VQE; it is a trade-off between expressiveness and cost.
• Trotterization introduces approximation error. Too few steps and the error is large; too many and the circuit becomes too deep — a balance is required.
• Circuit depth rises with size. The rapid growth in the number of doubles quickly outruns the coherence time of near-term hardware, which is what motivated adaptive methods like ADAPT-VQE that select only the operators they truly need.
• It is still bound by the variational principle and the optimization landscape. UCCSD gives a principled ansatz, not a guarantee of reaching the exact ground state.

Seeing it in code

Read this circuit against the discussion above. The opening for i in range(n_electrons): x(q[i]) uses x gates to fill electrons one by one into the lowest orbitals, preparing exactly the Hartree–Fock reference state; this assumes a qubit ordering in which the first n_electrons qubits correspond to the lowest occupied spin-orbitals. Then qalgora.kernels.uccsd(...) expands all single and double excitations, each a parameterized rotation controlled by θ — that is, the Trotterized circuit of exp(T − T†). uccsd_num_parameters(...) simply counts the total number of excitations described above, which is the number of parameters to optimize.

Implementation

import qalgora

@qalgora.kernel
def uccsd(thetas: list[float], n_qubits: int, n_electrons: int):
    q = qalgora.qvector(n_qubits)
    for i in range(n_electrons):     # Hartree-Fock reference
        x(q[i])
    # single + double excitations, each a parameterized rotation
    qalgora.kernels.uccsd(q, thetas, n_electrons, n_qubits)

# count parameters for the excitation pool
n_params = qalgora.kernels.uccsd_num_parameters(n_electrons=2, n_qubits=4)

Running VQE

With the ansatz in hand, hand it to VQE: the optimizer tunes thetas to drive the energy down toward the ground state. The number of parameters is given by the total excitation count we counted above.

optimizer = qalgora.optimizers.LBFGS()
energy, params = qalgora.vqe(uccsd, hamiltonian, optimizer,
                             parameter_count=n_params)
print("UCCSD ground-state energy:", energy)