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

Orkan: Cache-friendly simulation of quantum operations on hermitian operators

Timo Ziegler

quant-phSubmitted Apr 17, 2026• Announced Apr 20, 2026• 0 citations
arXivHTMLPDF

Abstract

Classical simulation of quantum operations is essential for algorithm design, noise characterisation, and benchmarking of quantum hardware. The most general physically realisable operation can be described by a positive linear map acting on a hermitian operator, representing either a density matrix or an observable. Established simulators vectorise the density matrix on an $n$-qubit Hilbert space and reuse state-vector kernels, storing all $2^{2n}$ elements and forgoing the benefits of hermitian symmetry. In this work, I introduce \emph{Orkan}, a simulation library that uses a tiled memory layout storing only the lower triangle of the hermitian matrix at tile granularity, roughly halving both the memory footprint and the wall time to simulate the evolution of quantum states under generic quantum operations. The implementation treats any hermitian operator uniformly and is agnostic to whether the Schrödinger or Heisenberg picture is used. Dedicated $k$-local conjugation algorithms update all entries of the hermitian matrix in a single pass. Benchmarks against Qiskit Aer, QuEST, and Qulacs show consistent wall-clock speedups of $2$-$4{\times}$ partly attributable to the reduced memory footprint.

Comments
10 pages, 6 figures. Submitted to IEEE Quantum Week 2026 (QCE26). Code: https://github.com/Timo59/orkan

Related papers

Memory-Scalable and Hardware-Adaptive Matrix-Free Quantum Simulation

Uriel Shafir, Ronnie Kosloff

The core step in quantum simulations is typically matrix vector multiplication $φ= \Hmat ψ$. Executing this step is limited by memory requirement to store the Hamiltonian. We present a memory-scalable, hardware-adaptive matrix-free framework for applying large operators on vectors without materializing the full matrix on a single accelerator. The operator is represented through a block-procedural interface: blocks may be generated, loaded, cached, distributed, or applied directly only when their action is needed. For quantum simulation, it provides the core kernel for quantum operations. An adaptive planner selects block size, cache strategy, GPU grouping, row distribution, and task parallelization from memory and workload estimates. We describe analytic, measured, and learned planning strategies that choose between procedural generation, partial caching, full caching, and row-distributed caching. The method removes the requirement that the full dense matrix fit in the accelerator memory. This shifts large simulations from a fixed memory barrier to a tunable balance between block generation, cache reuse, data movement, parallel scheduling, and numerical accuracy.

quant-pharXiv:2606.31598•Jul 1, 2026•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•1 citation

JAQSI: Just Another Quantum Simulator

Melvin Strobl, Maja Franz, Lukas Scheller +3 more

Classical simulation supports the development and validation of quantum algorithms through full-state inspection, controlled noise models and backpropagation, albeit for small quantum systems. Existing frameworks offer gate-level execution, differentiable pulse-level dynamics or optimised hardware execution. Just another quantum simulator (JAQSI) combines gate- and pulse-level simulation in one differentiable circuit model built upon JAX. Circuits are represented as pure functions of numerical inputs which support vectorised batches and JIT compilation. Within a single circuit, matrix-defined operations, gates synthesised from Hamiltonian time evolution and noise channels can be composed freely. For a fast simulation, gate and channel fusion reduces passes over the state, while adjoint differentiation computes expectation-value gradients with a constant number of statevectors. At pulse level, JAQSI reduces evolution under single-term Hamiltonians to a scalar pulse-area integral and reuses cached execution plans and compiled solvers. In a benchmark we compare JAQSI with PennyLane, Qiskit, Qibo, Qulacs, QuTiP and dynamiqs. At gate level, we observe performance either on par or an order of magnitude faster across statevector, density, noise and gradient simulation than the compared simulators up to 12 qubits. Beyond 18 qubits, JAQSI is on par with PennyLane Lightning in both statevector and gradient simulation. In the statevector and noisy density-matrix pulse benchmarks, it is at least 5 times faster than the other simulators, even with its closed-form solve disabled. Disabling the latter increases its runtime by at most a factor of 1.5. We provide JAQSI as open-source software on GitHub and PyPI.

quant-pharXiv:2610.05086•Oct 6, 2026•0 citations

Quantum Search in Hilbert Space

Michail A. Zak

