Quantum algorithms for scientific computing are specified against access models such as block-encodings, sparse oracles, state preparations, and quantum random-access memories. Their concrete realization is deliberately left open, yet it is a research variable that changes both the numerical behavior and the resource cost of the program, so every reported conclusion is attributable to one realization. In this paper, we present oracq, a Python framework that makes this choice a managed and checkable decision. Our claim is linguistic rather than infrastructural. Algorithms are stored as persistent register-level programs whose oracle slots are declared and typed but unimplemented. A separate binding pass links compatible realizations, so one stored algorithm can be re-bound to a gate network, a QRAM-backed table, or compiled reversible arithmetic and compared across them. Typed QRAM resources, a compiler from pure Python numerical formulas to reversible fixed-point circuits, and block-encoding algebra with qubitization and QSVT-style kernels supply the constructions. Two end-to-end workflows exercise the framework, a quantum finite-volume pipeline for the compressible Euler equations and a quantum homotopy-analysis pipeline that lifts nonlinear PDEs to composable linear input models. The verification methodology separates implementation error from method error, and logical resource accounts cover programs before and after binding. The framework is openly available at https://github.com/IAI-USTC-Quantum/oracq.
AI Summary
Quantum scientific-computing algorithms assume block-encodings, sparse oracles, state preparations, or QRAM, but concrete realizations affect both numerical accuracy and resource cost. **oracq** is a Python framework for storing algorithms as persistent register-level programs with typed, unimplemented oracle slots. A separate checked binding pass substitutes implementations without regenerating callers, checking register layouts, capabilities, fixed-point formats, and declared block-encoding normalizations. Libraries provide block-encoding algebra, QSVT-style kernels, named QRAM resources, and compilation of supported Python formulas into reversible fixed-point circuits.
The demonstrations assemble a compressible-Euler finite-volume workflow and a homotopy-analysis nonlinear-PDE workflow. A controlled experiment binds one stored algorithm to gate-table, QRAM-table, and arithmetic realizations at word widths $2,3,4$. All nine configurations match analytic amplitudes within $2.5\times10^{-16}$ across four execution paths; their logical costs differ. A further 193 instance-specific verification cases use independently constructed references, separating implementation from discretization, truncation, and quantization error. Selected Roe circuits are bit-exact against fixed-point references while retaining substantial deviations from floating-point physics. Generated four-cell QFVM constructions require roughly 1,960 data/work qubits and $5.85\times10^7$–$6.49\times10^8$ Toffolis, but are not accuracy-matched benchmarks or certified CFD steps.
Binding checks structural compatibility, not mathematical correctness or workspace cleanup. Validation covers finite instances, with restricted backend coverage for larger circuits; two execution paths share a simulator. QRAM queries remain physically unpriced, writes are classical-only, and estimates exclude routing and error correction. The bundled phase synthesizer has a degree-40 guard, though a replaceable backend is demonstrated at degree 585.
Some signs of AI-generated textIncrementalUnclear novelty
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
Quantum algorithms for scientific computing are specified against access models such as block-encodings, sparse oracles, state preparations, and quantum random-access memories. Their concrete realization is deliberately left open, yet it is a research variable that changes both the numerical behavior and the resource cost of the program, so every reported conclusion is attributable to one realization. In this paper, we present oracq, a Python framework that makes this choice a managed and checkable decision. Our claim is linguistic rather than infrastructural. Algorithms are stored as persistent register-level programs whose oracle slots are declared and typed but unimplemented. A separate binding pass links compatible realizations, so one stored algorithm can be re-bound to a gate network, a QRAM-backed table, or compiled reversible arithmetic and compared across them. Typed QRAM resources, a compiler from pure Python numerical formulas to reversible fixed-point circuits, and block-encoding algebra with qubitization and QSVT-style kernels supply the constructions. Two end-to-end workflows exercise the framework, a quantum finite-volume pipeline for the compressible Euler equations and a quantum homotopy-analysis pipeline that lifts nonlinear PDEs to composable linear input models. The verification methodology separates implementation error from method error, and logical resource accounts cover programs before and after binding. The framework is openly available at https://github.com/IAI-USTC-Quantum/oracq.
Quantum scientific-computing algorithms assume block-encodings, sparse oracles, state preparations, or QRAM, but concrete realizations affect both numerical accuracy and resource cost. oracq is a Python framework for storing algorithms as persistent register-level programs with typed, unimplemented oracle slots. A separate checked binding pass substitutes implementations without regenerating callers, checking register layouts, capabilities, fixed-point formats, and declared block-encoding normalizations. Libraries provide block-encoding algebra, QSVT-style kernels, named QRAM resources, and compilation of supported Python formulas into reversible fixed-point circuits.
The demonstrations assemble a compressible-Euler finite-volume workflow and a homotopy-analysis nonlinear-PDE workflow. A controlled experiment binds one stored algorithm to gate-table, QRAM-table, and arithmetic realizations at word widths 2,3,4. All nine configurations match analytic amplitudes within 2.5×10−16 across four execution paths; their logical costs differ. A further 193 instance-specific verification cases use independently constructed references, separating implementation from discretization, truncation, and quantization error. Selected Roe circuits are bit-exact against fixed-point references while retaining substantial deviations from floating-point physics. Generated four-cell QFVM constructions require roughly 1,960 data/work qubits and 5.85×107–6.49×108 Toffolis, but are not accuracy-matched benchmarks or certified CFD steps.
Binding checks structural compatibility, not mathematical correctness or workspace cleanup. Validation covers finite instances, with restricted backend coverage for larger circuits; two execution paths share a simulator. QRAM queries remain physically unpriced, writes are classical-only, and estimates exclude routing and error correction. The bundled phase synthesizer has a degree-40 guard, though a replaceable backend is demonstrated at degree 585.
We introduce OpenQARP, the Open Quantum Application Research Package: an open-source Python framework for quantum application research, built on a compiled C++ core. In OpenQARP, an application is assembled from an algorithm library that orchestrates three interchangeable layers: blocks describe circuits, primitives describe what to extract from them, and engines describe how they run. The release spans near-term through fault-tolerant methods, targeting problems from electronic structure to combinatorial optimization, with device-aware compilation, circuit cutting, and resource estimation over a single set of numerical conventions that the code must follow. Every numerical feature is checked against an independent oracle, and every published timing carries a correctness check. Against OpenFermion, Qiskit/Aer, PennyLane/Lightning, Qulacs, qsim, and pytket, OpenQARP is one to two orders of magnitude faster on operator algebra and among the fastest on simulation. It matches mature compilers on two-qubit gate count, and expresses a complete algorithm in the lines a framework needs rather than the plumbing a primitive stack demands.
We present qlbm , a Python software package designed to facilitate the development, simulation, and analysis of Quantum Lattice Boltzmann Methods (QBMs). qlbm is a modular framework that introduces a quantum component abstraction hierarchy tailored to the implementation of novel QBMs. The framework interfaces with state-of-the-art quantum software infrastructure to enable efficient simulation and validation pipelines, and leverages novel execution and pre-processing techniques that significantly reduce the computational resources required to develop quantum circuits. We demonstrate the versatility of the software by showcasing multiple QBMs in 2D and 3D with complex boundary conditions, integrated within automated benchmarking utilities. Accompanying the source code are extensive test suites, thorough online documentation resources, analysis tools, visualization methods, and demos that aim to increase the accessibility of QBMs while encouraging reproducibility and collaboration. Program summary Program Title: qlbm CPC Library link to program files: https://doi.org/10.17632/28hkvsg7p2.1 Developer's repository link: https://github.com/QCFD-Lab/qlbm Licensing provisions: MPL-2.0 Programming language: Python3 Supplementary material: The documentation of is available at https://qcfd-lab.github.io/qlbm/ . Nature of problem: The advent of quantum algorithms for computational fluid dynamics brings with it challenges that are new to the established field of computational physics. These challenges include the lack of standardized implementations of the still nascent quantum methods, the intense computational demands of developing and simulating quantum algorithms on hardware available today, and the absence of tools that integrate novel developments into established infrastructure. Because of these current limitations, physicists and mathematicians expend superfluous resources on tasks that more mature computational physics branches have surmounted long ago. Solution method: QLBM is a software package that provides an end-to-end development environment for quantum lattice Boltzmann methods. The modular design and flexible quantum circuit library provide a base for extending and generalizing quantum algorithms. Performance enhancements exploit the paradigm of quantum computing simulations to accelerate the speed at which researchers can verify the validity of their methods. Its integration with state-of-the-art quantum computing software and visualization tools increases the algorithms' accesibility. These features allow QLBM to effectively generate, simulate, and analyze quantum circuits for 2D and 3D computational fluid dynamics problems.
Discrete circular convolution over Z/NZ is a linear operator and can be implemented on quantum hardware within the linear-combination-of-unitaries (LCU) framework. In this work, we make this connection explicit through an asymmetric-LCU formulation: circular convolution is the postselected block of a circuit whose controlled-shift unitary is modular addition on computational-basis states. The asymmetry is essential: fixing the postselection state to the uniform state ∣u⟩ while supplying the kernel state ∣b⟩ as the input ancilla naturally preserves the complex coefficients bi within the block, whereas a symmetric overlap would yield ∣bi∣2 weights and erase their phases. Accordingly, when ∣a⟩ and ∣b⟩ are supplied by upstream quantum routines, the convolution subroutine requires only the fixed uncompute PREPu†, completely avoiding the need for a kernel-dependent inverse preparation PREPb†. We then introduce a reversal matrix Jn=X⊗n and define reflected shifts Li,n=Li,nJn. This symmetrization yields a recursive operator algebra for convolution that is natively compatible with LCU/block-encoding workflows. The resulting symmetrized operator differs from circular convolution only by one known input-side Jn layer. Crucially, for real-valued kernels, the resulting operator Hn(b)=∑ibiLi,n is Hermitian, providing a direct Hermitian interface for quantum singular value transformation (QSVT) and related spectral transformations. Based on this framework, we present a transparent recursive construction, paired with an exactly equivalent optimized bitwise compilation of the same SELECT block. Finally, we evaluate implementation trade-offs and resource scaling under explicit cost-model conventions.
Coherent alias sampling implement an important subroutine for block encoding and qubitization based quantum simulation using quantum lookup table. Related constructions exploit data lookup and matrix structure to implement block encodings for use in quantum singular value transformation. For a state on n qubits, constructing and storing the alias table requires both classical and quantum resources exponential in n. We show that when the amplitudes are samples of a polynomial of degree at most d, the table can be represented and evaluated coherently with cost polynomial in n, d, exponentially reduced from Θ(2n) classical and quantum cost. We construct a quantum circuit for coherently computing the alias table for polynomial states using reversible integer arithmetic. By employing fast arithmetic, we construct a deterministic circuit for preparing polynomial states over Clifford+T with a complete gate count of O~(ndB+B2), where arithmetic width B=O~(dn+dlog(d+1)). In the high precision limit for state fidelity ε with fixed n and d, it is sufficient have B=Θ(log(1/ε)) and the complete gate count becomes O(log3(1/ε)loglog(1/ε)). Additionally, the effective representation of the alias table can also be used for classical sampling algorithms. Furthermore, we develop a novel technique for uncomputing the auxilary register generated by coherent alias sampling. This technique opens a research direction in sampling based initial state preparation.
We introduce Unitaria, a Python library that brings the simplicity of classical linear algebra toolkits such as NumPy and SciPy to the implementation of quantum algorithms based on block encodings, a general-purpose abstraction in which a matrix is embedded as a sub-block of a larger unitary operator. Their implementation has so far required deep knowledge of low-level circuit construction, which Unitaria aims to eliminate. The library provides a composable, array-like interface through which users can define block encodings of matrices and vectors, combine them through standard operations such as addition, multiplication, tensor products, and the Quantum Singular Value Transformation, and extract the resulting quantum circuits automatically. A key feature is a matrix-arithmetic evaluation path in which every operation can be computed directly on encoded vectors and matrices without dependence on ancilla qubits or circuit simulation. This enables correctness verification and classical simulation that scale well beyond what state vector simulation permits and also allows resource estimation, including gate counts, qubit counts, and normalization constants, without executing any circuit. Together, these capabilities allow researchers to develop, verify, and analyze quantum linear algebra algorithms today, ahead of the availability of error-corrected hardware. Unitaria is open source and available at https://github.com/tequilahub/unitaria.
Due to the fragility of quantum mechanical effects, real quantum computers are plagued by frequent noise effects that cause errors during computations. Quantum error-correcting codes address this problem by providing means to identify and correct corresponding errors. However, most of the research on quantum error correction is theoretical or has been evaluated for specific hardware models only. Moreover, the development of corresponding codes and the evaluation of whether they indeed solve the problem for a particular hardware model, still often rests on tedious trial-and-error thus far. In this work, we propose an open-source framework that supports engineers and researchers in these tasks by automatically applying error-correcting codes for a given application followed by an automatic noise-aware quantum circuit simulation. Case studies showcase that this allows for a substantially more efficient implementation and evaluation of error-correcting codes.