LUCI Framework: Dynamic Surface-Code Circuits

Updated 5 July 2026

The LUCI framework is a dynamic, mid-cycle syndrome-extraction method for fault-tolerant surface-code circuits that preserves spatial code distance while trading temporal distance.
It uses complementary measurement subroutines—such as baseline and variant rounds—to flexibly navigate hardware constraints like broken couplers and noisy components.
Experimental benchmarks show LUCI achieves substantial improvements in logical error rates and resource efficiency, especially in inhomogeneous superconducting hardware.

The LUCI framework is a recent framework for constructing fault-tolerant, dynamic surface-code circuits in which the usual one-round syndrome-extraction circuit is replaced by complementary measurement subroutines that start and end in the same mid-cycle code space. In the quantum-error-correction literature, LUCI is described as enabling aperiodic and anisotropic syndrome-extraction schedules, preserving the spacelike or full spatial code distance of the surface code in the presence of isolated broken couplers, isolated broken measure qubits, or highly noisy components, while trading this for a reduction in timelike or temporal distance (Debroy et al., 2024, Kim et al., 2 Jul 2026). In the 2026 IBM-hardware demonstration, LUCI is expanded as “Logical Unitary Circuit Injection” (Kim et al., 2 Jul 2026), whereas a later optimization paper uses LUCI as “Layered Unrotated Circuit Intermediate” to emphasize its role as an intermediate representation for schedule synthesis (Anker et al., 11 Dec 2025). Across these formulations, the central idea is consistent: LUCI replaces a static, one-size-fits-all syndrome circuit with a dynamic schedule of valid subroutine rounds that preserve logical boundaries and permit circuit-level adaptation to hardware constraints.

1. Conceptual definition and mid-cycle picture

In the standard rotated surface code, one uses a single four-step CNOT-layer circuit per cycle to measure every $X$ - and $Z$ -type stabilizer exactly once, yielding syndrome density $\rho=1$ (Kim et al., 2 Jul 2026). LUCI instead splits this cycle into complementary rounds. In the IBM-hardware formulation, these are the “baseline” and “variant” rounds; each consists of four CNOT layers plus a measurement layer, and over the two-round cycle the complete stabilizer group is recovered (Kim et al., 2 Jul 2026). In the dropout-oriented formulation, LUCI is built in the mid-cycle picture: the state after the first two CNOT layers is viewed as an unrotated surface-code state on an $\ell\times\ell$ graph, and LUCI rounds take this mid-cycle state back to itself (Debroy et al., 2024).

The framework is explicitly intended to tolerate aperiodic and anisotropic CNOT assignments, to navigate around dropouts without losing full spatial distance, and to remain efficiently decodable through the detecting-region formalism (Debroy et al., 2024). A LUCI circuit is therefore not a single static syndrome-extraction schedule. Instead, the end of each round corresponds to a patch whose stabilizers are interleaved in an aperiodic fashion, while the logical operators are preserved because each mid-cycle or end-cycle state remains a valid distance- $d$ surface-code patch (Kim et al., 2 Jul 2026).

Several equivalent descriptions of LUCI emphasize different aspects of the same construction. One paper presents LUCI diagrams as a tiling of the square lattice into shapes such as $L$ , $U$ , $C$ , and $I$ , each prescribing a fold–measure–reset–unfold circuit fragment (Debroy et al., 2024). Another describes LUCI as an intermediate representation in which gauge operators are mapped to reusable 4- or 2-layer CNOT–measurement–reset subcircuits called shapes, and valid schedules are obtained by choosing which shape measures which operator in which time slice (Anker et al., 11 Dec 2025). This suggests that LUCI is best understood not as one specific circuit, but as a constrained family of syndrome-extraction schedules defined relative to a common mid-cycle code space.

2. Circuit structure, gauge operators, and detector construction

