⚛️ quantum physics

A Complete Calculus for Hamiltonian Quantum Programming

This paper introduces Hamilton, a fully abstract and decidable process calculus for quantum programming that models continuous Hamiltonian evolution through a parallel sum operator, with operational semantics based on the Lie-Trotter product formula that enables compiling programs to quantum circuits and verifying their equivalence.

Original author: Jacques Carette, Chris Heunen, Robin Kaarsgaard, Neil J. Ross, Amr Sabry

Published 2026-11-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original author: Jacques Carette, Chris Heunen, Robin Kaarsgaard, Neil J. Ross, Amr Sabry

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the author. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that are impossible for today's machines, from designing new medicines to modeling complex chemical reactions. To understand how they work, one must distinguish between two ways of describing their behavior. The most common view treats a quantum computer as a sequence of instructions, like a recipe where each step is a specific gate that flips or shifts the state of a particle. This approach is easy to manage for engineers, but it misses the deeper physical reality. In nature, particles do not jump from one state to another; they flow continuously, driven by forces that act simultaneously. Physicists describe these forces using a mathematical object called a Hamiltonian, which represents the total energy of a system and dictates how it evolves over time. When scientists want to simulate a molecule or a material, they often start with this continuous description of forces. The challenge has long been how to translate this smooth, simultaneous flow of energy into the discrete, step-by-step instructions that a quantum computer can actually execute, without losing the essential physics of the system.

A team of researchers has introduced a new language called Hamilton, designed to treat these continuous forces as the primary building blocks of quantum programming. Instead of forcing the programmer to think in terms of sequential gates, this language allows them to write programs as a sum of interactions acting at the same time. In this framework, a program is simply a collection of forces running in parallel, and the computer's job is to figure out how to break that parallel flow into a sequence of steps that a machine can follow. The researchers proved that their language is complete and precise: any program written in it corresponds to a specific, well-defined set of physical forces, and two programs are considered identical if they describe the exact same forces, regardless of how the instructions are ordered. This means that a compiler can rearrange the steps of a program to make it run faster or more accurately, knowing with absolute certainty that the underlying physics remains unchanged.

The core of this work relies on a mathematical trick known as the Lie-Trotter product formula, which serves as the bridge between the continuous world of forces and the discrete world of computer instructions. Imagine trying to walk along a curved path by taking only straight steps; if you take very small steps and alternate directions frequently, you can trace the curve with high precision. The researchers' language uses this same principle. When a program describes two forces acting together, the compiler breaks the total time into tiny slices. In each slice, it applies one force, then the other, then repeats the process. As the slices become smaller and the number of repetitions increases, the jagged, step-by-step path of the computer converges perfectly to the smooth curve of the original physical system. The language provides a rigorous set of rules to ensure that no matter how the compiler slices and dices the instructions, the final result always represents the same physical reality.

To test their ideas, the researchers built a working compiler that translates programs written in Hamilton into actual quantum circuits. They demonstrated its power by simulating the behavior of a hydrogen bond in a molecule called DMANH+, a system previously studied on a real quantum computer. The molecule involves a proton moving between two nitrogen atoms, a process governed by a complex set of forces. The researchers took the mathematical description of these forces, fed it into their language, and let the compiler generate the necessary instructions. They found that by refining the size of the time slices, the simulated results matched the expected physical behavior with remarkable accuracy. Specifically, when they used a high level of precision, the error in the calculated vibrational frequencies of the bond was less than 2.8 inverse centimeters, a margin of error smaller than the uncertainty found in the original physical experiment. This proved that their method could capture the subtle dynamics of a real-world chemical system without needing to compute the entire evolution of the system at once.

