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:2605.25974

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

Florian Krötz

quant-phcs.ETSubmitted May 25, 2026• Announced May 26, 2026• 0 citations• Revised Oct 26, 2026 (v2)
v1 · May 25, 2026v2 · Oct 26, 2026
arXivHTMLPDF

Abstract

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.

Comments
9 pages. Accepted at SC26 Workshops (Chicago, 2026)

Related papers

PauliEngine: High-Performant Symbolic Arithmetic for Quantum Operations

Leon Müller, Adelina Bärligea, Alexander Knapp +1 more

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.

quant-pharXiv:2601.02233•Jan 6, 2026•0 citations

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•0 citations

Quantum computing simulator on a heterogenous HPC system

Jun Doi, Hitomi Takahashi, Rudy Raymond +2 more

Quantum computing simulation on a classical computer is difficult due to the exponential runtime and memory overhead. Previous work addresses the difficulty by utilizing multiple Graphical Processing Units (GPUs) and multi-node computers. GPUs are efficient for handling runtime issues but have limited total accessible memory space. Meanwhile, the memory of a multi-node computer can be scaled to the petabytes order, but its bandwidth for access from host computers (CPUs) is narrow. To simultaneously accelerate simulation and enlarge the total memory space, we propose a heterogeneous parallelization approach by combining GPUs and CPUs. Our simulator allocates memory to the GPUs first, and then to the CPUs. It thus accelerates simulation by using the full capabilities of the GPUs if memory for the simulation fits in the GPUs on a cluster. Allocating memory to the CPUs reduces benefits of the GPUs but enlarges the capacity of qubits in the simulation. In such case, it can exploit the memory of the GPUs to add one more qubit in the simulation if the size of memory in a node is the power of two (such as 512GB). We show empirical performance evaluations of our simulator in a distributed environment of POWER9.

ACM International Conference on Computing Frontiers (CF)•Apr 30, 2019•44 citations

PACOX: A FPGA-based Pauli Composer Accelerator for Pauli String Computation

Tran Xuan Hieu Le, Tuan Hai Vu, Vu Trung Duong Le +2 more

Pauli strings are a fundamental computational primitive in hybrid quantum-classical algorithms. However, classical computation of Pauli strings suffers from exponential complexity and quickly becomes a performance bottleneck as the number of qubits increases. To address this challenge, this paper proposes the Pauli Composer Accelerator (PACOX), the first dedicated FPGA-based accelerator for Pauli string computation. PACOX employs a compact binary encoding with XOR-based index permutation and phase accumulation. Based on this formulation, we design a parallel and pipelined processing element (PE) cluster architecture that efficiently exploits data-level parallelism on FPGA. Experimental results on a Xilinx ZCU102 FPGA show that PACOX operates at 250 MHz with a dynamic power consumption of 0.33 W, using 8,052 LUTs, 10,934 FFs, and 324 BRAMs. For Pauli strings of up to 19 qubits, PACOX consistently outperforms state-of-the-art CPU-based methods in terms of execution speed, while also requiring significantly less memory and achieving a much lower power-delay product. These results demonstrate that PACOX delivers high computational speed with superior energy efficiency for Pauli-based workloads in hybrid quantum-classical systems.

quant-pharXiv:2601.04827•Jan 9, 2026•0 citations

A Full Stack Framework for High Performance Quantum-Classical Computing

Xin Zhan, Katherine Grace Johnson, Aniello Esposito +5 more

To address the growing needs for scalable High Performance Computing (HPC) and Quantum Computing (QC) integration, we present our HPC-QC full stack framework and its hybrid workload development capability with modular hardware/device-agnostic software integration approach. The latest development in extensible interfaces for quantum programming, dispatching, and compilation within existing mature HPC programming environment are demonstrated. Our HPC-QC full stack enables high-level, portable invocation of quantum kernels from commercial quantum SDKs within HPC meta-program in compiled languages (C/C++ and Fortran) as well as Python through a quantum programming interface library extension. An adaptive circuit knitting hypervisor is being developed to partition large quantum circuits into sub-circuits that fit on smaller noisy quantum devices and classical simulators. At the lower-level, we leverage Cray LLVM-based compilation framework to transform and consume LLVM IR and Quantum IR (QIR) from commercial quantum software frontends in a retargetable fashion to different hardware architectures. Several hybrid HPC-QC multi-node multi-CPU and GPU workloads (including solving linear system of equations, quantum optimization, and simulating quantum phase transitions) have been demonstrated on HPE EX supercomputers to illustrate functionality and execution viability for all three components developed so far. This work provides the framework for a unified quantum-classical programming environment built upon classical HPC software stack (compilers, libraries, parallel runtime and process scheduling).

arXiv:2510.20128•Oct 23, 2025•0 citations

phase2: full-state vector simulation of quantum time evolution at scale

Marek Miller, Jakob Günther, Freek Witteveen +5 more

