Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2601.02233

PauliEngine: High-Performant Symbolic Arithmetic for Quantum Operations

Leon Müller, Adelina Bärligea, Alexander Knapp, Jakob S. Kottmann

quant-phcs.ETcs.SEphysics.comp-phSubmitted Jan 5, 2026• Announced Jan 6, 2026• 4 citations
arXivHTMLPDF

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.

DOI
10.18420/se2026-ws_20

Related papers

A High-Performance Pauli-Algebra Framework for Large-Scale Quantum Simulations

Xiaopeng Li, Zhijie Sun, Yi Fan +3 more

Efficient manipulation of Pauli-algebraic objects is a key bottleneck in the classical emulation and benchmarking of quantum algorithms for chemistry and many-body physics. This bottleneck appears in Hamiltonian construction, variational ansatz preparation, expectation-value and gradient evaluation, and real-time propagation, all of which require repeated Pauli-algebra operations. Here, we present a high-performance Pauli-algebra framework tailored to quantum many-body and quantum-chemical simulations. The framework combines compact binary symplectic encoding, canonical coefficient reduction, and grouped sparse operator representations that exploit shared bit-flip patterns among Pauli strings. The resulting Julia/C\texttt{++} implementation accelerates Pauli multiplication, Hamiltonian construction, and operator--state multiplication in sparse and symmetry-adapted many-electron spaces. Benchmarks demonstrate efficient Hamiltonian construction, large-active-space VQE and ADAPT-VQE calculations, and real-time variational dynamics on modern multicore CPU and GPU architectures. These results show that structure-aware Pauli-algebra engines provide a scalable classical backend for developing and benchmarking quantum algorithms in quantum chemistry and many-body simulation.

quant-pharXiv:2606.28952•Jun 30, 2026•1 citation

PauLIB: HPC Strategies for Pauli-Arithmetic-Based Quantum Computing Workloads and Simulations

Florian Krötz

As quantum devices become accelerators within classical HPC deployments, the efficiency of the classical partition becomes critical. Workloads such as Hamiltonian manipulation, observable backpropagation, and Pauli-based compilation reduce to bulk arithmetic on Pauli strings and sums. We present HPC strategies for this arithmetic, demonstrated in PauLIB, a header-only C++20 library: a bit-packed binary symplectic representation reducing Pauli multiplication to a bitwise XOR and population count; a sorted, struct-of-arrays layout replacing hash maps and exposing contiguous word arrays to SIMD units and GPU warps; and deterministic OpenMP parallelism with race-free output partitioning. These strategies deliver orders-of-magnitude higher throughput and smaller memory footprint than Qiskit and PauliEngine, plus a speedup from a CUDA outer-product kernel on an H100. Two case studies, g-sim and truncated Pauli propagation, inherit these gains and scale unchanged from a desktop Arm CPU to a 72-core HPC Arm server. PauLIB is open source with C++ and Python interfaces.

quant-pharXiv:2605.25974•May 26, 2026•3 citations

Speed-oriented quantum circuit backend

Sören Wilkening

We present a new software package for efficient quantum circuit generation, designed to achieve optimal runtime performance. Despite being in an early stage of development, our implementation demonstrates significant advantages over existing tools. Using the quantum Fourier transform (QFT) as a benchmark, we show that our backend can generate circuits for systems with up to 2000 qubits faster than widely used frameworks such as Qiskit and Q#. This improvement is particularly relevant for applications where classical preprocessing time, including circuit generation, must be minimized to not diminish any potential quantum advantage - for example, in combinatorial optimization tasks. Additionally, our software provides high-level primitives for bit- and integer-level manipulations, offering a simplified interface for integration with high-level quantum programming languages.

quant-pharXiv:2604.21656•Apr 24, 2026•0 citations

Efficiently manipulating Pauli strings with PauliArray

Maxime Dion, Tania Belabbas, Nolan Bastien

Pauli matrices and Pauli strings are widely used in quantum computing. These mathematical objects are useful to describe or manipulate the quantum state of qubits. They offer a convenient basis to express operators and observables used in different problem instances such as molecular simulation and combinatorial optimization. Therefore, it is important to have a well-rounded, versatile and efficient tool to handle a large number of Pauli strings and operators expressed in this basis. This is the objective behind the development of the PauliArray library presented in this work. This library introduces data structures to represent arrays of Pauli strings and operators as well as various methods to modify and combine them. Built using NumPy, PauliArray offers fast operations and the ability to use broadcasting to easily carry out otherwise cumbersome manipulations. Applications to the fermion-to-qubit mapping, to the estimation of expectation values and to the computation of commutators are considered to illustrate how PauliArray can simplify some relevant tasks and accomplish them faster than current libraries.

arXiv:2405.19287•May 29, 2024•7 citations

