Generating the Electronic Hamiltonian

Turn a molecule into a qubit Hamiltonian: compute integrals, build the second-quantized operator, and map fermions to qubits.

The problem it solves

Every quantum-chemistry algorithm — VQE, QSCI, SKQD — needs the molecular Hamiltonian as a qubit operator: a weighted sum of Pauli strings the device can measure. But you start from something very different: a molecule, given as nuclei at positions in 3-D space with a cloud of electrons. This page is about the pipeline that bridges the two — geometry in, qubit operator out.

Second quantization

Within the Born–Oppenheimer approximation the nuclei are frozen and we solve for the electrons. First pick a finite basis set of single-particle orbitals; the electronic Hamiltonian is then written in second quantization using creation and annihilation operators a† and a, which add or remove an electron in an orbital:

H = Σpq hpq a†paq + ½ Σpqrs hpqrs a†pa†qaras

The first sum is the one-body part (an electron's kinetic energy plus its attraction to the nuclei); the second is the two-body part (electron–electron repulsion).

One- and two-electron integrals

The coefficients are not free parameters — they are definite integrals over the chosen orbitals, computed classically by a mean-field (e.g. Hartree–Fock) and integral code. The one-electron integrals hpq capture kinetic energy and nuclear attraction; the two-electron integrals hpqrs capture the repulsion between electrons. Together they pin down the Hamiltonian numerically for a given molecule and basis. Be careful with conventions: hpq are the one-electron integrals and hpqrs the two-electron integrals, but different integral notations order the two-body indices differently, so the convention must match the quantum-chemistry backend you use.

Mapping fermions to qubits

Electrons are fermions: their operators anticommute and the wavefunction must change sign when two are swapped. Qubits have no such rule, so a fermion-to-qubit mapping is needed. It stores the occupation of each spin-orbital in one qubit and rewrites every a†, a as Pauli strings, with extra Z operators threaded through to enforce the antisymmetric sign.

"One qubit per spin-orbital" refers to the common mapping without symmetry tapering; exploiting Z₂ symmetries (particle number, parity, spin, point group, …) can remove qubits. Bravyi–Kitaev, by encoding both occupation and parity information at once, compresses the parity strings that can reach O(N) in Jordan–Wigner down to about O(log N), at the price of a more intricate mapping structure.

Why the term count scales as O(N⁴)

In the naive construction the two-electron integrals hpqrs carry four orbital indices, so the number of non-zero two-body terms — and therefore the number of Pauli strings after mapping — grows as O(N⁴) in the worst case in the number of spin-orbitals N. This is the dominant cost driver of quantum chemistry: it sets how large the Hamiltonian object is and how many terms VQE must measure. In practice the term count is reduced by integral symmetries, threshold truncation, an active space, localized orbitals, and low-rank / double factorization. Shrinking N through a good orbital choice or an active space is the main lever against it.

From geometry to qubit operator

Read the snippet as the pipeline above, step by step. geometry is the molecule; create_molecule(...) calls a classical quantum-chemistry backend that computes the AO integrals from the geometry and basis and typically runs a mean-field step (e.g. RHF) to obtain the molecular orbitals and reference state; molecular_hamiltonian(...) assembles the second-quantized operator and applies the Jordan–Wigner mapping to emit the qubit operator; and get_qubit_count() reports the number of spin-orbitals that drives the O(N⁴) scaling.

import qalgora

# 1. define the molecule
geometry = [("H", (0., 0., 0.)), ("H", (0., 0., 0.735))]

# 2. run a mean-field calculation (RHF) and get integrals
molecule = qalgora.chemistry.create_molecule(geometry, basis="sto-3g")

# 3. build the second-quantized Hamiltonian, Jordan-Wigner mapped
hamiltonian = qalgora.chemistry.molecular_hamiltonian(molecule)
print("qubits:", hamiltonian.get_qubit_count())

Orbital choices

Because cost scales so steeply with N, the choice of orbitals (the mean-field reference) is not a detail — it decides both the accuracy of the integrals and how compact a Hamiltonian you can get away with.