A core feature of LUCI is that each round measures only a subset of the relevant operators. In the two-round surface-code version, the first round measures a subset of the bulk stabilizers plus certain boundary checks, while the second measures the complementary subset (Kim et al., 2 Jul 2026). Over two rounds, all weight-4 and boundary weight-1 checks are reconstructed. In the more general dropout formulation, circuit construction proceeds by choosing mid-cycle gauge operators $\{g_j\}$ , merging anticommuting pairs into super-stabilizers $Z$ 0, assigning shapes to each $Z$ 1, and enforcing local compatibility and four-coloring constraints so that every face is measured once in four rounds without collisions (Debroy et al., 2024).

The detecting-region picture provides the decoding primitive. For a mid-cycle stabilizer generator or gauge operator $Z$ 2, the detecting region is defined as

$Z$ 3

and the corresponding detector is the parity of the measurements at the end of that region,

$Z$ 4

A valid LUCI circuit is then one whose union of detecting regions covers the relevant CNOT layers and measurements such that each weight-1 error flips exactly two detectors (Debroy et al., 2024).

The 2026 IBM demonstration focuses on a reset-free implementation, motivated by the fact that on many superconducting platforms mid-circuit reset is either slow or unavailable (Kim et al., 2 Jul 2026). In that implementation, all qubits—data and ancilla—are measured each round, and no active reset is performed. If $Z$ 5 is the ancilla measurement of stabilizer $Z$ 6 in round $Z$ 7, and the support of the contracted version of that stabilizer in the previous round lay on data qubits $Z$ 8, the detector is

$Z$ 9

At the first round, one takes $\rho=1$ 0, and in the last round one XORs in the final data-qubit measurements to close the parity check (Kim et al., 2 Jul 2026). In practice, two consecutive LUCI rounds suffice to build every detector in spacetime, exactly as two cycles suffice in a reset-based standard code (Kim et al., 2 Jul 2026).

3. Distance trade-offs, syndrome density, and anisotropic scaling

The defining trade-off in LUCI is between space and time. Over the full LUCI cycle, the complete stabilizer group is recovered, so the space-time distance remains $\rho=1$ 1 and the full spatial code distance is preserved; however, because each stabilizer is measured only in one of the complementary rounds, the temporal distance is effectively reduced, asymptotically by a factor of about two in the two-round construction (Kim et al., 2 Jul 2026). For isolated broken couplers or isolated broken measurement qubits, the dropout analysis states this as

$\rho=1$ 2

in contrast with static-code dropout methods that typically reduce both spacelike and timelike distance (Debroy et al., 2024).

The same trade-off appears in the syndrome density. For a rectangular LUCI patch labeled by $\rho=1$ 3, the syndrome density is

$\rho=1$ 4

which gives $\rho=1$ 5 as $\rho=1$ 6 (Kim et al., 2 Jul 2026). In the IBM experiments, the explicit values compared to the standard code are: Standard $\rho=1$ 7; LUCI $\rho=1$ 8 for a $\rho=1$ 9 patch and $\ell\times\ell$ 0 for $\ell\times\ell$ 1 or $\ell\times\ell$ 2 (Kim et al., 2 Jul 2026). The framework therefore operates with almost half the syndrome density in time while preserving the relevant logical boundaries.

LUCI also supports asymmetrical scaling of $\ell\times\ell$ 3 and $\ell\times\ell$ 4 distances. To target logical- $\ell\times\ell$ 5 suppression, one stretches the patch in the horizontal direction so that $\ell\times\ell$ 6 rather than $\ell\times\ell$ 7; to target logical- $\ell\times\ell$ 8 suppression, one uses $\ell\times\ell$ 9 (Kim et al., 2 Jul 2026). The space-time distance remains $d$ 0, but the asymmetry changes the suppression behavior of the targeted logical Pauli error. This suggests that LUCI can be used not only for defect avoidance but also for basis-selective code shaping under hardware constraints.

A related construction is the diamond circuit family on a Lieb or heavy-square lattice. There, LUCI describes a mid-cycle subsystem surface code in which half the ancillas are dropped out of the grid. The resulting circuits preserve the spacelike distance $d$ 1 but incur a stronger timelike penalty, summarized in that work as $d$ 2 and $d$ 3 when one LUCI round is defined as the time between two measurement layers (Debroy, 14 Feb 2025). The diamond work therefore occupies the same conceptual space as the two-round surface-code LUCI construction, but with a different resource trade-off.