LogosQ: A High-Performance and Type-Safe Quantum Computing Library in Rust

Shiwen An, Jiayi Wang, Konstantinos Slavakis

Developing robust and high performance quantum software is challenging due to the dynamic nature of existing Python-based frameworks, which often suffer from runtime errors and scalability bottlenecks. In this work, we present LogosQ, a high performance backend agnostic quantum computing library implemented in Rust that enforces correctness through compile time type safety. Unlike existing tools, LogosQ leverages Rust static analysis to eliminate entire classes of runtime errors, particularly in parameter-shift rule gradient computations for variational algorithms. We introduce novel optimization techniques, including direct state-vector manipulation, adaptive parallel processing, and an FFT optimized Quantum Fourier Transform, which collectively deliver speedups of up to 900 times for state preparation (QFT) and 2 to 5 times for variational workloads over Python frameworks (PennyLane, Qiskit), 6 to 22 times over Julia implementations (Yao), and competitive performance with Q sharp. Beyond performance, we validate numerical stability through variational quantum eigensolver (VQE) experiments on molecular hydrogen and XYZ Heisenberg models, achieving chemical accuracy even in edge cases where other libraries fail. By combining the safety of systems programming with advanced circuit optimization, LogosQ establishes a new standard for reliable and efficient quantum simulation.

quant-pharXiv:2512.23183•Dec 30, 2025•0 citations

Benchmarking Matrix Multiplications For Variable Qubit Size And Depth

Md Imam Mazhar, Abhishek Sunil Tiwari, Nasir Ali +3 more

To emulate a quantum computation on a classical computer i.e. the evolution of the unitary operations on the wave function of the particle in quantum mechanics, we have to perform unitary matrix and normalized vector multiplications in the high-level programming languages of Python, C++, Java, etc. Quantum Libraries already available perform the matrix-vector multiplication in the backend using the numpy libraries of Python like Qiskit or use a C++ wrapper to further optimize the runtime it as in Qiskit-Aer Simulators. Since a fully functioning fault-tolerant computer is decades away, it is in our best interest to design new quantum algorithms and develop accelerator test beds for Quantum Emulations. All the quantum computer operations can be emulated on a classical computer, with the only downside being that the matrix multiplications scale up as O (N3) in runtime. In contrast, the quantum computer scales it up as O (N2log2N), where N = 2n, where N is the matrix dimension, where n is the number of qubits, so the runtime for quantum emulations on the classical computer increases exponentially with increase in number of qubits and increases linearly with increase in number of depths, complexity wise. Though it is not possible to change the exponential index, it is possible to reduce the runtime for quantum emulations on classical computers by use of GPU and Alveo Accelerator Cards, and also code optimization on the software side like using a C++ wrapper. In this paper, we will benchmark the matrix-matrix multiplications on HPC Accelerator Cards varying the qubit size and the depth of the quantum circuit and provide a universal mathematical equation for the runtime on the GPU and Alveo Vector Cards for two variables of qubit size and quantum circuit depth. So a theoretical limit on qubit size and qubit depth exactly can be established for quantum emulations on present classical supercomputers.

