⚛️ quantum physics

PropHunt: Automated Optimization of Quantum Syndrome Measurement Circuits

This paper introduces PropHunt, an automated tool that optimizes Quantum Syndrome Measurement circuits for CSS codes by prioritizing logical error rates over traditional metrics, thereby enabling the recovery of hand-designed circuits and facilitating the new Hook-ZNE error mitigation strategy.

Original authors: Joshua Viszlai, Satvik Maurya, Swamit Tannu, Margaret Martonosi, Frederic T. Chong

Published 2026-01-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Joshua Viszlai, Satvik Maurya, Swamit Tannu, Margaret Martonosi, Frederic T. Chong

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

The Big Picture: Fixing the "Security Guard" of Quantum Computers

Imagine you are trying to build a super-computer that can solve impossible problems, like designing new medicines or cracking unbreakable codes. This is a Quantum Computer. However, these computers are incredibly fragile. If you whisper too loudly or the room gets too warm, the information they are holding turns into gibberish. This is called "noise" or "errors."

To fix this, scientists use a system called Quantum Error Correction (QEC). Think of QEC as a team of security guards watching over the computer's memory. Their job is to constantly check if the data has been corrupted and fix it immediately.

The tool these guards use to check the data is called a Syndrome Measurement (SM) Circuit. It's like a specific set of instructions the guards follow to ask, "Is everything okay?"

The Problem: The Guards Are Following Bad Instructions

The paper argues that while we know what the guards need to do, we haven't been very good at designing how they do it.

The Old Way: Previously, researchers designed these instruction sets by hand. It was like a master chef writing a recipe for a specific dish. This worked for a few famous dishes (like the "Surface Code"), but if you wanted to cook a new, complex dish (a new type of error-correcting code), you had to start from scratch. It was slow, expensive, and often impossible for complex recipes.
The Flawed Tools: Existing computer tools tried to help by making the instructions "shorter" or "faster" (fewer steps). But the authors found a problem: Shorter isn't always better.
- The Analogy: Imagine a line of people passing a bucket of water to put out a fire. If you arrange them in a short line but in the wrong order, one person might accidentally splash water on the wrong side, causing a bigger mess. If you arrange them in a slightly longer line but in the perfect order, the water goes exactly where it needs to go.
- The paper shows that simply counting the number of steps (circuit depth) doesn't tell you if the guards will actually catch the errors. Sometimes, a "shorter" set of instructions actually lets errors slip through the cracks.

The Solution: Introducing "PropHunt"

The authors created a new automated tool called PropHunt. Instead of trying to make the instructions shorter, PropHunt tries to make the instructions less confusing.

The "Ambiguity" Problem: Sometimes, the guards get confused. They see a signal that could mean "The data is fine" OR "The data is broken." If they can't tell the difference, they might fix the wrong thing, creating a permanent error. The paper calls this "ambiguity."
How PropHunt Works:
1. It looks at the current set of instructions.
2. It finds the specific moments where the guards get confused (where the signals are ambiguous).
3. It automatically shuffles the order of the steps (like rearranging the people passing the bucket) to remove that confusion.
4. It repeats this process until the instructions are as clear as possible.

Think of PropHunt as a traffic control system for quantum errors. Instead of just counting how many cars are on the road, it looks at the traffic lights and timing to ensure no two cars crash into each other.

The Results: Better Guards, New Recipes

The authors tested PropHunt on several different types of error-correcting codes:

Re-discovering the Classics: When they gave PropHunt the famous "Surface Code," it automatically figured out the exact same perfect instructions that human experts had spent years designing by hand. This proves the tool works.
Solving the Unsolvable: They tried it on newer, more complex codes (called "Lifted Product" and "Random Quantum Tanner" codes) where no human had figured out the best instructions yet. PropHunt found instructions that were 2.5 to 4 times better at stopping errors than the standard methods currently used.

A Bonus Trick: "Hook-ZNE"

The paper also suggests a clever side-use for this tool, which they call Hook-ZNE.

