LUCI on IBM Hardware: Error Suppression with Almost Half Syndrome Density

Technical Summary: LUCI on IBM Hardware

Problem Statement
Scalable fault-tolerant quantum computation requires logical qubits that can preserve their state over extended execution times. While the surface code is the most practical Quantum Error Correction (QEC) protocol for locally constrained processors due to its high threshold, traditional implementations rely on static syndrome extraction circuits. These rigid circuits impose strict connectivity constraints and are vulnerable to hardware defects (e.g., non-functional qubits or couplers). Recent theoretical frameworks, such as LUCI (Logical Unitary Circuit Implementation), propose dynamic subroutines that can navigate around defective components by altering measurement schedules. However, this flexibility comes at the cost of reduced temporal distance, requiring multiple rounds to extract a full syndrome. Crucially, these dynamic approaches had not been experimentally demonstrated on physical hardware, nor had their performance been benchmarked against standard static codes in the absence of physical defects, particularly regarding the trade-off of "syndrome density" (the ratio of measured syndrome bits to total possible bits per cycle).

Methodology
The authors experimentally benchmarked the LUCI framework against the standard rotated surface code on the IBM ibm_miami superconducting quantum processor. The study utilized a "reset-free" scenario, where physical qubit reset operations were omitted to avoid idle time and leakage issues, relying instead on classical post-processing to define detectors.

Key methodological steps included:

• Dynamic Scheduling: The LUCI framework was implemented using mid-cycle states, where the circuit alternates between two distinct rounds (a baseline and a variant) to extract the full syndrome. This contrasts with the standard surface code, which extracts the full syndrome in a single round.
• Asymmetric Scaling: To target specific logical errors, the researchers scaled the QEC patches asymmetrically. They tested distance-3 ($d=3$) patches and extended them to rectangular patches with dimensions $(d_x=5, d_z=3)$ to suppress logical X errors, or $(d_x=3, d_z=5)$ to suppress logical Z errors.
• Syndrome Density Analysis: The study quantified "syndrome density" ($\rho$). While the standard surface code maintains a density of 1, the LUCI framework, requiring two rounds for full extraction, achieved a density of approximately 0.6 for $d=3$ patches and 0.588 for the grown patches.
• Hardware Constraints: The experiments were conducted in a defect-free region of the processor. However, the mapping for the standard surface code in the X-basis was forced to utilize a highly noisy coupler (error rate $\sim15\%$) due to rigid connectivity requirements, whereas the flexible LUCI scheduling allowed the avoidance of this specific noisy component.
• Decoding: Logical error rates were decoded using a correlated Minimum Weight Perfect Matching (MWPM) decoder (PyMatching), weighted by calibration data for gates and measurements.

Key Results
The authors compared the error suppression ratios ($\Lambda_{5/3} = \epsilon^r_{d=3} / \epsilon^r_{d=5}$) between the standard surface code and the LUCI framework:

• Logical X Errors: The LUCI framework demonstrated superior error suppression with a ratio of 1.75(10), compared to the standard surface code's 1.58(13). This improvement is attributed to LUCI's ability to avoid the highly noisy coupler that the standard code was forced to use.
• Logical Z Errors: The standard surface code showed higher suppression for Z errors (2.44(7)) compared to LUCI (1.93(12)).
• Overall Performance: Despite the LUCI framework operating with nearly half the syndrome density in time (requiring two rounds for full syndrome extraction), it remained competitive with the standard rotated surface code.
• Noise Inhomogeneity: The results highlighted that standard syndrome extraction circuits are not always optimal, even in defect-free regions, when hardware noise is inhomogeneous. The dynamic scheduling of LUCI successfully bypassed a specific noisy component, yielding better overall logical error rates for targeted errors while preserving logical boundaries.

Significance and Claims
The paper claims to bridge the gap between theoretical dynamic codes and practical hardware implementation. Its primary contributions are:

1. Experimental Verification: It provides the first experimental demonstration of the LUCI framework on physical quantum hardware, verifying its feasibility without physical defects.
2. Performance under Reduced Temporal Distance: It challenges the conventional dependency on static fault-tolerant architectures by showing that dynamic codes can outperform standard methods even when operating with reduced temporal syndrome density (halved density).
3. Hardware Compatibility: The work demonstrates that dynamic codes can actively avoid highly noisy components in inhomogeneous hardware environments, offering a viable alternative for maximizing performance on current-generation processors.
4. Reset-Free Implementation: It successfully implements a reset-free detector definition within the LUCI framework, proving that high-performance QEC is possible without relying on physical reset operations.

The authors conclude that these findings pave the way for hybrid, hardware-compatible code designs, suggesting that dynamic syndrome extraction is a practical approach for logical qubit preservation in the presence of hardware noise inhomogeneity.