Hamiltonians and Encoding for Quantum Circuits

qc/algorithms qc/math

A Hamiltonian $H$ is the energy operator of a physical system: its eigenvalues are the system’s allowed energies, its eigenvectors are the corresponding physical states, and it governs time evolution via $i\partial |\psi ⟩/\partial t=H|\psi ⟩$ (setting $\hslash =1$). Key insight: $H$ itself is generally not unitary, so it isn’t a valid quantum gate — the operator you actually implement on a circuit is $U(H,t)=e^{-iHt}$, the unitary time-evolution operator generated by $H$.

Why Paulis are the universal language

Two facts make circuit-level Hamiltonian work tractable:

1. Any $2^n\times 2^n$ Hermitian matrix can be written as a real-weighted linear combination of $n$-qubit Pauli strings — this is the same fact behind Pauli Operators’ role as the “universal alphabet” for observables, extended via tensor products to $n$ qubits.
2. A Pauli rotation $R_P(2\theta )=e^{i\theta P}=I\cos \theta +iP\sin \theta$ is unitary for any Pauli string $P$ — so each term in a Pauli-decomposed Hamiltonian is directly implementable as a rotation gate.

Three ways to hand $H$ to a circuit

• LCP (linear combination of Paulis) — $H={\sum }_j{h}_j{P}_j$ with real coefficients $h_j$. Natural for spin models, and the format near-term algorithms in this section mostly use.
• LCU (linear combination of unitaries) — $H={\sum }_j{h}_j{U}_j$ with complex coefficients, used by block-encoding methods for fault-tolerant-era algorithms.
• Sparse matrix oracles — $O_L$ (locations) and $O_V$ (values), an oracle-access model rather than an explicit decomposition.

Mapping physical systems onto qubits

Spin models map directly — one physical spin becomes one qubit, and the Hamiltonian is naturally in LCP form. Example, the transverse-field Ising model (the same Hamiltonian family as 1D Ising Chain and the Mirror Trick):

$H=-J{\sum }_{⟨i,j⟩}{Z}_i{Z}_j+g{\sum }_i{X}_i$

Fermions are harder — creation/annihilation operators anticommute, which plain qubit operators don’t do by default. Two standard mappings:

• Jordan-Wigner: $b_j^{†}\mapsto \frac{1}{2}(X_j-i{Y}_j)Z_{j-1}\cdots Z_0$ — simple, but a single fermionic operator touches $O(n)$ qubits (the trailing $Z$ string).
• Bravyi-Kitaev: touches only $O(\log n)$ qubits, at the cost of a less intuitive encoding — still delocalized, just less so.

This fermion-to-qubit mapping step is exactly what the SQD/LUCJ chemistry algorithms later in this section assume has already happened.

Worked Jordan-Wigner example (from an H₂ Hamiltonian, see Quantum Chemistry — QPE on H2 (Worked Example)): a number operator $n_0=b_0^{†}{b}_0$ maps to $n_0=(I-Z_0)/2$ — a single-qubit $Z$ term. A density-density (Coulomb repulsion) term $n_0{n}_1$ maps to a $ZZ$-type two-qubit term, since it’s just a product of two number operators. Hopping terms ($b_p^{†}{b}_q+b_q^{†}{b}_p$) map to $XY$-type terms carrying the $Z$-string between $p$ and $q$. This is how a molecular Hamiltonian with a handful of orbitals turns into the kind of 15-term Pauli sum that Quantum Chemistry — QPE on H2 (Worked Example) then feeds into a QPE circuit.

Related

• Pauli Operators
• SparsePauliOp
• Hamiltonian Simulation — Why It’s Hard
• Trotterization — what you actually do with this decomposition on a circuit
• Quantum Chemistry — QPE on H2 (Worked Example) — a full worked example of this Jordan-Wigner mapping applied to a real molecule
• The Full Pipeline of a Quantum Solver — this note covers the pipeline’s “Encoding” stage in depth

Self-Check

• Why is $e^{-iHt}$ the thing you implement on a circuit, not $H$ itself?
• Could you explain why any Hermitian matrix being a sum of Pauli strings matters practically?
• Why do fermionic systems need a mapping like Jordan-Wigner or Bravyi-Kitaev, but spin systems don’t?