A proposed quantum-computing algorithm would perform a search for an item of information in a database stored in a Hilbert-space memory structure. The algorithm is intended to make it possible to search relatively quickly through a large database under conditions in which available computing resources would otherwise be considered inadequate to perform such a task. The algorithm would apply, more specifically, to a relational database in which information would be stored in a set of N complex orthonormal vectors, each of N dimensions (where N can be exponentially large). Each vector would constitute one row of a unitary matrix, from which one would derive the Hamiltonian operator (and hence the evolutionary operator) of a quantum system. In other words, all the stored information would be mapped onto a unitary operator acting on a quantum state that would represent the item of information to be retrieved. Then one could exploit quantum parallelism: one could pose all search queries simultaneously by performing a quantum measurement on the system. In so doing, one would effectively solve the search problem in one computational step. One could exploit the direct- and inner-product decomposability of the unitary matrix to make the dimensionality of the memory space exponentially large by use of only linear resources. However, inasmuch as the necessary preprocessing (the mapping of the stored information into a Hilbert space) could be exponentially expensive, the proposed algorithm would likely be most beneficial in applications in which the resources available for preprocessing were much greater than those available for searching.

•Jan 1, 2003•0 citations

Quantum Simulation Using High-Performance Computing

Collin Beaudoin, Christian I. Trefftz, Zachary Kurmas

Hermitian matrix multiplication is one of the most common actions that is performed on quantum matrices, for example, it is used to apply observables onto a given state vector/density matrix. ρ→Hρ Our goal is to create an algorithm to perform the matrix multiplication within the constraints of QuEST [1], a high-performance simulator for quantum circuits. QuEST provides a system-independent platform for implementing and simulating quantum algorithms without the need for access to quantum machines. The current implementation of QuEST supports CUDA, MPI, and OpenMP, which allows programs to run on a wide variety of systems.

•Jan 1, 2021•0 citations

Black-box Hamiltonian simulation and unitary implementation

Andrew M. Childs, Dominic William Berry

We present general methods for simulating black-box Hamiltonians using quantum walks. These techniques have two main applications: simulating sparse Hamiltonians and implementing black-box unitary operations. In particular, we give the best known simulation of sparse Hamiltonians with constant precision. Our method has complexity linear in both the sparseness $\sparseness$ (the maximum number of nonzero elements in a column) and the evolution time $t$, whereas previous methods had complexity scaling as $\sparseness^4$ and were superlinear in $t$. We also consider the task of implementing an arbitrary unitary operation given a black-box description of its matrix elements. Whereas standard methods for performing an explicitly specified $\UN\times\UN$ unitary operation use $\tilde O(\UN^2)$ elementary gates, we show that a black-box unitary can be performed with bounded error using $O(\UN^{2/3} (\log\log \UN)^{4/3})$ queries to its matrix elements. In fact, except for pathological cases, it appears that most unitaries can be performed with only $\tilde O(\sqrt{\UN})$ queries, which is optimal.

