Variational Quantum Algorithms (VQAs) are a central class of hybrid quantum–classical methods for optimization on noisy intermediate-scale quantum (NISQ) hardware. Their scalability is constrained by the cost of gradient evaluation via the parameter-shift rule, whose complexity grows with both the number of circuit parameters and Pauli terms in the Hamiltonian, quickly dominating runtime for deep circuits or large qubit counts. We present TREV (Tensor-Ring Evaluated Variational algorithms), a Python library that accelerates VQA simulation through batched parameter evaluation within tensor-ring state representations . By amortizing contraction and sampling costs across multiple parameter shifts, TREV exploits GPU-parallel tensor contractions to achieve substantial runtime reduction with tunable memory–throughput trade-offs. Implemented in PyTorch, the framework supports both deterministic contraction-based and stochastic sampling-based evaluations. Benchmarks on Max-Cut, Traveling Salesperson Problem (TSP), and molecular ground-state energy estimation (H 2 , H 4 , LiH, BeH 2 ) show comparable accuracy and up to 97% runtime reduction over sequential evaluation, while outperforming PennyLane, TensorCircuit, and Qiskit in runtime scalability. The chemistry benchmarks further demonstrate that TREV handles arbitrary Pauli Hamiltonians beyond QUBO formulations, broadening its applicability to quantum chemistry.
Variational quantum algorithms often adapt the ansätze (ansatz) to the target Hamiltonian, leading to deep or hardware-incompatible circuits. In this work we demonstrate an opposite approach: choosing a hardware-efficient CNOT-ladder ansatz and calibrating the Hamiltonian to compensate for its expressibility to solve ground-state energy problem of 100+ site lattice on real quantum computer. This ansatz-calibrated Hamiltonian framework enables two key advantages: (1) it allows restructuring the algorithm into smaller sub-problems which can independently solved off-line classically, leaving quantum computer tasked with recombining partial solutions into full state-vector with fewer parameters to optimize and (2) it leverages circuit-specific error statistics to de-noise observable readouts with nominal noise-mitigation overhead. We simulate the spin-1/2 antiferromagnetic Heisenberg model over a 103-site flat Kagome lattice using IBM’s Heron r1 and r2 processors. The obtained per-site ground-state energy of \(-0.4172\,J\) , which approaches the benchmark \(-0.4386\,J\) after open boundary correction and approximate error mitigation. Our experiments reveal a peculiar distribution of bond energies when the ansatz is executed on the quantum processor, in contrast to its classical simulation, which merits further investigation.
Voltage source converters (VSCs) play a critical role in modern power systems, where their simulation requires solving linear system problems and remains computationally expensive. Quantum linear system solvers, particularly the variational quantum linear solver (VQLS) tailored for noisy intermediate-scale quantum devices, offer a competitive paradigm with the potential for developing linear solvers with logarithmically scaled computational complexity. We propose Acc-VQLS, a domain-specific quantum algorithm and circuit co-optimization method that accelerates traditional VQLS for VSC simulation. We adopt constant vector-based variational quantum circuits for fast convergence with efficient initial state preparation and employ multi-core processing to parallelize the cost function evaluation and gradient computation. To demonstrate the potential applicability of Acc-VQLS in VSC operating scenarios, we employ the commonly used fault behavior model for VQLS-based VSC simulation. Quantitative experimental evaluations and comparisons across the tested benchmarks show that the proposed Acc-VQLS reduces iterations required for cost function convergence by an average of 82.5%, and our multi-core parallel computing strategy achieves a 53.9 × speedup on the AMD EPYC 9554 CPU. By incorporating a short-circuit fault in the VSC simulation, the proposed Acc-VQLS with error compensation achieves less than 10 − 9 in both the mean absolute error and the root mean square error.
Simulating quantum circuits on classical computers is challenging because conventional state-vector simulators are required to track \(2^N\) amplitudes, a resource-intensive process. While sparse simulators that exploit state-support sparsity—where only a small subset of computational basis states carry nonzero amplitudes—offer highly efficient alternatives, they lose their advantage for circuits that generate dense quantum states. To address this, we propose an adaptive simulation technique that dynamically predicts state sparsity through a rapid pre-simulation assessment. Employing a novel application, Gaussian elimination on linear constraints, the proposed approach efficiently tracks an affine subspace of the state space to estimate the number of non-zero amplitudes without complex calculations. We emphasize that our technique specifically targets state-support sparsity rather than gate-level or unitary-matrix sparsity. Overall, this approach enables the system to select between full-state and sparse-state simulations, significantly improving speed and memory efficiency for sparse circuits as well as preserving dense-circuit performance.
Reversible logic is fundamental to quantum circuit design, as quantum operations are inherently information-preserving and reversible. While most quantum synthesis methods rely on binary logic, quaternary reversible computing can increase data density, reduce circuit width, and potentially lead to more efficient realizations. We introduce a genetic-algorithm-based approach for designing compact quaternary reversible comparator circuits, which are important components in quantum architectures. This technique utilizes a gate library based on extended Shift and Muthukrishnan–Stroud gates tailored to quaternary systems. Chromosomes encode sequences of quaternary gates, and evolutionary operators search for configurations with minimal quantum cost. Although demonstrated on comparator circuits, the approach applies to any quaternary reversible circuit defined by its truth table. The synthesis process occurs in two phases: candidate circuits first evolve toward correct behavior; then correct circuits are optimized to obtain compact implementations. We evaluate the approach on comparators performing lower-than, greater-than, and equality operations, as well as on a 1-qudit full comparator. The method achieves average quantum cost improvements of about 30% for restoring and 58% for non-restoring configurations compared to existing designs. These reductions support more efficient and more error-resilient quantum circuits, showing that this approach is a strong candidate for quaternary quantum systems.
We present STQS, a unified system architecture for spatiotemporal quantum sensing that interlaces four key quantum components: sensing , memory , communication , and computation . By employing a comprehensive gate-based framework, we systemically explore the design space of quantum sensing schemes and probe the influence of noise at each state in a sensing workflow through simulation. We introduce a novel distance-based metric that compares reference states to sensing states and assigns a confidence level. We anticipate that the distance measure will serve as an intermediate step toward more advanced quantum signal processing techniques like quantum machine learning. To our knowledge, STQS is the first system-level framework to integrate quantum sensing within a coherent, unified architectural paradigm. STQS provides seamless avenues for unique state preparation, multi-user sensing requests, and addressing practical implementations. We demonstrate the versatility of STQS through evaluations of quantum radar and qubit-based dark matter detection. To highlight the near-term feasibility of our approach, we present results obtained from IBM’s Marrakesh and IonQ’s Forte devices, validating key STQS components on present day quantum hardware. We have made the simulation code and experimental data used in this work publicly available.
Toffoli gates are key building blocks in quantum programs, and on most current quantum computers, they must be implemented with smaller gates. Such an implementation requires five 2-qubit gates if we assume that each gate can operate on any two qubits. However, many current quantum computers have only 2-qubit gates that operate on neighboring qubits; we call them neighbor gates. How many neighbor gates are required to implement a Toffoli gate? In this article, we show that six neighbor gates are necessary and sufficient, and we generalize to a characterization of all 3-qubit diagonal gates.
As quantum machines have scaled up in their number of qubits, significant research has turned towards increasing their fidelity with quantum error correction codes. Although promising results have been shown with the surface code, which only requires near-neighbor connections between qubits, the high qubit overhead of such local codes promises to be problematic. Consequently, recent work has explored non-local quantum LDPC (qLDPC) codes, which have good asymptotic encoding rates. Despite theoretical progress, hardware implementations of these codes have been a longstanding challenge. At the experimental level, demonstrations of movement based communication on atom arrays suggest this is a powerful new primitive to achieve non-local connectivity. Leveraging this, we present a protocol for implementing non-local qLDPC codes in hardware. Our protocol, qSIEVE, is a co-design of such codes with movement in atom arrays. qSIEVE defines a restricted family of qLDPC codes that can be implemented efficiently with systolic movement. We then quantify the utility of qSIEVE in the context of a complete fault tolerant architecture. We compare the cost of implementing benchmark programs in a standard, surface code only architecture and a mixed architecture where data is stored in qLDPC memory with qSIEVE and loaded to surface codes for computation. CCS Concepts: center dot Computer systems organization -> Quantum computing;
As quantum computing emerges as a promising computational paradigm, quantum programming languages provide the tools that bridge the distance between abstract programming and its hardware implementation. In some cases, restricted programming languages may even provide an avenue for more efficient circuit compilation strategies. In this work, we introduce foq, a first-order quantum programming language which allows for quantum control and recursion, and where a syntactically restricted subset of programs (pfoq) is shown to be sound and complete for quantum polytime computation. This is achieved by bounding both the recursion depth and the branching width of programs, which we demonstrate to still be compatible with various interesting applications, such as quantum teleportation and the quantum Fourier transform. pfoq constitutes the first programming-language-based characterization of the quantum complexity class fbqp, and we provide a semantics-preserving compilation algorithm such that any pfoq program can be compiled into a quantum circuit that grows polynomially on its number of input qubits, using an anchoring-and-merging technique to solve the problem of branch sequentialization.
Quantum computing is fundamentally limited by the Planck constant ( h = 6 . 63 x 10-34 J s) through the Heisenberg Limit. The energy consumption over a given time, or the speed of processing information with a specific energy budget, is a core research focus in quantum computing. To date, the smallest action (the energy-time cost) achieved is approximately 10-29J s, using a giant spin qubit composed of 20 spins. In our study, we achieved an action of 1 . 66 x 10-34 J s to reversibly manipulate a single spin qubit through a spin-spin magnetic interaction experiment. By adhering to the principle of least action, our theoretical and experimental results establish the minimal action required. Our findings highlight the potential of spin-qubit quantum computers as accelerators for computation-intensive applications, such as AI and Post-Quantum Cryptography, since they exhibit several unique advantages: 1. High energy efficiency (by approaching the Heisenberg limit as well as the Landauer bound); 2. High-density integration (with just an atom/ion per qubit); 3. Long coherence times (tens of seconds); 4. High-fidelity (98%); and 5. Fault tolerance (through decoherencefree subspaces).
The data input model is a fundamental component of every quantum algorithm, as its efficiency is crucial for achieving potential speed-ups over classical methods. For quantum linear algebra tasks that utilize quantum eigenvalue or singular value transformations, block encoding is the established technique for accessing matrix data. A key application of this is solving partial differential equations, where the Laplacian operator and its finite difference discretization serve as foundational examples. In this paper, we present an efficient and explicit block encoding method that enhances existing approaches in key aspects. We detail the construction of the quantum algorithm and illustrate how it leverages the unique structure of finite difference discretizations. Furthermore, we analytically derive the scaling of the sub-normalization factor and of the success probability of the block encoding with respect to the problem dimension, the grid width of the finite difference grid and the regularity of the exact solution, and we give resource estimates.
The efficient implementation of matrix arithmetic operations underpins the speedups of many quantum algorithms. We develop a suite of methods to perform matrix arithmetics -- with the result encoded in the off-diagonal blocks of a Hamiltonian -- using Hamiltonian evolutions of input operators. We show how to maintain this $\textit{Hamiltonian block encoding}$, so that matrix operations can be composed one after another, and the entire quantum computation takes $\leq 2$ ancilla qubits. We achieve this for matrix multiplication, matrix addition, matrix inversion, Hermitian conjugation, fractional scaling, integer scaling, complex phase scaling, as well as singular value transformation for both odd and even polynomials. We also present an overlap estimation algorithm to extract classical properties of Hamiltonian block encoded operators, analogous to the well known Hadmard test, at no extra cost of qubit. Our Hamiltonian matrix multiplication uses the Lie group commutator product formula and its higher-order generalizations due to Childs and Wiebe. Our Hamiltonian singular value transformation employs a dominated polynomial approximation, where the approximation holds within the domain of interest, while the constructed polynomial is upper bounded by the target function over the entire unit interval. We describe a circuit for simulating a class of sum-of-squares Hamiltonians, attaining a commutator scaling in step count, while leveraging the power of matrix arithmetics to reduce the cost of each simulation step. In particular, we apply this to the doubly factorized tensor hypercontracted Hamiltonians from recent studies of quantum chemistry, obtaining further improvements for initial states with a fixed number of particles. We achieve this with $1$ ancilla qubit.
Quantum computing has the potential to revolutionize fields like quantum optimization and quantum machine learning. However, current quantum devices are hindered by noise, reducing their reliability. A key challenge in gate-based quantum computing is improving the reliability of quantum circuits, measured by process fidelity, during the transpilation process, particularly in the routing stage. In this article, we address the Fidelity Maximization in Routing Stage (FMRS) problem by introducing FIDDLE, a novel learning framework comprising two modules: a Gaussian Process-based surrogate model to estimate process fidelity with limited training samples and a reinforcement learning module to optimize routing. Our approach is the first to directly maximize process fidelity, outperforming traditional methods that rely on indirect metrics such as circuit depth or gate count. We rigorously evaluate FIDDLE by comparing it with state-of-the-art fidelity estimation techniques and routing optimization methods. The results demonstrate that our proposed surrogate model is able to provide abetter estimation on the process fidelity compared to existing learning techniques, and our end-to-end framework significantly improves the process fidelity of quantum circuits across various noise models.
It is widely recognized that quantum computing has profound impacts on multiple fields, including but not limited to cryptography, machine learning, materials science, and so on. To run quantum algorithms, it is essential to develop scalable quantum hardware with low noise levels and to design efficient fault-tolerant quantum computing (FTQC) schemes. Currently, various FTQC schemes have been developed for different hardware platforms. However, a comprehensive framework for the analysis and evaluation of these schemes is still lacking. In this work, we propose Quantum Logical Operations Per Second (QLOPS) as a metric for assessing the performance of FTQC schemes on quantum hardware platforms. This benchmarking framework will integrate essential relevant factors, e.g., the code rates of quantum error-correcting codes, the accuracy, throughput, and latency of the decoder. Through a resource analysis of factoring RSA-2048, we demonstrate that QLOPS reflects the practical requirements of quantum algorithm execution. This framework will enable the identification of bottlenecks in quantum hardware, providing potential directions for their development. Moreover, our results will help establish a comparative framework for evaluating FTQC designs. As this benchmarking approach considers practical applications, it may assist in estimating the hardware resources needed to implement quantum algorithms and offers preliminary insights into potential timelines.
Delegated quantum computing (DQC) allows clients with low quantum capabilities to outsource computations to a server hosting a quantum computer. This process is often envisioned within the measurement-based quantum computing framework, as it naturally facilitates blindness of inputs and computation. Hence, the overall process of setting up and conducting the computation encompasses a sequence of three stages: preparing the qubits, entangling the qubits to obtain the resource state, and measuring the qubits to run the computation. There are two primary approaches to distributing these stages between the client and the server that impose different constraints on cryptographic techniques and experimental implementations. In the prepare-and-send setting, the client prepares the qubits and sends them to the server, while in the receive-and-measure setting, the client receives the qubits from the server and measures them. Although these settings have been extensively studied independently, their interrelation and whether setting-dependent theoretical constraints are inevitable remain unclear. By implementing the key components of most DQC protocols in the respective missing setting, we provide a method to build prospective protocols in both settings simultaneously and to translate existing protocols from one setting into the other.
Evaluating quantum algorithms at utility-scale - involving more than 100 qubits - is a key step toward advancing real-world applications of quantum computing. In this study, we benchmark seven state-of-the-art quantum emulators employing techniques such as tensor networks, matrix product states (MPS), decision diagrams, and factorized ket based methods, running on CPU based hardware and focusing on effectively exact simulations. Performance is assessed on 13 benchmark circuits from the MQTBench library, spanning circuit sizes from 4 to 1,024 qubits. Our results reveal that MPS-based emulators outperform other approaches overall, successfully solving 8 benchmarks up to the maximum size of 1,024 qubits and 12 benchmarks up to at least 100 qubits in less than 5 minutes. We find evidence that all circuits except a random one can be simulated in polynomial time. This work demonstrates that quantum emulators can faithfully simulate a broad range of large and complex universal quantum circuits with high fidelity, far beyond the limits of statevector simulators and today's quantum hardware.
Quantum Approximate Optimization Algorithm (QAOA) is a promising quantum heuristic with empirical evidence of speedup over classical state-of-the-art for some problems. QAOA uses a parameterized circuit with p layers, where higher p yields better solutions, but requires optimizing 2p independent parameters, which is challenging at large p. We present an iterative interpolation method that exploits the smoothness of optimal parameter schedules by expressing them in a basis of orthogonal functions, generalizing the work of Zhou et al. By optimizing a small number of basis coefficients and iteratively increasing both circuit depth and coefficient count until convergence, our method constructs high-quality schedules for large p. We provide theoretical justification using Jackson's theorem and Lipschitz continuity to bound the required number of basis coefficients for a given accuracy. Our approach achieves better performance with fewer optimization steps than existing methods across three benchmark problems: the Sherrington-Kirkpatrick (SK) model, portfolio optimization, and Low Autocorrelation Binary Sequences (LABS). For the largest LABS instance, we achieve near-optimal merit factors with schedules exceeding 1000 layers, an order of magnitude beyond previous methods. Additionally, we observe that a mild growth in QAOA depth suffices to solve the SK model exactly, a result of independent theoretical interest.
Property-based testing has been previously proposed for quantum programs in Q# with QSharpCheck; however, this implementation was limited in functionality, lacked extensibility, and was evaluated on a narrow range of programs using a single property. To address these limitations, we propose QuCheck, an improved property-based testing framework for Qiskit. By leveraging Qiskit and the broader Python ecosystem, QuCheck facilitates property construction, introduces flexible input generators and assertions, and supports expressive preconditions. We assessed its effectiveness through mutation analysis on five quantum programs (2-10 qubits), varying the number of properties, inputs, and measurement shots to assess their impact on fault detection and demonstrate the effectiveness of property-based testing across a range of conditions. Results show a strong positive correlation between the mutation score (a measure of fault detection) and number of properties evaluated, with a moderate negative correlation between the false positive rate and number of measurement shots. The most thorough test configurations achieved a mean mutation score of 0.90 averaged across all five algorithms, with a false positive rate between 0 and 0.06. QuCheck identified 47.8% more faults than QSharpCheck, with execution time reduced by 67.4%. These findings highlight the viability of property-based testing for verifying quantum systems.
Ordered search is the task of finding an item in an ordered list using comparison queries. The best exact classical algorithm for this fundamental problem uses ⌈log_2n⌉ queries for a list of length n. Quantum computers can achieve a constant-factor speedup, but the best possible coefficient of log_2n for exact quantum algorithms is only known to lie between (ln2)/π≈ 0.221 and 4/log_2605≈ 0.433. We consider a special class of translation-invariant algorithms with no workspace, introduced by Farhi, Goldstone, Gutmann, and Sipser, that has been used to find the best known upper bounds. First, we show that any exact, k-query quantum algorithm for ordered search can be implemented by a k-query algorithm in this special class. Second, we use linear programming to show that the best exact 5-query quantum algorithm can search a list of length 7265, giving an ordered search algorithm that asymptotically uses 5 log_7265n≈ 0.390 log_2n quantum queries.
The distance of a stabilizer quantum code is a very important feature since it determines the number of errors that can be detected and corrected. We present three new fast algorithms and implementations for computing the symplectic distance of the associated classical code. Our new algorithms are based on the Brouwer-Zimmermann algorithm. Our experimental study shows that these new implementations are much faster than current state-of-the-art licensed implementations on single-core processors, multicore processors, and shared-memory multiprocessors. In the most computationally-demanding cases, the performance gain in the computational time can be larger than one order of magnitude. The experimental study also shows a good scalability on shared-memory parallel architectures.