The Idea: Sometimes, you don't want the guards to be perfect immediately. You might want to test how the computer behaves when things go slightly wrong, to learn how to fix it better later.
The Metaphor: Imagine a pilot training in a flight simulator. If the simulator is too perfect, the pilot doesn't learn. If the simulator is too chaotic, the pilot crashes. You need a "Goldilocks" level of chaos.
How it helps: Because PropHunt can create instructions that are almost perfect but have just a tiny bit of confusion left in them, it can be used to intentionally create a controlled amount of error. This helps scientists test and improve their error-correction systems on today's imperfect quantum computers.

Summary

The Issue: Quantum computers need "security guards" (SM circuits) to catch errors, but we don't know how to design the best instructions for them, especially for new types of codes.
The Mistake: Previous tools tried to make instructions shorter, but that didn't always stop errors.
The Fix: PropHunt is an automated tool that rearranges the instructions to remove "confusion" (ambiguity), ensuring the guards catch every error.
The Win: It matches human experts on old codes and creates significantly better instructions (up to 4x better) for new, complex codes. It also offers a way to fine-tune error testing for near-term experiments.

Technical Summary: PropHunt: Automated Optimization of Quantum Syndrome Measurement Circuits

1. Problem Statement

Fault-Tolerant Quantum Computing (FTQC) relies on Quantum Error Correction (QEC) codes, which utilize Syndrome Measurement (SM) circuits to detect and correct errors on data qubits. While the theoretical performance of QEC codes is often evaluated based on code distance ( $d$ ), the actual logical error rate is heavily dependent on the physical implementation of the SM circuit.

Existing circuit optimization tools, primarily designed for the Noisy Intermediate-Scale Quantum (NISQ) era, focus on minimizing gate counts and circuit depth to reduce the probability of physical errors occurring. However, in FTQC, errors are expected to occur and must be tolerated. The critical challenge is that the ordering of CNOT gates within an SM circuit dictates how errors propagate (specifically "hook errors" where an ancilla fault spreads to multiple data qubits). Poor ordering can create ambiguous error patterns that lead to undetected logical errors, effectively reducing the code's performance even if the circuit depth is minimal.

Current approaches to SM circuit design face three limitations:

Hand-design: Tailored circuits are intensive and often intractable for codes with random structures (e.g., Lifted Product or Random Quantum Tanner codes).
Brute-force search: Unscalable for moderate-to-large code sizes.
Imperfect predictors: Optimizing for circuit depth or effective code distance ( $d_{eff}$ ) alone is insufficient. As demonstrated in the paper, circuits with identical depth or $d_{eff}$ can exhibit vastly different logical error rates due to how errors propagate through the specific CNOT schedule.

2. Methodology: PropHunt

The authors propose PropHunt, an automated tool for optimizing SM circuits for CSS codes by directly targeting the minimization of error ambiguity rather than relying on imperfect proxies like depth.

Core Concept: Error Ambiguity

The paper defines an ambiguous error as two distinct error patterns ( $e_1$ and $e_2$ ) that produce the same syndrome ( $H e_1 = H e_2$ ) but have different logical effects ( $L e_1 \neq L e_2$ ). A Maximum Likelihood Estimator (MLE) decoder will mispredict the logical state when such ambiguity exists. The goal is to modify the SM circuit to eliminate these ambiguous pathways.

The Optimization Loop

PropHunt operates through an iterative loop consisting of five stages:

Ambiguous Decoding Subgraph Finding:
- The tool constructs a circuit-level decoding graph where nodes represent errors and syndromes.
- It samples random subgraphs and expands them until it identifies a subgraph where the logical observable matrix $L'$ is not in the row space of the check matrix $H'$ ( $L' \notin \text{rowsp}(H')$ ). This condition indicates the presence of an ambiguous error within that subgraph.
Min-Weight Logical Error Solving (via MaxSAT):
- For each identified ambiguous subgraph, PropHunt uses a MaxSAT formulation (solved via the Z3 and Loandra solvers) to find the minimum-weight logical error.
- To handle the exponential complexity of converting XOR clauses to Conjunctive Normal Form (CNF), the authors use auxiliary variables in a tree-like structure. This allows for efficient parallelized solving of local subgraphs rather than a global, intractable search.
Candidate Circuit Change Enumeration:
- Once a minimum-weight logical error is identified, the tool maps the error back to specific gate errors in the SM circuit.
- It enumerates two types of modifications to alter error propagation:
  - Reordering: Changing the sequence in which a syndrome qubit interacts with its connected data qubits.
  - Rescheduling: Changing the relative timing of syndrome qubits interacting with a shared data qubit (swapping edges in the internal multi-edge directed graph representation).