Abstract Large-scale classical simulation of quantum computers is crucial for benchmarking quantum algorithms, establishing boundaries of quantum advantage and exploring heuristic quantum algorithms. We present a full-state vector simulation algorithm and software implementation designed to perform HPC simulation of layers of rotations around a string of Pauli operators. We demonstrate robust scalability of the simulation method on large distributed CPU and GPU systems. Our distributed computation harnessed up to 16384 CPU cores and 512 NVIDIA H100 GPUs, using 32 TB of memory. The simulator significantly outperforms other high-performance libraries, showing a typical speedup of 10-100 for large-scale multi-GPU workloads. As a first application of our approach, we report a numerical experiment aimed at simulating exactly Hamiltonian dynamics of up to 40 qubits to investigate the Trotter error for a quantum chemistry problem. Bounding the Trotter error is important for evaluating the cost of quantum algorithms for chemistry, and rigorous bounds are often conservative, as our simulations confirm. Our software, specifically designed for quantum time evolution applications, is also well equipped to manage circuits that utilize standard gate sets.

arXiv:2504.17881•Communications AI & Computing•Jul 14, 2026•2 citations
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.
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.
Quantum computing simulation on a classical computer is difficult due to the exponential runtime and memory overhead. Previous work addresses the difficulty by utilizing multiple Graphical Processing Units (GPUs) and multi-node computers. GPUs are efficient for handling runtime issues but have limited total accessible memory space. Meanwhile, the memory of a multi-node computer can be scaled to the petabytes order, but its bandwidth for access from host computers (CPUs) is narrow. To simultaneously accelerate simulation and enlarge the total memory space, we propose a heterogeneous parallelization approach by combining GPUs and CPUs. Our simulator allocates memory to the GPUs first, and then to the CPUs. It thus accelerates simulation by using the full capabilities of the GPUs if memory for the simulation fits in the GPUs on a cluster. Allocating memory to the CPUs reduces benefits of the GPUs but enlarges the capacity of qubits in the simulation. In such case, it can exploit the memory of the GPUs to add one more qubit in the simulation if the size of memory in a node is the power of two (such as 512GB). We show empirical performance evaluations of our simulator in a distributed environment of POWER9.
Pauli strings are a fundamental computational primitive in hybrid quantum-classical algorithms. However, classical computation of Pauli strings suffers from exponential complexity and quickly becomes a performance bottleneck as the number of qubits increases. To address this challenge, this paper proposes the Pauli Composer Accelerator (PACOX), the first dedicated FPGA-based accelerator for Pauli string computation. PACOX employs a compact binary encoding with XOR-based index permutation and phase accumulation. Based on this formulation, we design a parallel and pipelined processing element (PE) cluster architecture that efficiently exploits data-level parallelism on FPGA. Experimental results on a Xilinx ZCU102 FPGA show that PACOX operates at 250 MHz with a dynamic power consumption of 0.33 W, using 8,052 LUTs, 10,934 FFs, and 324 BRAMs. For Pauli strings of up to 19 qubits, PACOX consistently outperforms state-of-the-art CPU-based methods in terms of execution speed, while also requiring significantly less memory and achieving a much lower power-delay product. These results demonstrate that PACOX delivers high computational speed with superior energy efficiency for Pauli-based workloads in hybrid quantum-classical systems.
To address the growing needs for scalable High Performance Computing (HPC) and Quantum Computing (QC) integration, we present our HPC-QC full stack framework and its hybrid workload development capability with modular hardware/device-agnostic software integration approach. The latest development in extensible interfaces for quantum programming, dispatching, and compilation within existing mature HPC programming environment are demonstrated. Our HPC-QC full stack enables high-level, portable invocation of quantum kernels from commercial quantum SDKs within HPC meta-program in compiled languages (C/C++ and Fortran) as well as Python through a quantum programming interface library extension. An adaptive circuit knitting hypervisor is being developed to partition large quantum circuits into sub-circuits that fit on smaller noisy quantum devices and classical simulators. At the lower-level, we leverage Cray LLVM-based compilation framework to transform and consume LLVM IR and Quantum IR (QIR) from commercial quantum software frontends in a retargetable fashion to different hardware architectures. Several hybrid HPC-QC multi-node multi-CPU and GPU workloads (including solving linear system of equations, quantum optimization, and simulating quantum phase transitions) have been demonstrated on HPE EX supercomputers to illustrate functionality and execution viability for all three components developed so far. This work provides the framework for a unified quantum-classical programming environment built upon classical HPC software stack (compilers, libraries, parallel runtime and process scheduling).
Abstract Large-scale classical simulation of quantum computers is crucial for benchmarking quantum algorithms, establishing boundaries of quantum advantage and exploring heuristic quantum algorithms. We present a full-state vector simulation algorithm and software implementation designed to perform HPC simulation of layers of rotations around a string of Pauli operators. We demonstrate robust scalability of the simulation method on large distributed CPU and GPU systems. Our distributed computation harnessed up to 16384 CPU cores and 512 NVIDIA H100 GPUs, using 32 TB of memory. The simulator significantly outperforms other high-performance libraries, showing a typical speedup of 10-100 for large-scale multi-GPU workloads. As a first application of our approach, we report a numerical experiment aimed at simulating exactly Hamiltonian dynamics of up to 40 qubits to investigate the Trotter error for a quantum chemistry problem. Bounding the Trotter error is important for evaluating the cost of quantum algorithms for chemistry, and rigorous bounds are often conservative, as our simulations confirm. Our software, specifically designed for quantum time evolution applications, is also well equipped to manage circuits that utilize standard gate sets.