The significance of this work lies in its ability to separate the description of a problem from the method of solving it. In previous approaches, programmers often had to manually design the sequence of gates to approximate a physical system, a process that was prone to errors and difficult to optimize. With Hamilton, the programmer describes the forces, and the language guarantees that the resulting sequence of gates is a faithful approximation. The researchers showed that their system can handle complex interactions involving multiple particles and different types of forces, all while maintaining a strict mathematical guarantee that the program does what it is supposed to do. They also demonstrated that the compiler can automatically simplify programs by canceling out redundant steps or reordering instructions to reduce errors, all without changing the physical outcome. This level of automation and certainty is a significant step forward for the field, offering a reliable way to program quantum computers for the simulation of complex physical phenomena.

While the current implementation works best for small systems and relies on a specific type of approximation, the researchers are confident that the underlying theory is robust and scalable. They have formally verified the core logic of their language using computer-assisted proof tools, ensuring that the rules they established are mathematically sound. The next steps involve refining the compiler to produce even more efficient circuits and extending the language to handle more complex scenarios, such as systems that interact with their environment or involve measurements during the computation. For now, the work stands as a complete and verified framework for thinking about quantum programs as continuous flows of energy, providing a solid foundation for the future of quantum simulation.

=== SUMMARY ===

Technical Summary: A Complete Calculus for Hamiltonian Quantum Programming

Problem Statement

Quantum programs are predominantly expressed as sequences of gates (circuits), where sequential composition is the primitive operation. While this model is tractable for compilers and type theorists, it is ill-suited for the original motivation of quantum computing: simulating physical systems, solving optimization problems, and estimating eigenvalues. These tasks are naturally described by Hamiltonians, which model continuous evolution driven by simultaneous forces. In the circuit model, simultaneous interactions must be approximated via sequential interleaving (Trotterization), obscuring the additive nature of the underlying physics. Existing approaches to "patch" the circuit model (e.g., Trotterization or block encodings) lack a unified conceptual framework where simultaneous interactions are first-class citizens, rather than approximations of sequential ones.

Methodology

The authors introduce Hamilton, a process calculus designed to treat Hamiltonians as the primary abstraction. The methodology rests on three pillars:

Syntax and Semantics:
- Parallel Composition: The core operator is parallel composition ( $\parallel$ ), representing the sum of interactions acting simultaneously. Unlike circuit languages where order matters, the order of terms in a Hamilton process is immaterial to the underlying Hamiltonian.
- Halving: The calculus includes a "halving" operation ( $p/2^n$ ), which scales the duration of an interaction. This is essential for implementing the Lie-Trotter product formula, where a sum of Hamiltonians $e^{A+B}$ is recovered as the limit of sequential interleavings $(e^{A/N}e^{B/N})^N$ as $N \to \infty$ .
- Target Model: Hamilton programs compile to the calculus $\Pi_k$ , a complete calculus for sequential quantum programs that includes square roots of NOT and $2^k$ -th roots of unity. This allows for the exact representation of dyadic rational coefficients.
Operational Semantics:
- The operational semantics of a Hamilton program is defined by the Lie-Trotter product formula. Compiling a program involves choosing a precision level $n$ , halving the process $n$ times, and unrolling the resulting schedule into a sequence of $2^n$ Trotter steps, each realized as a $\Pi_k$ circuit.
- The semantics are defined in four layers: Hamiltonian semantics (sum of matrices), Unitary semantics (exponential of the Hamiltonian), Approximate Schedule Semantics (finite-level Trotter steps), and Limit Schedule Semantics (the infinite limit).
Equational Theory:
- The paper defines process equivalence ( $\approx$ $\approx$ ) based on schedule equivalence ( $\sim$ $\sim$ ). Two processes are equivalent if their schedules can be transformed into one another via:
  - Permutation (R1): Reordering actions (since order is irrelevant in the limit).
  - Substitution (R2): Replacing an action with a sequence of actions that are equivalent under every halving level (ensuring equality of the underlying Hamiltonians).
- This theory is proven to be fully abstract with respect to the Hamiltonian semantics.

Key Contributions

