Validating Quantum State Preparation Programs (Extended Version)

One of the key steps in quantum algorithms is to prepare an initial quantum superposition state with different kinds of features. These so-called state preparation algorithms are essential to the behavior of quantum algorithms, and complicated state preparation algorithms are difficult to develop correctly and effectively. This paper presents Pqasm: a high-assurance framework implemented with the Coq proof assistant, allowing us to certify our Pqasm tool to correctly reflect quantum program behaviors. The key in the framework is to reduce the program correctness assurance of a program containing a quantum superposition state to the program correctness assurance for the program state without superposition. The reduction allows the development of an effective testing framework for testing quantum state preparation algorithm implementations on a classical computer - considered to be a hard problem with no clear solution until this point. We utilize the QuickChick property-based testing framework to test state preparation programs. We evaluated the effectiveness of our approach over 5 case studies implemented using Pqasm; such cases are not even simulatable in the current quantum simulators.

💡 Research Summary

The paper introduces QSV (Quantum State Preparation Validation), a high‑assurance framework for developing, testing, and compiling quantum state‑preparation programs. The authors observe that many quantum algorithms begin with a uniform superposition generated by a series of Hadamard gates, after which the algorithm “carves” the desired state using further quantum operations. Verifying such programs is difficult because the superposition may contain an exponential number of basis‑kets, making classical simulation infeasible for realistic qubit counts.

To address this, the authors design a new language, Pqasm (Preparation‑augmented QASM), which extends OQASM with preparation‑specific constructs and a three‑tier type system (Had, Nor, Rot). The type system enforces quantum‑mechanical constraints such as the no‑cloning theorem and guarantees that qubits belonging to different records are never entangled. Using the Coq proof assistant, they formally define the syntax, operational semantics, and typing rules of Pqasm and prove type‑soundness, thereby providing a mathematically certified foundation for writing state‑preparation programs.

The core verification insight is a reduction: correctness of a program that manipulates a superposition can be reduced to correctness of a program that manipulates a single basis‑ket. In practice, the framework treats the initial Hadamard block as a “special Had” type and, during testing, replaces it with a random selection of one basis‑ket from the uniform distribution. All subsequent quantum operations (comparators, controlled rotations, etc.) are interpreted as deterministic functions on that selected ket. Measurement, although probabilistic, is “determinized” by computing the exact probability from the amplitude of the selected ket. This deterministic abstraction enables property‑based testing (PBT) using QuickChick, a Coq‑integrated random testing framework. By generating many random basis‑ket samples, the tester can with high confidence detect bugs in the program logic without ever simulating the full exponential state.

QSV also includes a certified compiler that translates verified Pqasm programs into SQIR, an intermediate representation for quantum circuits. The compilation correctness is proved in Coq, ensuring that the generated circuit faithfully implements the semantics of the original Pqasm program.

The authors evaluate QSV on five case studies that are deliberately chosen because they are either unsimulatable or extremely costly to simulate with existing tools (Qiskit, DDSim). The examples include: (1) preparing a uniform superposition of n distinct basis‑kets, (2) a repeat‑until‑success routine that probabilistically prepares the same state, (3) arithmetic oracles implementing addition and modular multiplication, (4) a comparator‑based state‑preparation with conditional measurement, and (5) a more complex program combining multiple measurements and conditional branches. The input sizes range from 60 qubits per register up to a total of 361 qubits, far beyond the practical limits of naïve state‑vector simulation. In all cases, QSV’s QuickChick‑based tests run in seconds to minutes on a classical machine and successfully detect injected bugs, while the same programs either fail to run or require prohibitive resources in conventional simulators.

Limitations are acknowledged: QSV currently supports a restricted set of program patterns (essentially those that start with a Hadamard block followed by deterministic transformations and a final measurement). Extending the approach to handle nested measurements, dynamic circuit generation, or non‑unitary operations would require additional theoretical development. Moreover, the statistical guarantee of bug detection depends on the number of sampled basis‑kets; for extremely large qubit counts, the required sample size may grow, though still far less than the full exponential space.

In summary, the paper delivers a novel combination of formal verification (Coq proofs of language soundness and compiler correctness) and practical testing (QuickChick property‑based testing) that together make it possible to validate quantum state‑preparation programs on classical hardware, even when the underlying quantum state is too large to simulate. This work represents a significant step toward reliable quantum software engineering, providing a concrete pipeline—from high‑level program writing, through mathematically certified verification, to certified circuit generation—that can be integrated into future quantum development toolchains.