PropHunt: Optimizing Syndrome Measurement Circuits

• PropHunt is an automated tool for optimizing syndrome measurement circuits in CSS stabilizer codes to minimize logical error rates in fault-tolerant quantum computing.
• It models gate-level error propagation deterministically and uses a MaxSAT-based algorithm to eliminate ambiguous error patterns through local circuit transformations.
• The approach achieves 2.5–4× logical error rate reductions with minimal circuit depth increase and enables fine-grained Zero-Noise Extrapolation via the Hook-ZNE method.

PropHunt is an automated tool for optimizing Syndrome Measurement (SM) circuits associated with Calderbank-Shor-Steane (CSS) stabilizer codes in fault-tolerant quantum computing (FTQC). It addresses the problem of minimizing logical error rates in quantum error correction (QEC) by directly modeling gate-level error propagation, a task not handled by standard NISQ-era circuit optimization tools, and provides automated transformations capable of bridging the gap between theoretical code performance and its physical realization. PropHunt also introduces applications to fine-grained error mitigation such as Hook-ZNE, delivering new approaches to Zero-Noise Extrapolation (ZNE) by enabling the generation of SM circuits at intermediate logical error rates (Viszlai et al., 24 Jan 2026).

1. Problem Statement and Motivation

FTQC architectures depend critically on the performance of QEC codes, which require repeated application of SM circuits to extract syndrome information. An $[[n, k, d]]$ CSS stabilizer code, characterized by $X$-type and $Z$-type parity-check matrices $H_X, H_Z \in \mathbb{F}_2^{m\times n}$ and logical operators $L_X, L_Z \in \mathbb{F}_2^{k\times n}$, is mapped to a syndrome measurement circuit $C$ composed of sequences of CNOT and single-qubit prep/measure gates that implement parity checks.

In the circuit-level Pauli noise model, each physical gate may introduce errors; the way these errors propagate through $C$ determines the distinguishability of different error patterns. The logical error rate $$P_L(C; p) = \Pr[\text{decoder outputs wrong logical value}]$$ reflects the probability that the decoder produces the incorrect logical outcome given a physical error rate $p$. PropHunt seeks SM circuits $C^*$ that (approximately) minimize $P_L(C; p)$ subject to circuit-level constraints.

Standard NISQ-era optimization tools, which prioritize gate count or depth, are inadequate for SM circuits where the critical factor is how errors propagate and possibly become ambiguous, directly affecting logical error rates by creating fault patterns that cannot be uniquely decoded (Viszlai et al., 24 Jan 2026).

2. Circuit-Level Error Propagation and Modeling

PropHunt utilizes a standard Pauli-error model where:

• Each single-qubit gate is followed by an $X$, $Y$, or $Z$ error with probability $p/3$.
• Each two-qubit gate (e.g., CNOT) is followed by a non-identity Pauli error on the two qubits with probability $p/15$.

Error propagation is tracked deterministically: $$\mathrm{CNOT}: \quad X_c \mapsto X_c X_t, \quad Z_t \mapsto Z_c Z_t, \quad X_t \mapsto X_t, \quad Z_c \mapsto Z_c$$ For each gate, PropHunt simulates the effect of a single Pauli fault, propagates it, and records which syndrome bits ($H(C)$) and logical observables ($L(C)$) are flipped, yielding matrices $H(C) \in \mathbb{F}_2^{M \times G}$ and $L(C) \in \mathbb{F}_2^{K \times G}$, with $G$ the total number of gates.

Ambiguous pairs $(e_1, e_2)$, where $H e_1 = H e_2$ but $L e_1 \ne L e_2$, drive logical failures. Under the independent fault assumption, the probability of a particular fault pattern $e \in \mathbb{F}_2^G$ is $p^{|e|}(1-p)^{G - |e|}$.

3. Optimization Objective and Iterative Algorithm

PropHunt’s primary optimization objective is the minimization of $P_L(C; p)$, with circuit depth $\mathrm{depth}(C)$ as a secondary criterion: $$F(C) = w_{\mathrm{err}} P_L(C; p) + w_{\mathrm{depth}}\,\mathrm{depth}(C), \quad w_{\mathrm{err}} \gg w_{\mathrm{depth}}$$ Rather than simulating the full logical error at each step, PropHunt employs ambiguity elimination within the decoding graph as a proxy.

Search Algorithm Overview

The optimization proceeds iteratively:

1. Build or update the decoding graph from the current $H(C)$ and $L(C)$.
2. Sample small, connected subgraphs to find ambiguous logical-error patterns.
3. For each ambiguous subgraph, solve a MaxSAT instance to find a minimum-weight ambiguous fault.
4. Enumerate local circuit transformations (CNOT reorderings/reschedulings) that would resolve the ambiguity.
5. Select and apply the most effective transformation that preserves commutation and minimizes circuit depth.

Core Pseudocode

Input: initial SM circuit C₀, iterations T, samples per iter S C ← C₀ for t in 1…T do G ← build_decoding_graph(H(C), L(C)) BestMove ← none, BestDepth ← ∞ for s in 1…S do subgraph ← sample_connected_subgraph(G) if ambiguous(subgraph): e⋆ ← solve_MinWeightLogicalError(subgraph) # MaxSAT candidates ← enumerate_moves(C, e⋆) for move in candidates: if valid(move,C) and removes_ambiguity(move,subgraph): d ← depth(apply(C,move)) if d < BestDepth: BestMove ← move BestDepth ← d if BestMove ≠ none: C ← apply(C, BestMove) else: break return C