A Complete Calculus for Hamiltonians:
The paper establishes that the equational theory of Hamilton is complete and decidable. Two processes are provably equal if and only if they denote the same Hamiltonian. The expressible Hamiltonians are exactly those whose Pauli coefficients are dyadic rationals (numbers of the form $m/2^k$ ). Since dyadic rationals are dense in the reals, any real-valued Hamiltonian can be approximated arbitrarily closely.
Full Abstraction:
The authors prove that process equivalence coincides exactly with equality of the Hamiltonian semantics (Theorem 32). This means the calculus captures the physical reality of the system without "accidental" equalities or missing distinctions. The theory is fully abstract with respect to the Lie algebra of the unitary group.
Universality:
Theorem 15 and 16 demonstrate that Hamilton processes of type $2^n$ are in a semantic one-to-one correspondence with Hamiltonians on $n$ qubits having dyadic rational Pauli coefficients. This establishes the universality of the language for this class of Hamiltonians.
Implementation and Verification:
- A full implementation in Haskell (delegating linear algebra to Python libraries) compiles Hamilton programs to quantum circuits and decides their equivalence by computing Pauli representations (normal forms) symbolically, avoiding matrix construction.
- Core metatheory (syntax, types, and key semantic properties) has been formalized and "sanity-checked" in Agda, confirming the soundness of the paper's proofs.

Results

Compilation and Approximation: The implementation successfully compiles Hamilton programs to circuits. Experiments on a single-qubit $X+Z$ Hamiltonian demonstrate that the error of the compiled circuit decreases linearly with the refinement level (halving the error at each step), consistent with first-order Trotter convergence.
Optimization via Rewriting: The equational theory enables optimizations that are invisible to standard circuit optimizers.
- Reordering: The compiler can search through different orderings of non-commuting terms to find the schedule with the lowest Trotter error, knowing that all orderings denote the same Hamiltonian.
- Cancellation: The theory allows for the cancellation of terms that commute with the total Hamiltonian but are separated by non-commuting gates in a standard schedule. This reduces circuit depth and error (e.g., reducing CNOT counts from 8 to 4 in a specific example).
- Invariant Preservation: By grouping commuting actions into atomic blocks, the compiled circuits can preserve physical invariants (e.g., particle number) exactly at every Trotter step, whereas standard interleaving might violate them.
Case Study (Hydrogen Bond): The authors simulated the hydrogen bond of the DMANH+ molecule (a 2-qubit system with 9 Pauli terms).
- The compiled circuits recovered the vibrational frequencies of the bond with an error of 2.8 cm⁻¹ (at precision $k=12$ and refinement $n=4$ ).
- This error is below the 3.3 cm⁻¹ measurement uncertainty of the original physical experiment (Richeme et al. [2023]), demonstrating that term-by-term compilation via Hamilton does not introduce detectable algorithmic error compared to the experimental noise floor.
- The authors note that while their circuits are larger than the experiment's hand-optimized exact circuits (which used 3 CNOTs vs. Hamilton's 18+), the Hamilton approach scales to larger molecules where exact synthesis is infeasible.

Significance and Claims

The paper claims that Hamilton provides a "conceptual framework" for Hamiltonian quantum programming, distinct from the sequential circuit model. Its significance lies in:

First-Class Hamiltonians: It treats the sum of interactions as a primitive, recovering the sequential circuit only as an operational artifact of compilation.
Rigorous Equational Reasoning: It offers a complete, decidable, and fully abstract equational theory. This allows compilers to reason about program equivalence based on the underlying physics (Hamiltonians) rather than just the resulting unitary matrices, enabling optimizations (like reordering and cancellation) that are sound with respect to the physical system.
Bridging Theory and Practice: The implementation demonstrates that this theoretical framework can be realized in a working compiler that produces circuits competitive with state-of-the-art experimental results for small systems, while offering a path to scale to larger, more complex systems where exact synthesis is impossible.

The authors modestly acknowledge that the current implementation is limited to small Hamiltonians and that the generated circuits require further optimization (e.g., resynthesis) to be practical. They identify higher-order Trotter splittings and connections to fermion-to-qubit mappings as necessary next steps for broader adoption.