CQM: Cyclic Qubit Mappings

1. Problem Statement

The paper addresses the challenge of hardware heterogeneity and uncertainty in Noisy Intermediate-Scale Quantum (NISQ) devices and future fault-tolerant quantum computers utilizing Surface Codes.

• Spatial and Temporal Variance: Physical qubits exhibit non-uniform error rates that vary across the chip (spatial) and over time (temporal). These variations arise from factors like Two-Level System (TLS) defects, leakage, and burst errors.
• Uncertainty in Logical Error Rates (LER): Because physical error rates fluctuate and are difficult to track in real-time (calibration is slow and cannot occur during execution), the resulting Logical Error Rate of a specific surface code tile is often unknown during program execution.
• Failure of Static Mappings: Current compilation strategies rely on static mappings, where logical qubits are assigned to specific hardware tiles for the duration of the program. If a compiler inadvertently maps a logical qubit to a "bad" tile (one with high error rates or burst errors) due to lack of real-time data, the program may fail. Conversely, relying on historical data is unreliable as hardware states drift.
• Leakage Accumulation: Physical qubits can leak into higher energy states (e.g., $|2\rangle, |3\rangle$), which standard error correction cannot fix. Without periodic resetting, leakage accumulates, degrading performance.

2. Methodology: Cyclic Qubit Mappings (CQM)

The authors propose Cyclic Qubit Mappings (CQM), a dynamic compilation and runtime strategy that mitigates hardware heterogeneity by continuously reshuffling the positions of logical qubits.

• Core Concept: Instead of fixing a logical qubit to a single tile, CQM moves logical qubits around the available hardware topology during idle periods. By ensuring every logical qubit spends an equal amount of time on every available tile, the system enforces an average Logical Error Rate (LER) for every qubit.
• Mechanism via Lattice Surgery:
  • The approach utilizes lattice surgery operations inherent to Surface Codes.
  • Movement: Logical qubits (represented as $d \times d$ patches) can be moved by expanding the patch into adjacent ancilla space and measuring the old space. This takes 1 code cycle.
  • Edge Rotation: To facilitate movement or interaction, the boundaries (X and Z edges) of the tiles can be rotated using adjacent ancilla, taking 3 code cycles.
  • Ancilla Requirements: Movement requires a contiguous channel of ancilla qubits. The paper analyzes occupancy constraints:
    • Low Occupancy ($o \leq 0.5$): All qubits can move every cycle.
    • High Occupancy ($o > 0.5$): Some qubits must stall while others move, but over time, equal occupancy is still achievable.
• Leakage Mitigation: The movement process inherently involves measuring and resetting the original physical qubit patch. This effectively flushes leakage errors without needing dedicated "Leakage Reduction Circuits."
• Compilation Strategy: The compiler generates a sequence of mappings $\phi(t)$ rather than a single static map. It schedules these movements during idle times to minimize execution time overhead.

3. Key Contributions

1. Identification of Uncertainty Risks: The authors demonstrate that spatial and temporal variations in physical error rates create significant uncertainty in Logical Error Rates. They show via IBM Kyoto hardware data that static mappings can inadvertently select worst-case scenarios (mapping to high-error tiles) because the compiler cannot predict future hardware states.
2. Proof of Concept for Average Case Guarantee: Through mathematical modeling, the paper proves that dynamic remapping guarantees an average-case LER.
   • Example: If a qubit spends 50% of its time on a "good" tile ($p_{L,low}$) and 50% on a "bad" tile ($p_{L,high}$), its success probability approaches $(1-p_{L,low})^{T/2}(1-p_{L,high})^{T/2}$. This is significantly more robust than being stuck on the bad tile for the entire duration.
3. CQM Framework: The proposal of a specific compilation framework that integrates cyclic movement into the scheduling process.
4. Resource Efficiency Analysis: The paper argues that CQM is more resource-efficient than simply increasing the code distance ($d$) to combat errors. Increasing $d$ scales the physical qubit requirement quadratically ($2d^2-1$), whereas CQM utilizes existing spare ancilla space to average out errors with minimal overhead.

4. Results and Analysis

• Empirical Data: Using 30 days of calibration data from the IBM Kyoto processor, the authors simulated Logical Error Rates. The results showed significant fluctuation in LER over time, with many rates exceeding fault-tolerant thresholds. This validates the premise that static mapping is risky.
• Performance Overhead:
  • The movement of logical qubits is abstracted as taking 1 code cycle for translation and 3 cycles for edge rotation.
  • The paper argues that by scheduling these moves during qubit idling time, the execution time overhead is minimal.
  • In high-occupancy scenarios, "rotation stalls" may occur, but the system still converges to an equal distribution of time across all tiles.
• Comparison to Alternatives:
  • vs. Static Mapping: CQM avoids worst-case scenarios caused by unknown hardware states.
  • vs. Increasing Code Distance: CQM achieves error mitigation without the severe hardware overhead (quadratic increase in physical qubits) required to increase the code distance $d$.

5. Significance

• Robustness against Hardware Drift: CQM provides a software-level solution to hardware instability, making quantum programs more resilient to burst errors, leakage, and calibration drift without requiring perfect real-time hardware characterization.
• Feasibility for Near-Term Architectures: As quantum hardware improves but remains imperfect, CQM offers a path to fault tolerance that leverages the inherent flexibility of Surface Code lattice surgery.
• Paradigm Shift: The paper shifts the compilation paradigm from "find the best static mapping" to "ensure fair distribution of risk," fundamentally changing how logical qubits are managed in error-corrected systems.
• Leakage Management: It offers a novel, low-overhead method for resetting physical qubits to mitigate leakage errors, a known bottleneck in long-running quantum computations.

In conclusion, CQM represents a strategic evolution in quantum compilation, moving from static resource allocation to dynamic, cyclic management to guarantee average-case performance in the face of unpredictable hardware noise.