PauliEngine: High-Performant Symbolic Arithmetic for Quantum Operations

TL;DR

PauliEngine addresses the need for fast classical manipulation of Pauli strings in quantum software by introducing a compact C++ backend that uses binary symplectic representation and bitwise operations for arithmetic, phase tracking, and commutator evaluation. It supports both numeric and symbolic coefficients through integration with a symbolic engine and exposes a Python interface for easy integration into quantum workflows. The key innovations include XOR-based multiplication with efficient phase reconstruction via counts of local phase contributions, fast O($N$) commutator evaluation, and operator folding to accelerate expectation-value computations in parametrized circuits. Benchmark results show orders-of-magnitude speedups over established tools like PennyLane and OpenFermion, with favorable scaling for large Hamiltonians or long Pauli strings, confirming PauliEngine as a scalable backend for Pauli-based quantum-simulation and analysis. The work also demonstrates practical applications to dynamical Lie algebras and VQA-related tasks, indicating strong potential for integration into SDKs supporting parametrized and differentiable quantum workflows.

Abstract

Quantum computation is inherently hybrid, and fast classical manipulation of qubit operators is necessary to ensure scalability in quantum software. We introduce PauliEngine, a high-performance C++ framework that provides efficient primitives for Pauli string multiplication, commutators, symbolic phase tracking, and structural transformations. Built on a binary symplectic representation and optimized bit-wise operations, PauliEngine supports both numerical and symbolic coefficients and is accessible through a Python interface. Runtime benchmarks demonstrate substantial speedups over state-of-the-art implementations. PauliEngine provides a scalable backend for operator-based quantum software tools and simulations.

Figures (5)

• Figure 1: Overview over datatypes and operations.
• Figure 2: Coefficient Determination Tables to determine the phase factors arising in the multiplication of two single-qubit Pauli operators in binary symplectic form. Each row corresponds to one pair of local Paulis with bit representation $(x,y)$ and $(x',y')$. The left table marks the cases that contribute a factor of $+i$, while the right table marks the cases contributing $-i$.
• Figure 3: Runtime benchmark of DLA computations using PauliEngine arithmetic versus PennyLane. Left: Mean runtime over 1000 runs for computing the Lie closure of DLAs isomorphic to $\mathfrak{so}(2N)$. Right: Mean runtime over 100 runs for computing the corresponding structure constants. Both axes are logarithmic. For each $N$, the dashed vertical markers indicate the speedup factor (PauliEngine relative to PennyLane). All benchmarks were performed on an Apple M4 processor with 24 GB RAM.
• Figure 4: Runtime comparison for Hamiltonian multiplication using PauliEngine, PauliArray , and OpenFermion. Left: Runtime vs. Hamiltonian size at fixed Pauli string length (500). Right: Runtime vs. Pauli string length at fixed Hamiltonian size (500). PauliEngine and PauliArray clearly outperform OpenFermion across all tested regimes; OpenFermion becomes a bottleneck already for moderate sizes. Performed on Intel i9-11900KF with 32GB RAM.
• Figure 5: Direct comparison between PauliEngine and PauliArray . Left: Mean runtime over 10 runs vs. Hamiltonian size at fixed Pauli string length (500). Right: Mean Runtime over 100 runs vs. Pauli string length at fixed Hamiltonian size (500). PauliArray is faster for small instances, but its runtime grows sharply once memory consumption becomes substantial, whereas PauliEngine maintains stable, with quadratic scaling in Hamiltonian size and near-linear scaling in Pauli string length. Performed on Intel i9-11900KF with 32GB RAM.