⚛️ quantum physics

ConQEC: Concolic Testing for Quantum Error-Correcting Code Implementations

This paper introduces ConQEC, the first concolic testing framework for quantum error-correcting code implementations, which combines concrete fault replay with symbolic constraint solving to generate scalable, diagnostic-rich tests that identify and localize the earliest divergence points in fault-syndrome-decoder-recovery workflows.

Original authors: Zihao Li, Ji Guan, Mingsheng Ying

Published 2026-10-23

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Zihao Li, Ji Guan, Mingsheng Ying

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that are currently impossible for classical machines, from designing new medicines to cracking complex codes. However, the physical parts that make up these machines are incredibly fragile. The slightest disturbance from heat or radiation can flip a quantum bit, corrupting the calculation before it finishes. To protect against this, scientists use a method called quantum error correction. Instead of storing information on a single, fragile bit, they spread it across many physical bits. The system constantly checks the relationships between these bits to spot errors without looking at the actual data, and then automatically fixes them. This process is like a self-healing shield, but it relies on complex software to decide which bits are broken and how to repair them. If that software makes a mistake, the entire protection system fails, and the quantum computer loses its information.

Building this software is difficult because the rules of quantum physics are different from the rules of everyday electronics. A small error in the code can cause the system to apply the wrong fix, making the problem worse. Until now, there has been no reliable way to test this software thoroughly. Existing tools could prove that the math was correct in theory, or they could run random tests to see if the system eventually crashed, but they could not tell a developer exactly where the software went wrong when it did. A developer needed to know not just that the repair failed, but which specific step in the repair process had gone off track. Was it the part that detected the error? The part that decided which fix to apply? Or the part that actually performed the fix? Without this specific information, finding and fixing bugs in quantum error correction software was like trying to repair a car engine by only knowing the car wouldn't start.

A team of researchers has developed a new testing method called ConQEC to solve this problem. They created a system that acts like a guided tour through the repair process, looking for the exact moment the software deviates from the correct path. Instead of guessing which errors to test, the system uses a smart search to generate specific error scenarios that are most likely to reveal hidden mistakes. When it finds a problem, it does not just report a failure; it produces a detailed record of the entire event. This record shows the specific error that was introduced, the signal the system received, the decision the software made, the action it took, and the precise point where the software's behavior differed from what it should have been. This allows developers to see the bug clearly and fix it immediately.

The researchers tested this new method on a wide variety of quantum error correction designs, including some that use thousands of physical bits. In every single case where they planted a known bug into the software, ConQEC found it. It successfully located the error in systems with up to 1,500 physical bits, a scale that is relevant to the large quantum processors being built today. The system was able to distinguish between different types of mistakes, such as a sensor reading the wrong value, a decision-making module choosing the wrong fix, or a repair action being applied to the wrong location. In one specific test involving a simple three-bit system, the researchers introduced a fault that caused the software to choose the wrong repair action. ConQEC identified that the software had selected the wrong fix for the specific error signal it received, pinpointing the exact moment the logic diverged from the correct path.

One of the most significant findings was that this method works efficiently even as the systems grow larger. Traditional testing methods often struggle when the number of bits increases because the number of possible error combinations grows too fast to check one by one. ConQEC avoids this problem by focusing on the logic of the repair process rather than trying to simulate every possible state of the quantum machine. The researchers found that the time it took to replay the tests and verify the results was negligible, even for the largest systems. The main time cost came from the smart search that decided which errors to test next, not from the actual checking of the results. This means the method can scale to the massive quantum computers of the future without becoming too slow to be useful.

The team also demonstrated that this approach works on real-world software artifacts that are already being used by other researchers. They applied their method to public datasets and existing quantum error correction tools, showing that it can integrate with the current ecosystem of quantum software development. By comparing the behavior of different software versions, they were able to spot subtle differences in how they handled error signals. In one instance, they found that two different decoding programs produced the same final result but arrived there through different internal steps, a difference that could matter for future reliability. In another case, they identified a specific scenario where a historical version of the software failed to correct an error, while a newer, fixed version succeeded.

The work suggests that the future of building reliable quantum computers will depend on tools that can provide this level of detailed insight. By turning the repair process into a transparent, step-by-step journey, ConQEC gives developers the ability to debug their software with the same precision they use for classical computers. The researchers showed that it is possible to test these complex systems at a large scale without getting lost in the overwhelming number of possibilities. Their method provides a clear path forward for ensuring that the software protecting quantum information is as robust as the physics it is designed to harness. This is not just a theoretical improvement; it is a practical tool that has already proven its ability to find and explain bugs in systems that are large enough to be relevant to the next generation of quantum technology.

Technical Summary: ConQEC – Concolic Testing for Quantum Error-Correcting Code Implementations

1. Problem Statement

Quantum Error-Correcting Code (QECC) implementations function as hybrid software-control systems where measured syndromes drive decoder dispatch, recovery actions, and logical checks. While existing formal verification techniques can prove mathematical obligations and general quantum testing can expose final failures, developers lack a scalable testing workflow that generates concrete faults and explains where a QECC repair path first diverges from the reference.

Current approaches face two primary limitations:

Scalability: General quantum concolic testing (e.g., QCT) relies on amplitude-based constraint models. Tracking the quantum state space grows exponentially with the number of physical qubits, making these methods infeasible for modern implementations involving thousands of qubits (e.g., IBM's Condor processor).
Diagnostic Utility: Existing tools often report only a final logical failure (pass/fail). They fail to provide a replayable "witness" that isolates the specific stage of the repair pipeline (syndrome extraction, decoder decision, or recovery action) where the implementation diverged from the expected behavior.

2. Methodology: The ConQEC Framework

ConQEC is the first concolic testing framework designed specifically for QECC implementations. It addresses scalability and diagnostic needs by shifting the focus from amplitude-level state reasoning to symbolic repair-path constraints.

Core Design Principles

Fault–Syndrome–Decoder–Recovery (FSDR) Repair Paths: ConQEC treats a test not as a final outcome but as a staged execution path. A bug is accepted only after a "paired replay" against a reference contract produces a staged witness.
Symbolic Encoding at the Repair-Path Level: Instead of simulating quantum amplitudes, ConQEC symbolically encodes:
- Pauli Faults: Represented as symbolic Boolean indicators ( $\hat{f}_i$ ) for injection sites.
- Syndrome Predicates: Modeled as affine parity expressions ( $s_c(\hat{f}) = \beta_c \oplus \bigoplus \hat{f}_i$ ) representing how faults flip check bits.
- Decoder and Recovery Relations: Modeled as relations $D(\sigma, d)$ and $R(\sigma, d, r)$ mapping syndromes to decisions and recovery actions.
Paired Replay: The framework generates a candidate Pauli fault via a solver (SMT), then executes it concretely on both the implementation and a reference contract. Coverage and bug acceptance are credited only after this replay validates the fault's effect and identifies the first point of divergence.

The Concolic Loop

Symbolic Generation: The system builds a constraint model over the legal fault space and repair-path predicates. It formulates queries to target specific objectives (e.g., reaching a specific syndrome, triggering a specific decoder branch, or finding a divergence between implementation and reference).
Candidate Materialization: A solver provides a valuation for symbolic fault indicators, materializing a concrete Pauli fault (e.g., $X@q_0$ ).
Paired Validation: The concrete fault is replayed on the implementation and the reference.
Witness Construction: If the replay reveals a failure ( $\omega = \text{FAIL}$ ) or a stage-level divergence ( $\delta \neq \perp$ ), ConQEC constructs an FSDR bug witness. This witness includes the injected fault, observed syndrome, decoder decision, recovery action, oracle result, and the earliest divergent stage.

Bug Classification

ConQEC localizes bugs into five specific classes based on the earliest divergent stage:

Syndrome extraction error: Incorrect check/detector values.
Measurement register misuse: Stale or swapped register reads.
Decoder misdispatch: Correct syndrome mapped to a wrong decoder arm.
Unhandled syndrome: Reachable syndrome with no handler.
Recovery contract violation: Correct decoder decision but incorrect recovery application or final check failure.

3. Key Contributions

ConQEC Framework: The first concolic testing framework for QECC implementations, modeling tests as FSDR repair paths and returning replay-backed witnesses.
Scalable Repair-Path Generation: A symbolic encoding method that avoids exponential amplitude-level reasoning, enabling the generation of targeted faults for QECCs with up to thousands of qubits.
Empirical Evaluation: Comprehensive evaluation on generated source-level QECC families (Repetition, Surface/Toric, Tanner/LDPC, Color codes) and public artifacts (Tesseract, PyMatching), demonstrating the ability to detect seeded bugs and provide fault-localizing witnesses at scale.

4. Experimental Results

The evaluation was conducted on a server with 128 cores and 2.0 TiB memory, using the QSE backend and Z3 solver.

Fault Localization (RQ1): ConQEC successfully localized seeded bugs in 195/195 experimental cases (across 13 configurations and 5 bug classes) with a generation budget of $B=4$ . In contrast, random fault testing found only ~15.7/195 witnesses at the same budget, and generic branch-order search found 0. ConQEC localized faults in systems with up to 1,500 physical qubits.
Semantic Coverage (RQ2): ConQEC significantly outperformed random testing in covering "hard" stabilizer obligations (e.g., pair-mask coverage where two faults cancel out). For $n=1000$ qubits, ConQEC covered ~49.9% of pair-mask obligations at budget $B=500$ , whereas random testing covered only 0.10%.
Scale and Cost (RQ3): The framework scaled to source-level campaigns with 3,000 qubits (Repetition code) and distance $d=41$ (Surface code). The primary bottleneck was SMT solving/query generation, not the paired replay phase, which accounted for less than 0.004% of wall-clock time.
Public Artifact Applicability (RQ4): ConQEC successfully instantiated replay-backed evidence on public artifacts, including the Tesseract Stim corpus and PyMatching regression tests, identifying logical disagreements and decoder boundary regressions.

5. Significance and Claims

The paper claims that ConQEC provides a scalable, diagnostic testing workflow for QECC implementations that existing formal verification and general quantum testing tools cannot offer.

Developer-Centric Debugging: By returning a replayable FSDR witness, ConQEC transforms a "black box" failure into a localized debugging artifact, identifying exactly where the repair path diverged (e.g., "Decoder chose $X@q_1$ instead of $X@q_0$ for syndrome $(1,0)$ ").
Scalability: By abstracting away amplitude-level state tracking and focusing on the discrete logic of syndrome decoding and recovery, ConQEC bridges the gap between theoretical QECC verification and practical software testing for thousand-qubit systems.
Complementarity: The authors position ConQEC as complementary to formal verification tools (like QSE or QECV). While formal tools prove correctness, ConQEC generates concrete test cases and debugging evidence for implementation bugs, operating within a "budgeted" testing framework suitable for large-scale software stacks.

The paper maintains a modest scope, acknowledging that its symbolic model relies on exposed predicates and that transition objectives require explicit decoder/recovery relations. It does not claim to solve all quantum software testing problems but specifically targets the unique challenges of QECC repair pipelines.