Quantum Information and Computation•Jan 1, 2012•101 citations
Classical simulation of quantum operations is essential for algorithm design, noise characterisation, and benchmarking of quantum hardware. The most general physically realisable operation can be described by a positive linear map acting on a hermitian operator, representing either a density matrix or an observable. Established simulators vectorise the density matrix on an nnn-qubit Hilbert space and reuse state-vector kernels, storing all 22n2^{2n}22n elements and forgoing the benefits of hermitian symmetry. In this work, I introduce \emph{Orkan}, a simulation library that uses a tiled memory layout storing only the lower triangle of the hermitian matrix at tile granularity, roughly halving both the memory footprint and the wall time to simulate the evolution of quantum states under generic quantum operations. The implementation treats any hermitian operator uniformly and is agnostic to whether the Schrödinger or Heisenberg picture is used. Dedicated kkk-local conjugation algorithms update all entries of the hermitian matrix in a single pass. Benchmarks against Qiskit Aer, QuEST, and Qulacs show consistent wall-clock speedups of 222-4×4{\times}4× partly attributable to the reduced memory footprint.
The core step in quantum simulations is typically matrix vector multiplication $φ= \Hmat ψ$. Executing this step is limited by memory requirement to store the Hamiltonian. We present a memory-scalable, hardware-adaptive matrix-free framework for applying large operators on vectors without materializing the full matrix on a single accelerator. The operator is represented through a block-procedural interface: blocks may be generated, loaded, cached, distributed, or applied directly only when their action is needed. For quantum simulation, it provides the core kernel for quantum operations. An adaptive planner selects block size, cache strategy, GPU grouping, row distribution, and task parallelization from memory and workload estimates. We describe analytic, measured, and learned planning strategies that choose between procedural generation, partial caching, full caching, and row-distributed caching. The method removes the requirement that the full dense matrix fit in the accelerator memory. This shifts large simulations from a fixed memory barrier to a tunable balance between block generation, cache reuse, data movement, parallel scheduling, and numerical accuracy.
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.
Classical simulation supports the development and validation of quantum algorithms through full-state inspection, controlled noise models and backpropagation, albeit for small quantum systems. Existing frameworks offer gate-level execution, differentiable pulse-level dynamics or optimised hardware execution. Just another quantum simulator (JAQSI) combines gate- and pulse-level simulation in one differentiable circuit model built upon JAX. Circuits are represented as pure functions of numerical inputs which support vectorised batches and JIT compilation. Within a single circuit, matrix-defined operations, gates synthesised from Hamiltonian time evolution and noise channels can be composed freely. For a fast simulation, gate and channel fusion reduces passes over the state, while adjoint differentiation computes expectation-value gradients with a constant number of statevectors. At pulse level, JAQSI reduces evolution under single-term Hamiltonians to a scalar pulse-area integral and reuses cached execution plans and compiled solvers. In a benchmark we compare JAQSI with PennyLane, Qiskit, Qibo, Qulacs, QuTiP and dynamiqs. At gate level, we observe performance either on par or an order of magnitude faster across statevector, density, noise and gradient simulation than the compared simulators up to 12 qubits. Beyond 18 qubits, JAQSI is on par with PennyLane Lightning in both statevector and gradient simulation. In the statevector and noisy density-matrix pulse benchmarks, it is at least 5 times faster than the other simulators, even with its closed-form solve disabled. Disabling the latter increases its runtime by at most a factor of 1.5. We provide JAQSI as open-source software on GitHub and PyPI.
A proposed quantum-computing algorithm would perform a search for an item of information in a database stored in a Hilbert-space memory structure. The algorithm is intended to make it possible to search relatively quickly through a large database under conditions in which available computing resources would otherwise be considered inadequate to perform such a task. The algorithm would apply, more specifically, to a relational database in which information would be stored in a set of N complex orthonormal vectors, each of N dimensions (where N can be exponentially large). Each vector would constitute one row of a unitary matrix, from which one would derive the Hamiltonian operator (and hence the evolutionary operator) of a quantum system. In other words, all the stored information would be mapped onto a unitary operator acting on a quantum state that would represent the item of information to be retrieved. Then one could exploit quantum parallelism: one could pose all search queries simultaneously by performing a quantum measurement on the system. In so doing, one would effectively solve the search problem in one computational step. One could exploit the direct- and inner-product decomposability of the unitary matrix to make the dimensionality of the memory space exponentially large by use of only linear resources. However, inasmuch as the necessary preprocessing (the mapping of the stored information into a Hilbert space) could be exponentially expensive, the proposed algorithm would likely be most beneficial in applications in which the resources available for preprocessing were much greater than those available for searching.
Hermitian matrix multiplication is one of the most common actions that is performed on quantum matrices, for example, it is used to apply observables onto a given state vector/density matrix. ρ→Hρ Our goal is to create an algorithm to perform the matrix multiplication within the constraints of QuEST [1], a high-performance simulator for quantum circuits. QuEST provides a system-independent platform for implementing and simulating quantum algorithms without the need for access to quantum machines. The current implementation of QuEST supports CUDA, MPI, and OpenMP, which allows programs to run on a wide variety of systems.
We present general methods for simulating black-box Hamiltonians using quantum walks. These techniques have two main applications: simulating sparse Hamiltonians and implementing black-box unitary operations. In particular, we give the best known simulation of sparse Hamiltonians with constant precision. Our method has complexity linear in both the sparseness $\sparseness$ (the maximum number of nonzero elements in a column) and the evolution time ttt, whereas previous methods had complexity scaling as $\sparseness^4$ and were superlinear in ttt. We also consider the task of implementing an arbitrary unitary operation given a black-box description of its matrix elements. Whereas standard methods for performing an explicitly specified $\UN\times\UN$ unitary operation use $\tilde O(\UN^2)$ elementary gates, we show that a black-box unitary can be performed with bounded error using $O(\UN^{2/3} (\log\log \UN)^{4/3})$ queries to its matrix elements. In fact, except for pathological cases, it appears that most unitaries can be performed with only $\tilde O(\sqrt{\UN})$ queries, which is optimal.