ITU Kaleidoscope Academic Conference (ITU K)•Oct 21, 2024•2 citations
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.
Efficient manipulation of Pauli-algebraic objects is a key bottleneck in the classical emulation and benchmarking of quantum algorithms for chemistry and many-body physics. This bottleneck appears in Hamiltonian construction, variational ansatz preparation, expectation-value and gradient evaluation, and real-time propagation, all of which require repeated Pauli-algebra operations. Here, we present a high-performance Pauli-algebra framework tailored to quantum many-body and quantum-chemical simulations. The framework combines compact binary symplectic encoding, canonical coefficient reduction, and grouped sparse operator representations that exploit shared bit-flip patterns among Pauli strings. The resulting Julia/C\texttt{++} implementation accelerates Pauli multiplication, Hamiltonian construction, and operator--state multiplication in sparse and symmetry-adapted many-electron spaces. Benchmarks demonstrate efficient Hamiltonian construction, large-active-space VQE and ADAPT-VQE calculations, and real-time variational dynamics on modern multicore CPU and GPU architectures. These results show that structure-aware Pauli-algebra engines provide a scalable classical backend for developing and benchmarking quantum algorithms in quantum chemistry and many-body simulation.
As quantum devices become accelerators within classical HPC deployments, the efficiency of the classical partition becomes critical. Workloads such as Hamiltonian manipulation, observable backpropagation, and Pauli-based compilation reduce to bulk arithmetic on Pauli strings and sums. We present HPC strategies for this arithmetic, demonstrated in PauLIB, a header-only C++20 library: a bit-packed binary symplectic representation reducing Pauli multiplication to a bitwise XOR and population count; a sorted, struct-of-arrays layout replacing hash maps and exposing contiguous word arrays to SIMD units and GPU warps; and deterministic OpenMP parallelism with race-free output partitioning. These strategies deliver orders-of-magnitude higher throughput and smaller memory footprint than Qiskit and PauliEngine, plus a speedup from a CUDA outer-product kernel on an H100. Two case studies, g-sim and truncated Pauli propagation, inherit these gains and scale unchanged from a desktop Arm CPU to a 72-core HPC Arm server. PauLIB is open source with C++ and Python interfaces.
We present a new software package for efficient quantum circuit generation, designed to achieve optimal runtime performance. Despite being in an early stage of development, our implementation demonstrates significant advantages over existing tools. Using the quantum Fourier transform (QFT) as a benchmark, we show that our backend can generate circuits for systems with up to 2000 qubits faster than widely used frameworks such as Qiskit and Q#. This improvement is particularly relevant for applications where classical preprocessing time, including circuit generation, must be minimized to not diminish any potential quantum advantage - for example, in combinatorial optimization tasks. Additionally, our software provides high-level primitives for bit- and integer-level manipulations, offering a simplified interface for integration with high-level quantum programming languages.
Pauli matrices and Pauli strings are widely used in quantum computing. These mathematical objects are useful to describe or manipulate the quantum state of qubits. They offer a convenient basis to express operators and observables used in different problem instances such as molecular simulation and combinatorial optimization. Therefore, it is important to have a well-rounded, versatile and efficient tool to handle a large number of Pauli strings and operators expressed in this basis. This is the objective behind the development of the PauliArray library presented in this work. This library introduces data structures to represent arrays of Pauli strings and operators as well as various methods to modify and combine them. Built using NumPy, PauliArray offers fast operations and the ability to use broadcasting to easily carry out otherwise cumbersome manipulations. Applications to the fermion-to-qubit mapping, to the estimation of expectation values and to the computation of commutators are considered to illustrate how PauliArray can simplify some relevant tasks and accomplish them faster than current libraries.
Developing robust and high performance quantum software is challenging due to the dynamic nature of existing Python-based frameworks, which often suffer from runtime errors and scalability bottlenecks. In this work, we present LogosQ, a high performance backend agnostic quantum computing library implemented in Rust that enforces correctness through compile time type safety. Unlike existing tools, LogosQ leverages Rust static analysis to eliminate entire classes of runtime errors, particularly in parameter-shift rule gradient computations for variational algorithms. We introduce novel optimization techniques, including direct state-vector manipulation, adaptive parallel processing, and an FFT optimized Quantum Fourier Transform, which collectively deliver speedups of up to 900 times for state preparation (QFT) and 2 to 5 times for variational workloads over Python frameworks (PennyLane, Qiskit), 6 to 22 times over Julia implementations (Yao), and competitive performance with Q sharp. Beyond performance, we validate numerical stability through variational quantum eigensolver (VQE) experiments on molecular hydrogen and XYZ Heisenberg models, achieving chemical accuracy even in edge cases where other libraries fail. By combining the safety of systems programming with advanced circuit optimization, LogosQ establishes a new standard for reliable and efficient quantum simulation.
To emulate a quantum computation on a classical computer i.e. the evolution of the unitary operations on the wave function of the particle in quantum mechanics, we have to perform unitary matrix and normalized vector multiplications in the high-level programming languages of Python, C++, Java, etc. Quantum Libraries already available perform the matrix-vector multiplication in the backend using the numpy libraries of Python like Qiskit or use a C++ wrapper to further optimize the runtime it as in Qiskit-Aer Simulators. Since a fully functioning fault-tolerant computer is decades away, it is in our best interest to design new quantum algorithms and develop accelerator test beds for Quantum Emulations. All the quantum computer operations can be emulated on a classical computer, with the only downside being that the matrix multiplications scale up as O (N3) in runtime. In contrast, the quantum computer scales it up as O (N2log2N), where N = 2n, where N is the matrix dimension, where n is the number of qubits, so the runtime for quantum emulations on the classical computer increases exponentially with increase in number of qubits and increases linearly with increase in number of depths, complexity wise. Though it is not possible to change the exponential index, it is possible to reduce the runtime for quantum emulations on classical computers by use of GPU and Alveo Accelerator Cards, and also code optimization on the software side like using a C++ wrapper. In this paper, we will benchmark the matrix-matrix multiplications on HPC Accelerator Cards varying the qubit size and the depth of the quantum circuit and provide a universal mathematical equation for the runtime on the GPU and Alveo Vector Cards for two variables of qubit size and quantum circuit depth. So a theoretical limit on qubit size and qubit depth exactly can be established for quantum emulations on present classical supercomputers.