---
title: 'LUCI Framework: Dynamic Surface-Code Circuits'
url: https://www.emergentmind.com/topics/luci-framework
type: topic
---

# LUCI Framework: Dynamic Surface-Code Circuits

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 [2410.14891][2607.01887]. In the 2026 IBM-hardware demonstration, LUCI is expanded as **“Logical Unitary Circuit Injection”** [2607.01887], whereas a later optimization paper uses LUCI as **“Layered Unrotated Circuit Intermediate”** to emphasize its role as an intermediate representation for schedule synthesis [2512.10871]. 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$ [2607.01887]. 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 [2607.01887]. 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 [2410.14891].

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 [2410.14891]. 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 [2607.01887].

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 [2410.14891]. 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 [2512.10871]. 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 [2607.01887]. 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** $S_{jk}=g_jg_k$, assigning shapes to each $S_{jk}$, and enforcing local compatibility and four-coloring constraints so that every face is measured once in four rounds without collisions [2410.14891].

The detecting-region picture provides the decoding primitive. For a mid-cycle stabilizer generator or gauge operator $G$, the detecting region is defined as
\[
\mathcal{R}_G \;=\;\bigl\{(q,t)\,\bigm|\;q\in\mathrm{supp}(G\,\mathrm{propagated\ across\ CNOT\ layers\ at\ time}\;t)\bigr\},
\]
and the corresponding detector is the parity of the measurements at the end of that region,
\[
D_G \;=\;\prod_{(q,t)\in\partial^+\mathcal{R}_G} M_{q,t}\,.
\]
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 [2410.14891].

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 [2607.01887]. In that implementation, all qubits—data and ancilla—are measured each round, and no active reset is performed. If $m_{i,j}$ is the ancilla measurement of stabilizer $i$ in round $j$, and the support of the contracted version of that stabilizer in the previous round lay on data qubits $q_l$, the detector is
\[
d_{i,j-1} \;=\; m_{i,j} \;\oplus\; \bigoplus_{\,q_l\in\mathrm{supp}(i)\text{ at round }j-1}\! m_{q_l,j-1}\,.
\]
At the first round, one takes $d_{i,1}=m_{i,1}$, and in the last round one XORs in the final data-qubit measurements to close the parity check [2607.01887]. In practice, two consecutive LUCI rounds suffice to build every detector in spacetime, exactly as two cycles suffice in a reset-based standard code [2607.01887].

## 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 $d$ 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 [2607.01887]. For isolated broken couplers or isolated broken measurement qubits, the dropout analysis states this as
\[
d_s^{(\rm LUCI)} \;=\; d_s^{(0)}\quad,\qquad
d_t^{(\rm LUCI)} \;\approx\;\frac12\,d_t^{(0)}\,,
\]
in contrast with static-code dropout methods that typically reduce both spacelike and timelike distance [2410.14891].

The same trade-off appears in the syndrome density. For a rectangular LUCI patch labeled by $(d_x,d_z)$, the syndrome density is
\[
\rho(d_x,d_z)\;=\;\frac12 \;+\;\frac{d_x+d_z-2}{2\bigl(2\,d_x\,d_z \;+\;d_x+d_z \;-\;4\bigr)}\,,
\]
which gives $\rho\to 1/2$ as $d_x=d_z=d\to\infty$ [2607.01887]. In the IBM experiments, the explicit values compared to the standard code are: Standard $=1.0$; LUCI $=0.6$ for a $3\times3$ patch and $0.588$ for $5\times3$ or $3\times5$ [2607.01887]. The framework therefore operates with almost half the syndrome density in time while preserving the relevant logical boundaries.

LUCI also supports **asymmetrical scaling** of $X$ and $Z$ distances. To target logical-$X$ suppression, one stretches the patch in the horizontal direction so that $(d_x,d_z)=(5,3)$ rather than $(3,3)$; to target logical-$Z$ suppression, one uses $(3,5)$ [2607.01887]. The **space-time** distance remains $d=\min(d_x,d_z)$, 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_s=d$ but incur a stronger timelike penalty, summarized in that work as $d_t^{\rm std}=d$ and $d_t^{\rm dia}=4d$ when one LUCI round is defined as the time between two measurement layers [2502.10355]. 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 [2410.14891]. 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 $1\%$ and a patch diameter of $15$, LUCI achieves an **average spacelike distance** of $13.1$, compared to $9.1$ for the prior best methods [2410.14891]. 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 [2410.14891]. 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 $i$ is assigned a small set $P_i$ of admissible shapes, Boolean variables $v_{t,i,p}\in\{0,1\}$ specify whether shape $p\in P_i$ measures operator $i$ at time slice $t$, and auxiliary variables $f_{t,i}$ record whether operator $i$ is measured at time $t$ [2512.10871]. An integer linear program then imposes shape-compatibility, coverage, and superstabilizer-completeness constraints while minimizing a linear proxy objective
\[
\mathrm{Obj}=-m+\alpha s_2+\beta s_3+\gamma a+\delta b,
\]
with $\alpha=6$, $\beta=5$, $\gamma=12$, and $\delta=2$ in the reported experiments [2512.10871].

