Propaq: A Python package for Heisenberg Propagation

AI summary

Overview

Research area: Quantum information science — classical simulation of quantum circuits via Heisenberg-picture (Pauli/Majorana) propagation, and scientific software engineering.

Technical level: Intermediate. The paper assumes familiarity with the Heisenberg vs. Schrödinger picture, Pauli operators, and basic circuit simulation, but its API section is usable by practitioners with modest background.

Scope: Propaq is a Rust-backed Python package for Heisenberg propagation that supports arbitrary operator bases, hybrid Schrödinger–Heisenberg simulation, truncation and noise policies, and detailed logging, and it benchmarks competitively against existing propagation packages.

What This Paper Is About

Classically simulating quantum circuits is a workhorse for benchmarking algorithms, testing error mitigation, and probing the boundaries of quantum advantage. Heisenberg (back-)propagation — evolving the observable backwards through the circuit instead of evolving the state forwards — has become popular recently, partly because it underlies challenges to quantum-advantage claims. The paper introduces Propaq, a Python package that implements this technique with a focus on performance and on features that existing packages do not offer.

Key Contributions

1. A performant implementation. Propaq is written in Rust with Python front-ends and is reported in the abstract to match or outperform similar state-of-the-art packages for Heisenberg propagation. It adopts several low-level design elements for term storage and threading from the monoprop package.
2. Heisenberg propagation in any basis. The Pauli and Majorana bases are built in; users can define other bases by subclassing abstract classes and implementing six required methods (basis-element products, branching behavior, operator weight, diagonal expectation with a basis state, gate generators, and hashing/equality/byte representations). The authors state that to their knowledge Propaq is the only library supporting backpropagation in any basis.
3. Hybrid Schrödinger–Heisenberg simulation. A circuit is partitioned at an index $$k$$; operations before the partition act on the state (currently via matrix product states) and operations after act on the observable, with the expectation value computed as a series of overlaps. To the authors' knowledge, Propaq is the only Heisenberg simulation package supporting this.
4. Research tooling: truncation, logging, noise, and extrapolation. Pluggable truncation policies, per-gate logging of term counts, discarded terms and discarded $$L_1$$ norm, built-in depolarizing noise models, custom noise channels, zero-cutoff extrapolation, zero-noise extrapolation, and saving/streaming-loading of back-propagated operators for checkpointing and distributed evaluation.

Main Findings

• Competitive wall-clock performance: On a $$6 \times 6$$ Trotterized transverse-field Ising model ($$J=1.0$$, $$h=0.5$$, $$\Delta t=0.1$$) and a $$3 \times 3$$ Hubbard model ($$t=1.0$$, $$U=4.0$$, $$\Delta t=0.1$$), Propaq's runtime for a single $$Z$$ observable is similar to PauliPropagation.jl and monoprop in the Pauli basis, and similar to monoprop in the Majorana basis. All runs used a coefficient cutoff of $$10^{-6}$$ and 64 AMD EPYC 7H12 cores, except single-threaded pauli-prop. The paper notes that all packages maintained a similar number of terms in this benchmark and that multi-threaded packages consequently had similar peak memory usage.
• Arbitrary bases work in practice: Using a Weyl-Heisenberg (qudit Pauli) subclass on a seven-site, three-state Potts spin chain quench ($$h_2 = 0.1$$) with weight cutoff $$w=4$$, computed magnetizations agree with exact diagonalization up to $$t \leq 25$$ and then accumulate error from truncation.
• Logging exposes accuracy bounds: In the logged example, nearly $$10^{8}$$ terms are discarded due to truncation, yet the discarded coefficient $$L_1$$ norm stays between $$10^{0}$$ and $$10^{1}$$, which the paper presents as a bound on observable accuracy. (The body text describes this run as a twenty-atom hydrogen chain with Pauli propagation, while the figure caption describes a two-layer unitary cluster Jastrow ansatz with Majorana propagation; both use a cutoff of $$10^{-6}$$.)
• Zero-cutoff extrapolation improves accuracy: For a five-qubit periodic TFIM circuit evolved for 4 Trotter steps, a linear fit over cutoff evaluations gives a ZCE value of 0.4117 for $$\langle Z^{\otimes 5}\rangle$$, closer to the untruncated value of 0.4124 than the truncated evaluations.
• Symbolic propagation pays off for variational loops: For a depth-two QAOA max-cut ansatz on a 12-vertex, 3-regular graph with 1000 iterations, direct numerical propagation takes 12.2 s; symbolic simulation takes 1.34 s once, after which all 1000 evaluations take 1.18 s total. The paper cautions that surrogate propagation is significantly more expensive than numerical propagation and should be used when many evaluations are required.
• Clifford deferral reduces runtime: Storing a sequence of Clifford gates' adjoint action in a stabilizer tableau and pushing non-Clifford gates through it produces up to around 10x runtime reduction on a 64-qubit, 80-layer Clifford+$$T$$ circuit where each layer has a random single-qubit Clifford on each qubit, a perfect-matching CNOT layer, and a $$T$$ gate with probability $$p$$.
• Noise damps coefficients: In the Pauli basis, single-qubit depolarizing noise multiplies a non-identity Pauli by $$(1 - 4p/3)$$, so a Pauli string picks up a damping factor $$e^{-\gamma w[P]}$$ with $$e^{-\gamma} := (1-4p/3)$$. For Majoranas the modulation uses the Pauli weight $$w[\mathcal{P}(M)]$$ rather than the Majorana weight, so nonlocal Majoranas damp differently. UniformNoiseModel applies single-qubit depolarizing noise to all qubits after every layer.