Each operation is designed to be local, preserves code correctness, and is checked efficiently for ambiguity elimination by partial recomputation of $H$ and $L$.

4. Local Circuit Transformations

PropHunt supports two key classes of transformations:

• Reordering (Within One Stabilizer):

For a stabilizer ancilla $s$ interacting with data qubits $(q_1, ..., q_w)$ via CNOTs, the ordering of these gates can be permuted. For $$C_s = \cdots\,\text{CNOT}(s, q_i)\,\text{CNOT}(s, q_j)\cdots$$, swapping positions of CNOTs can adjust the overlap of hook-errors with logical operators.

• Rescheduling (Between Two Stabilizers):

When ancillas $s_1, s_2$ both couple to the same data qubit $q$, the order of CNOTs can be altered. If $s_1$ ($X$-type) and $s_2$ ($Z$-type) need to swap CNOTs on $q$, one additional shared qubit must also be rescheduled to maintain overall stabilizer commutativity.

Both moves are local, affect $O(w)$ gates, and are verified rapidly for ambiguity elimination in the decoding graph.

5. Benchmarking and Performance Analysis

PropHunt is evaluated across a range of code families:

• Surface codes: distances $d \in \{3, 5, 7, 9\}$
• Lifted-Product (LP) codes: $[[39, 3, 3]]$, $[[54, 11, 4]]$
• Random-Quantum-Tanner (RQT) codes: $[[60, 2, 6]]$, $[[108, 18, 4]]$

Compared to baseline “coloration” circuits (as in Tremblay et al. 2022) at a gate error rate $p = 0.1\%$, PropHunt achieves:

• Reductions in logical error rate $P_L(C^*)$ by $2.5$–$4\times$ for LP and RQT codes.
• Automatic recovery of hand-tuned surface code scheduling, matching effective code distance ($d_{\mathrm{eff}} = d$).
• Circuit depth increases of at most $10\%$ in the worst case, with this overhead often being acceptable in measurement-limited hardware scenarios.

MaxSAT bottlenecks are alleviated by restricting to subgraph-based sampling: global MaxSAT over $H, L$ may involve tens of thousands of variables, but subgraph-based MaxSAT instances only scale as $O(d_{\mathrm{eff}}^2)$ and solve in $1$–$2$ seconds per core.

Code Family	Baseline Logical Error Rate	PropHunt Logical Error Reduction	Max Depth Increase
LP, RQT codes	$P_L$(baseline)	$2.5$–$4\times$	$\leq 10\%$
Surface codes	$d_{\mathrm{eff}} < d$	$d_{\mathrm{eff}} = d$	Minimal

6. Fine-Grained Zero-Noise Extrapolation via Hook-ZNE

PropHunt enables a new approach to ZNE, termed Hook-ZNE. Traditional ZNE strategies in QEC involve circuit folding, distance scaling, or hardware-specific tuning, each with coarse or hardware-limited control over logical error rates. In contrast, PropHunt produces SM circuits with a continuous range of logical error rates at fixed code distance by controlling the degree to which ambiguities are eliminated.

The suppression factor is: $$\Lambda = (P_{\mathrm{th}} / p), \quad P < P_{\mathrm{th}}, \quad P_L(d) \approx \Lambda^{-\lceil d/2 \rceil}$$ By only partially resolving ambiguities, effective code distance can be tuned fractionally: $d_{\mathrm{eff}} = d - \delta$ for $0 \leq \delta \leq 1$, with corresponding logical error $$P_L(\alpha) \approx \Lambda^{-\lceil (d - \delta)/2 \rceil}$$.

Hook-ZNE runs logical measurements at a set of $(\delta_i)$, fits $\langle A \rangle_i$ to a model, and extrapolates to $\delta=0$. This approach produces lower $L_1$-bias in observable estimation under the same resource budget compared to distance-scaling ZNE, due to fine-grained logical error tuning that avoids exposing the decoder to high-variance, low-distance regimes.

7. Limitations and Prospects for Extension

PropHunt is limited to CSS stabilizer codes; generalization to non-CSS or subsystem codes would require extensions to the move set and more comprehensive commutation-preservation checks. The noise model is assumed to be standard independent Pauli depolarizing; correlated or coherent noise scenarios may necessitate enhanced ambiguity analysis. The algorithm, as formulated, does not introduce flag ancillas or extra helper qubits, which may remain necessary for some codes to maintain full distance.

Potential extensions include:

• Generalizing to non-CSS or subsystem codes.
• Incorporating flag-ancilla moves to enhance $d_{\mathrm{eff}}$ for certain codes.
• Integrating with hardware-aware compilers to ensure compliance with specific connectivity and timing constraints.
• Joint optimization of SM circuits with higher-level logical protocols, such as interleaved $T$-gate distillation, to further minimize overall resource requirements.

PropHunt presents the first general-purpose automated approach specifically designed to optimize logical performance of CSS SM circuits at the gate level, demonstrating effectiveness across surface, LP, and RQT codes, and providing a foundation for advanced error mitigation strategies such as Hook-ZNE (Viszlai et al., 24 Jan 2026).