On a distance-11 surface code with Stim+SI1000 noise at $0.1\%$ physical error and $4d$ rounds per cycle, adding weight-1 gauges and spike trimming yields a logical-error-rate geometric-mean reduction of $8.2\%$ at $1\%$ dropout and $14.9\%$ at $3\%$ dropout, while subsequent ILP schedule optimization adds a further $6.8\%$ and $10.3\%$ reduction, for a total improvement of **14.5%** and **23.6%** over naive $4d$-round extraction [2512.10871]. 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 $1\%$-dropout cases and **76%** of the $3\%$-dropout cases, increase logical error rate by **45%** and **8.1%** respectively when compared on equal gate depth [2512.10871]. 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** [2607.01887]. Calibration data showed two-qubit gate errors of order $10^{-3}$ and readout errors of order $10^{-2}$, except for one particularly noisy coupler in the $X$-basis patch at approximately $15\%$ [2607.01887]. Both the standard rotated surface code and LUCI were mapped onto overlapping qubit sets to keep the comparison fair.

In the standard code, the $5\times3$ $X$ 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 [2607.01887]. The reported resource summary is specific: the standard $5\times3$ patch used **29 qubits**, **44 couplers**, and cycle time $\approx3.5\,\mu\mathrm{s}$; the LUCI $5\times3$ patch used **35 qubits**, **50 couplers**, and cycle time $\approx7\,\mu\mathrm{s}$ over two rounds [2607.01887]. All data qubits idle during ancilla measurements received **XY4 dynamical decoupling** to suppress idle errors [2607.01887].

The experiment prepared $\ket{0}_L$ or $\ket{+}_L$, ran up to $n=7$ rounds, and decoded with **Minimum-Weight Perfect Matching (PyMatching)** [2607.01887]. The logical-error probability was fit to
\[
p_L(n)\;=\;\tfrac12\Bigl[1-(1-2\epsilon_r)^n\Bigr],
\]
which defines the per-round logical error rate $\epsilon_r$, and the suppression ratio between a $d=3$ patch and a stretched $d=5$ patch in the targeted basis was defined as
\[
\Lambda^{5/3} \;=\;\frac{\epsilon_r(d=3)}{\epsilon_r(d=5)}\,.
\]
The fitted per-round logical error rates and suppression ratios are as follows [2607.01887]:

| Framework and basis | $\epsilon^r_{d=3}$, $\epsilon^r_{d=5}$ | $\Lambda^{5/3}$ |
|---|---:|---:|
| Standard, $X$ basis | $4.25(11)\%$, $1.74(3)\%$ | $1.58(13)$ |
| Standard, $Z$ basis | $7.54(58)\%$, $4.76(12)\%$ | $2.44(7)$ |
| LUCI, $X$ basis | $9.02(30)\%$, $4.67(24)\%$ | $1.75(10)$ |
| LUCI, $Z$ basis | $3.11(3)\%$, $1.77(10)\%$ | $1.93(12)$ |

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 [2607.01887]. Second, LUCI outperformed the standard implementation for logical-$X$ 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$ suppression when no comparably bad component was involved [2607.01887]. 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.

## 6. Related constructions, terminology, and scope

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 [2410.14891]. The IBM-hardware paper uses the term for the two-round **baseline/variant** subroutine construction and emphasizes **reset-free** experimental implementation on superconducting hardware [2607.01887]. The optimization paper reinterprets LUCI explicitly as an **intermediate representation** over which ILP compilation can search a large family of valid schedules [2512.10871]. 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 [2502.10355].

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 [2410.14891][2512.10871]. 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** [2607.01887].

The acronym itself is also overloaded outside quantum error correction. **LUCI** is the name of a Python package for SITELLE spectral analysis [2108.12428] and of a spectral line-fitting pipeline using CNN and mixture-density-network initialization for IFU spectroscopy [2111.12755]. 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 [2410.14891][2607.01887].

Source: https://www.emergentmind.com/topics/luci-framework