Pruning Candidates:
- Candidates are filtered based on Circuit Validity (preserving stabilizer commutation and ensuring schedulability without circular dependencies) and Ambiguity Removal (verifying that the change resolves the specific ambiguity found).
- Additional checks ensure the modified circuit does not inadvertently create new logical errors.
Applying Changes:
- Verified changes are applied to the SM circuit. If multiple compatible changes exist, the one resulting in the minimum circuit depth is selected as a secondary optimization target.

3. Key Contributions

Novel Optimization Metric: A shift from optimizing for depth or $d_{eff}$ to directly minimizing logical error rate by resolving error ambiguity in the circuit-level decoding graph.
Efficient Algorithm: A method for finding min-weight logical errors in circuit-level graphs using parallelized MaxSAT on ambiguous subgraphs, avoiding the intractability of global solving.
PropHunt Tool: An automated implementation that recovers hand-designed schedules for surface codes and optimizes circuits for codes where no known performant schedules exist.
Hook-ZNE: A novel application of PropHunt's intermediate optimization states to improve Zero-Noise Extrapolation (ZNE) for near-term FTQC.

4. Evaluation Results

The authors evaluated PropHunt on a suite of QEC codes, including Surface Codes, Lifted Product (LP) codes, and Random Quantum Tanner (RQT) codes.

Surface Codes: PropHunt successfully automated the discovery of the well-known "N-Z" schedule, recovering the performance of hand-designed circuits.
LP and RQT Codes: For codes without known optimal schedules, PropHunt reduced logical error rates by 2.5x to 4x compared to standard "coloration" circuits at a physical error rate of 0.1%.
Scalability: The subgraph-based MaxSAT approach proved significantly more tractable than global solving. For a $d=7$ surface code, global solving timed out, whereas the subgraph approach solved in under 2 seconds.
Idle Error Sensitivity: The study showed that the slight increases in circuit depth introduced by PropHunt's optimizations are outweighed by the reduction in logical error rates across a wide range of hardware idle error strengths (relevant to neutral atom and superconducting systems).

5. Hook-ZNE Application

The paper introduces Hook-ZNE, a near-term application leveraging PropHunt's ability to generate intermediate SM circuits with varying logical error rates at a fixed code distance.

Mechanism: Instead of changing the code distance (which is coarse and resource-intensive) or stretching the circuit (which increases decoherence), Hook-ZNE uses suboptimal SM circuits discovered during the optimization process to smoothly scale logical noise.
Performance: Compared to Distance-Scaling ZNE (DS-ZNE), Hook-ZNE provides finer-grained noise control. Evaluations show Hook-ZNE reduces error by 3x to 6x compared to DS-ZNE, offering more stable fits for expectation values with the same shot budget.

6. Significance and Claims

The paper claims that PropHunt addresses a critical gap in the QEC design space: the lack of automated tools that account for error propagation dynamics in SM circuits. By moving beyond imperfect predictors like circuit depth, PropHunt enables the discovery of high-performance SM circuits for complex QEC codes that were previously limited to hand-design or brute-force methods.

The authors emphasize that their work does not claim to solve all QEC challenges but provides a foundational tool for optimizing the "glue" (SM circuits) that holds FTQC systems together. The ability to automatically generate optimized circuits for emerging code families (like LP and RQT) is presented as essential for the practical realization of large-scale FTQC. Furthermore, the Hook-ZNE application demonstrates that the optimization process itself yields valuable artifacts for error mitigation in the near-term era.