Methodology in Plain English

Instead of tracking how the quantum state changes as a circuit is applied, Propaq tracks how the measured observable changes when run backwards through the circuit. The observable is written as a sum of simple operator terms; each gate either leaves a term alone or splits it into two terms with cosine and sine coefficients. Because the number of terms grows exponentially in general, the package lets users throw away small or heavy terms according to a stack of configurable rules, and it records exactly how much was thrown away so users can judge accuracy.

The heavy numerical work is done in Rust, with Python wrappers that ingest Qiskit, Cirq, OpenFermion, and ffsim objects. The authors benchmark against pauli-prop, pyrauli, PauliPropagation.jl, MajoranaPropagation.jl, and monoprop on two Trotterized lattice models, then demonstrate each feature with a separate example: a qutrit Potts quench for arbitrary bases, a five-qubit TFIM for extrapolation, a QAOA instance for symbolic propagation, and random Clifford+$$T$$ circuits for Clifford deferral. A hybrid mode splits the circuit in two, evolving one part forward (currently with matrix product states) and the other backward, then contracting the two.

Why This Matters

Impact on research: Faster and more flexible propagation lets researchers push classical simulation further when testing quantum-advantage claims, studying noisy-circuit simulability, and validating error mitigation. The arbitrary-basis support extends these techniques beyond qubits — the demonstrated qutrit Potts example would not be possible with other packages, per the authors — and the logging tools make truncation error quantitative rather than guesswork. Hybrid Schrödinger–Heisenberg simulation offers a knob for trading space against time, including the possibility of forward evolution on actual quantum hardware.

Real-world applications:

• Benchmarking quantum algorithms and error-mitigation or error-correction protocols before running on hardware.
• Accelerating variational algorithm workflows (VQE, QAOA) by building a surrogate model once and re-evaluating it cheaply at new parameters.
• Modeling realistic noisy devices with depolarizing and custom noise channels to predict expectation values.
• Estimating simulation accuracy in advance via zero-cutoff and zero-noise extrapolation of truncated results.
• Distributing large expectation-value computations across devices via compressed on-disk operators, streaming loads, and checkpoint/resume.

Industry relevance: The package integrates directly with Qiskit (a hard dependency) and optionally with Cirq, FFSIM, OpenFermion, and Quimb; it installs from PyPI on Linux, Windows, and macOS and can be rebuilt from source for CPU-specific speedups. That makes it drop-in usable inside existing quantum software stacks and cloud/hardware workflows.

Future Directions

• Systematizing truncation choices. The paper states explicitly that it is not well understood how to pick the best truncation strategy for a given problem or predict the resulting observable accuracy; Propaq's logging and extrapolation tools are positioned as groundwork for answering this.
• Broadening hybrid simulation. Only matrix product states are currently implemented for the forward (Schrödinger) part; the authors point to other forward simulators such as Stim for Clifford simulation as natural extensions, and note compatibility with forward evolution on a quantum computer.
• More bases and more qudits. The Weyl-Heisenberg qutrit example invites further user-defined bases and higher-dimensional systems, but performance and accuracy of custom bases beyond the demonstrated case are not characterized in the provided content.
• Scaling studies and memory profiling. The paper defers additional performance and memory benchmarks (including the referenced Fig. 10) to a later section; broader benchmarks across problem classes would clarify when each package and each Propaq mode wins.

Note: the supplied paper content is truncated partway through Section IV.3.2, so the backend design details of Section V and the additional benchmarks of Section VI are referenced but not reported here.

Target Audience

Quantum information researchers and graduate students who need fast classical simulation of circuits with observables, especially those studying noisy-circuit simulability, quantum advantage, or variational algorithms. It is equally aimed at quantum software developers who want a Qiskit/Cirq-compatible simulation backend, and at method developers interested in extending propagation to new operator bases or hybrid Schrödinger–Heisenberg schemes. Readers wanting to use the package need only basic Python and circuit familiarity; readers wanting to extend it need comfort with operator algebras and commutators.

Authors’ abstract

We introduce Propaq, a performant and flexible Python package implementing Heisenberg propagation techniques for classically simulating quantum circuits. Propaq is compatible with major quantum software packages like Qiskit and Cirq, and matches or outperforms similar state-of-the-art packages for Heisenberg propagation. Beyond this, Propaq has multiple distinguishing features for simulation and research. These include Heisenberg propagation in any basis, hybrid Schrödinger-Heisenberg simulation, custom truncation and noisy simulation methods, and detailed logging information for analyzing simulation accuracy, runtime, and memory usage. We describe these features, how to use Propaq for research, and its backend implementation.