4. Adaptation to defects, dropout, and schedule optimization

The original motivation for LUCI is adaptation to imperfect hardware. When a coupler is missing, LUCI routes entanglement around the hole by locally modifying shapes on adjacent faces; when an isolated measurement qubit is missing, the four adjacent mid-cycle gauge operators are paired into two weight-six super-stabilizers instead of removing data qubits (Debroy et al., 2024). The stated consequence is that isolated broken couplers or isolated broken measure qubits no longer force the same spatial-distance penalty found in prior static routines.

Quantitatively, for qubit and coupler dropout rates of $d$ 4 and a patch diameter of $d$ 5, LUCI achieves an average spacelike distance of $d$ 6, compared to $d$ 7 for the prior best methods (Debroy et al., 2024). Under the SI1000(0.001) noise model, that translates to a 36x improvement in median logical error rate per round, and at those dropout and error rates LUCI requires roughly 25% fewer physical qubits to reach one-in-a-trillion logical codeblock error rates (Debroy et al., 2024). These are among the clearest quantitative statements of LUCI’s architectural significance in the dropout regime.

Later work treats LUCI as a fully parameterized intermediate representation rather than a single hand-designed prescription. In that encoding, each gauge operator $d$ 8 is assigned a small set $d$ 9 of admissible shapes, Boolean variables $L$ 0 specify whether shape $L$ 1 measures operator $L$ 2 at time slice $L$ 3, and auxiliary variables $L$ 4 record whether operator $L$ 5 is measured at time $L$ 6 (Anker et al., 11 Dec 2025). An integer linear program then imposes shape-compatibility, coverage, and superstabilizer-completeness constraints while minimizing a linear proxy objective

$L$ 7

with $L$ 8, $L$ 9, $U$ 0, and $U$ 1 in the reported experiments (Anker et al., 11 Dec 2025).

On a distance-11 surface code with Stim+SI1000 noise at $U$ 2 physical error and $U$ 3 rounds per cycle, adding weight-1 gauges and spike trimming yields a logical-error-rate geometric-mean reduction of $U$ 4 at $U$ 5 dropout and $U$ 6 at $U$ 7 dropout, while subsequent ILP schedule optimization adds a further $U$ 8 and $U$ 9 reduction, for a total improvement of 14.5% and 23.6% over naive $C$ 0-round extraction (Anker et al., 11 Dec 2025). The same study reports that attempts to maximize measurements alone can increase logical error rate by up to 5.5x, and that three-round LUCI schedules, although they exist for about 95% of the $C$ 1-dropout cases and 76% of the $C$ 2-dropout cases, increase logical error rate by 45% and 8.1% respectively when compared on equal gate depth (Anker et al., 11 Dec 2025). A plausible implication is that LUCI’s usefulness depends not only on dynamic measurement itself, but on careful balancing of detector volume, stretch, and skip penalties.

5. Experimental realization on IBM hardware

The first physical-hardware benchmark of LUCI reported in the supplied material uses the heavy-hexagonal device ibm_miami (Kim et al., 2 Jul 2026). Calibration data showed two-qubit gate errors of order $C$ 3 and readout errors of order $C$ 4, except for one particularly noisy coupler in the $C$ 5-basis patch at approximately $C$ 6 (Kim et al., 2 Jul 2026). Both the standard rotated surface code and LUCI were mapped onto overlapping qubit sets to keep the comparison fair.

In the standard code, the $C$ 7 $C$ 8 patch was forced to use the bad coupler. In LUCI, the corresponding ancilla could be omitted in one of the two rounds, thereby avoiding the noisy link while preserving the logical boundary (Kim et al., 2 Jul 2026). The reported resource summary is specific: the standard $C$ 9 patch used 29 qubits, 44 couplers, and cycle time $I$ 0; the LUCI $I$ 1 patch used 35 qubits, 50 couplers, and cycle time $I$ 2 over two rounds (Kim et al., 2 Jul 2026). All data qubits idle during ancilla measurements received XY4 dynamical decoupling to suppress idle errors (Kim et al., 2 Jul 2026).

The experiment prepared $I$ 3 or $I$ 4, ran up to $I$ 5 rounds, and decoded with Minimum-Weight Perfect Matching (PyMatching) (Kim et al., 2 Jul 2026). The logical-error probability was fit to

$I$ 6

which defines the per-round logical error rate $I$ 7, and the suppression ratio between a $I$ 8 patch and a stretched $I$ 9 patch in the targeted basis was defined as

$\{g_j\}$ 0

The fitted per-round logical error rates and suppression ratios are as follows (Kim et al., 2 Jul 2026):

Framework and basis	$\{g_j\}$ 1, $\{g_j\}$ 2	$\{g_j\}$ 3
Standard, $\{g_j\}$ 4 basis	$\{g_j\}$ 5, $\{g_j\}$ 6	$\{g_j\}$ 7
Standard, $\{g_j\}$ 8 basis	$\{g_j\}$ 9, $Z$ 00	$Z$ 01
LUCI, $Z$ 02 basis	$Z$ 03, $Z$ 04	$Z$ 05
LUCI, $Z$ 06 basis	$Z$ 07, $Z$ 08	$Z$ 09

These data support two distinct conclusions. First, despite operating at nearly half the syndrome density in time, LUCI achieved clear error suppression in both bases (Kim et al., 2 Jul 2026). Second, LUCI outperformed the standard implementation for logical- $Z$ 10 suppression in the case where the standard code was forced to use the high-error coupler, whereas the standard approach remained stronger for logical- $Z$ 11 suppression when no comparably bad component was involved (Kim et al., 2 Jul 2026). The hardware demonstration therefore does not claim uniform superiority; rather, it verifies that dynamic codes can outperform standard methods when hardware inhomogeneity is the dominant constraint.

Within the quantum-error-correction literature, LUCI has been used to describe more than one closely related construction. The dropout paper presents LUCI as a general framework for fault-tolerant, aperiodic, anisotropic surface-code circuits built from detecting regions and mid-cycle gauge operators (Debroy et al., 2024). The IBM-hardware paper uses the term for the two-round baseline/variant subroutine construction and emphasizes reset-free experimental implementation on superconducting hardware (Kim et al., 2 Jul 2026). The optimization paper reinterprets LUCI explicitly as an intermediate representation over which ILP compilation can search a large family of valid schedules (Anker et al., 11 Dec 2025). The diamond-circuit work uses LUCI to specify subsystem-code circuits on the Lieb lattice with half the ancillas removed, emphasizing qubit, coupler, and control-line reductions at the expense of a stronger time overhead (Debroy, 14 Feb 2025).

This range of usage can create a misconception that LUCI denotes one fixed syndrome-extraction circuit. The published descriptions instead indicate that LUCI is a framework or IR that supports multiple circuit families, provided they begin and end in the same mid-cycle code space and preserve the required logical structure (Debroy et al., 2024, Anker et al., 11 Dec 2025). Another possible misconception is that LUCI is only a defect-avoidance technique. The IBM study explicitly argues otherwise by demonstrating a benefit from avoiding a highly noisy component even without physical defects (Kim et al., 2 Jul 2026).

The acronym itself is also overloaded outside quantum error correction. LUCI is the name of a Python package for SITELLE spectral analysis (Rhea et al., 2021) and of a spectral line-fitting pipeline using CNN and mixture-density-network initialization for IFU spectroscopy (Rhea et al., 2021). Those uses are unrelated to the surface-code framework. In the quantum-computing context, LUCI specifically refers to the family of dynamic, mid-cycle constructions summarized above.

Taken together, the available papers define LUCI as a framework for hardware-compatible, dynamic code design in which measurement schedules can be reshaped around defects, noisy couplers, or resource constraints while preserving logical boundaries and full spatial distance. The consistent technical theme is the deliberate exchange of temporal measurement density for architectural flexibility, with the experimental and numerical results indicating that, in inhomogeneous hardware regimes, this trade can be favorable (Debroy et al., 2024, Kim et al., 2 Jul 2026).