Circuit-Level Loss Performance of RHG and Foliated Floquet Color Codes in a Compound Photon--Atom Quantum Architecture

arXiv:2609.02428 · quant-ph · Submitted 2026-09-02 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Circuit-Level Loss Performance of RHG and Foliated Floquet Color Codes in a Compound Photon--Atom Quantum Architecture".

Mira: Measurement-based quantum computation (MBQC) proceeds by preparing an entangled resource state, typically a cluster state, and consuming it through single-qubit measurements, which is particularly well suited to photonic architectures.

Kai: First, who's behind it and why it matters.

Paper summary: Kai: So, looking at this paper again, we’ve seen how they compared RHG against FFCC and rFFCC specifically within this compound photon–atom architecture to figure out circuit-level loss performance.

Mira: It boils down to the fact that while RHG has the highest threshold of two point seven five percent under uniform loss, that advantage can be eroded if there's a lot of excess loss on those intermodule CZ connections, which then favors the reduced FFCC in certain scenarios.

Lev: I think what’s compelling here is that they didn't just test one scenario; they looked at different generation schemes too, which suggests this isn't just a theoretical exercise in code comparison.

Kai: And the authors are trying to map this onto real hardware constraints by detailing how photon loss during CZ gates and correlated Pauli errors from bond-loss propagation affect the logical error rate scaling.

Mira: That analysis of the logical error rate scaling, using that formula where LER scales as p/p th beta d, suggests that even though reduced FFCC has a lower intrinsic threshold of thirteen point five percent under an IID loss model, it can become favorable at specific low loss probabilities depending on the active-atom cost per unit distance.

Lev: That resource constraint discussion is crucial for us; if we're building these systems, knowing when the overhead difference between the codes starts paying off in terms of actual qubit count is what matters most for implementation.

Kai: So, in simple terms, this paper shows that you can't just pick a code based on its graph degree alone; you have to consider the hardware-aware resource overhead and the specific loss profile you're dealing with.

Mira: That’s right; the choice between RHG and rFFCC isn't fixed but depends entirely on whether your system suffers more from uniform loss or localized connectivity issues in those CZ connections.

Lev: It provides a solid framework for us to predict how these codes will behave when we start building these systems, especially regarding that scaling exponent beta they found.

Conclusion: Kai: So, we've been looking at how this paper compared three different Measurement-Based Quantum Computation codes—RHG, FFCC, and reduced FFCC—specifically focusing on their performance when running on a compound photon–atom architecture with realistic loss models. Mira, looking at the title of this paper now, "Circuit-Level Loss Performance of RHG and Foliated Floquet Color Codes in a Compound Photon--Atom Quantum Architecture," what do you think that tells us about where the current bottlenecks are in building these systems?

Mira: I think it immediately signals that we need to move past just looking at the theoretical error rates under ideal conditions; they’re explicitly tying circuit-level loss performance directly to the specific hardware setup, which is really important because those physical constraints dictate whether a code actually works or not. Kai, when you look at the authors and what they've done with these codes—RHG versus FFCC—it seems like they are really showing how graph structure isn't the only thing that matters here.

Kai: Exactly; I mean, looking at the actual experiment setup described in this paper, it sounds like they built a system where photons interact with atoms via near-deterministic CZ gates and then tracked all that loss during the process. Lev, from your perspective as someone who has to actually run this on real hardware, what does seeing those specific threshold numbers—like two point seven five percent for RHG compared to thirteen point five percent for the reduced FFCC—mean in terms of feasibility?

Lev: Those thresholds are critical because they give us a concrete metric for how much overhead we can tolerate before the computation breaks down, and it shows that even with a lower intrinsic tolerance like the reduced FFCC, if the hardware is structured right or if you keep your loss low enough, you can still achieve a reasonable threshold. Kai, when you talk about what was actually built and cooled and measured in this study—the generation schemes like bipartite versus STAP—does that physical reality change how we interpret those theoretical thresholds?

Kai: It does; the different generation schemes introduce different types of loss channels, like the bond-loss propagation they modeled, which means a code might look good on paper but fail practically because of how the photons and atoms are physically routed during the sequence. Mira, when you consider that correlation between Pauli errors caused by missing CZ gates—that E Sk = one/two rho + one/two Z Sk rho Z Sk channel—how does that affect your view on the underlying assumptions of those MBQC codes?

Mira: That specific model is what makes it so deep; it shows that the loss isn't just simple independent qubit errors, but a correlated dephasing channel that directly affects the logical integrity based on where in the graph you lose a connection, which pushes our understanding toward more realistic noise models. Lev, if we were to run this on real hardware now, what kind of practical advice would you give about which code is safer when dealing with those intermodule connections having high loss?

Lev: I'd say that for systems where the physical layout means certain CZ connections are inherently noisier than others, the reduced FFCC might be a better starting point because its lower overhead per unit distance could compensate for some of that intrinsic loss tolerance gap. Kai, what do you think is the biggest takeaway from this comparison regarding how we should design our next generation of photon–atom quantum processors?

Quantum Source Labs

quant-ph

Submitted: 2026-09-02

Updated: 2026-10-01

Comments: 20 pages, 15 figures; includes Supplementary Material

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 80/100

The gist: Measurement-based quantum computation (MBQC) proceeds by preparing an entangled resource state, typically a cluster state, and consuming it through single-qubit measurements, which is particularly

Key concepts

Measurement-based quantum computation (MBQC)
MBQC is a method of quantum computation that uses a highly entangled resource state, like a cluster state, and performs computations by making single-qubit measurements on this state. It is particularly well-suited for photonic systems because photons are easy to generate and manipulate.
Circuit-level loss model
This model calculates the probability of errors occurring at every step of the quantum circuit. It accounts for specific hardware losses, such as photon loss during CZ gates or errors caused by bond-loss propagation between gates, allowing researchers to predict how much noise a code can tolerate.
Code Threshold
The threshold is the maximum physical error rate (loss probability) at which a quantum computation can still succeed with high fidelity. A higher threshold means the code is more robust against noise during the computation.

Terminology

Summary

Measurement-based quantum computation (MBQC) proceeds by preparing an entangled resource state, typically a cluster state, and consuming it through single-qubit measurements, which is particularly well suited to photonic architectures. This work compares three MBQC codes—the Raussendorf–Harrington–Goyal (RHG) code, the Foliated Floquet Color Code (FFCC), and the reduced FFCC—within a compound photon–atom architecture featuring near-deterministic photon–atom CZ gates to determine their circuit-level loss performance.

The gist: RHG achieves the highest circuit-level threshold, 2.75%, while sufficiently large intermodule loss on intermodule CZ connections reverses the ordering in favor of reduced FFCC, demonstrating that lower graph degree alone does not determine performance.

Code Comparison and Performance Benchmarks

The study evaluates three MBQC codes: RHG (the canonical three-dimensional cluster-state realization of the surface code), FFCC (inspired by Floquet color codes with a lower degree graph than RHG), and reduced FFCC (rFFCC, which removes syndrome-like qubits and replaces them with local Hadamard operations). The comparison is conducted under an architecture-aware circuit-level loss model that includes photon loss during photon–atom CZ gates, mid-circuit photon loss that can remove subsequent bonds, and correlated Pauli errors on neighboring qubits due to bond-loss propagation. Under an independent and identically distributed (IID) loss model, the thresholds are approximately 25% for RHG, 8.5% for FFCC, and 13.5% for reduced FFCC.

Hardware Architecture and Generation Schemes

The compound photon–atom architecture utilizes a reusable atom–cavity unit cell that generates single photons, implements near-deterministic photon–atom CZ gates, and performs atomic state preparation and measurement. The connectivity is reconfigurable via optical routing, allowing photons to interact sequentially with selected atoms through CZ gates. Two generation schemes are compared:

  1. The bipartite scheme: Each qubit remains either photonic or atomic throughout its entangling sequence, alternating assignments between SL-qubit and data-qubit positions in consecutive layers for RHG and FFCC.

  2. The STAP (State Transfer from Atom to Photon) scheme: A qubit may be transferred from an atom to a photon between entangling gates, allowing qubits to change physical type during the schedule.

Circuit-Level Loss Modeling and Analysis

The circuit-level loss model assigns specific loss probabilities based on the hardware operations: photon generation, photon participation in a CZ gate, STAP (2p), and atomic measurement (2p). Photon initialization is treated as loss-free, while photonic H gates are treated as loss-free. Bond-loss propagation is modeled by assigning conditional probabilities to intervals between scheduled CZ gates, resulting in a correlated dephasing channel where the missing CZ gates generate a correlated Z-error mechanism:

(5) E Sk (ρ) = 1/2 ρ + 1/2 ZSk ρZSk.

Results on Thresholds and Loss Sensitivity

The comparison of circuit-level thresholds reveals that RHG achieves the highest threshold, 2.75%, showing the largest reduction from the IID threshold of 25%. FFCC shows a smaller reduction, consistent with its smallest graph degree. The reversal in ordering is observed when sufficiently large intermodule loss on intermodule CZ connections is introduced; this occurs because RHG has two CZ connections per photon carrying the penalty, compared to one in reduced FFCC.

Logical Error Rate (LER) Scaling and Resource Constraints

The LER scaling analysis uses a graphlike fault distance estimate, where for RHG, it is d = l, and for FFCC/reduced FFCC it is d = l for even l and d = l + 1 for odd l. The LER scales as:

**(1) LER(p, d) = LER(pth) **

p/pth βd

The fitted scaling exponent β is slightly above 1 for all three codes, supporting the graphlike-distance assignments. Under fixed resource budgets (e.g., nearly matched per-layer qubit counts), reduced FFCC becomes favorable at specific low loss probabilities within certain active-atom windows because its lower active-atom cost per unit distance outweighs its lower intrinsic loss tolerance.

Summary of Findings

The study concludes that the benefit of reduced graph degree is not assessed in isolation but must be considered alongside intrinsic IID loss tolerance, generation-scheme details, and hardware-aware resource overhead. The ordering of thresholds changes when intermodule CZ connections carry additional loss, and the preferred code depends on the operating loss probability. While reduced FFCC shows favorable behavior in specific low-loss windows due to its lower overhead, its lower intrinsic IID threshold (13.

Improvements for AI systems

Based on the provided scientific paper, here are specific improvements that could be made to AI systems, categorized by their potential application:

)

) 1. Enhanced Quantum Circuit Synthesis and Resource Allocation for MBQC:

The paper compares different codes (RHG, FFCC, reduced FFCC) and generation schemes (Bipartite vs. STAP). An AI system could be trained on the findings to perform automated circuit synthesis for a given logical computation target.

  • Ability to dynamically select the optimal code and generation scheme based on predicted hardware loss characteristics (e.g., module connectivity/intermodule loss probability, as detailed in Section 3 and Figure 10).

  • Ability to optimize resource allocation (photon/atom assignments) within the chosen scheme to maximize the circuit-level threshold under specific noise models.

  • Ability to predict performance degradation when moving from a standard generation scheme (Bipartite) to an STAP scheme, accounting for the trade-offs between loss during STAP versus bond-loss propagation.

  1. Optimized Quantum Error Correction (QEC) Decoding:

The paper details sophisticated decoding using Minimum-Weight Perfect Matching (MWPM). An AI system can learn from the simulation results to create more robust and faster decoders.

  • Ability to infer the most likely loss locations and bond losses based on detector outcomes, moving beyond simple error models.

  • Ability to adapt the MWPM cost function dynamically based on the specific code geometry (e.g., RHG vs. FFCC) and the correlation surface being probed (logical X vs. logical Y).

  • Ability to handle correlated Pauli errors induced by bond loss propagation (Equation 5), which is a key feature of the proposed model, leading to more accurate syndrome decoding in noisy environments.

  1. Hardware-Aware Fault Tolerance Assessment:

The paper explicitly links code performance to hardware constraints (native gates, connectivity) and loss mechanisms (intramodule vs. intermodule). An AI system can serve as a predictive tool for hardware design.

  • Ability to predict the impact of increasing intermodule loss on the performance ordering between different codes (e.g., when reduced FFCC overtakes RHG).

  • Ability to quantify the cost of physical implementation choices (e.g., choosing bipartite vs. STAP scheme) by predicting changes in logical error rate (LER) and threshold for specific hardware architectures.

  1. Automated Code Design Optimization:

The paper concludes that performance depends on a complex interplay of code degree, loss tolerance, generation scheme, and overhead. An AI system can explore the parameter space to discover novel codes or modified versions thereof.

  • Ability to suggest modifications to existing codes (like reducing graph degree) only when the resulting gain in intrinsic IID tolerance outweighs the increased hardware overhead and geometric changes (as suggested by Figure 12).

  • Ability to identify specific low-loss windows where reduced FFCC is superior, allowing for targeted design choices based on anticipated operational conditions.

  1. Scalability and Resource Management:

The paper analyzes LER scaling with distance and fixed resource budgets. An AI system can optimize the physical layout of quantum processors for long-distance computation.

  • Ability to predict the optimal code choice (RHG vs. reduced FFCC) for a given distance and required resource budget, balancing the need for high threshold against the practical constraints of active-atom count versus qubit count per layer.

  • Ability to optimize the trade-off between code distance and active atom budget under scaling models (Equation 1).

Abstract

A central question for fault-tolerant quantum computing is which quantum error-correcting codes are best suited to a given hardware architecture. Here we compare the Raussendorf--Harrington--Goyal (RHG) code, the Foliated Floquet Color Code (FFCC), and the reduced FFCC in a compound photon--atom architecture that directly generates measurement-based quantum computation (MBQC) resources with near-deterministic photon--atom CZ gates. RHG serves as a natural benchmark, while the FFCC variants allow us to study whether reduced graph degree improves performance under an architecture-aware circuit-level loss model with delayed heralding and correlated bond-loss propagation. We construct two generation schemes compatible with the compound hardware and evaluate circuit-level thresholds under periodic boundary conditions. RHG achieves the highest circuit-level threshold, 2.75%, and its threshold falls below that of reduced FFCC only for large excess loss on intermodule CZ connections. RHG also achieves the lowest logical error rate in most resource-matched comparisons, but some low-loss windows favor reduced FFCC. Overall, we show that when the hardware supports the native gates and connectivity required for MBQC, the benefits of lower graph degree must be weighed against each code's intrinsic IID loss tolerance, generation-scheme details, and hardware-aware resource overhead.

Sources

Related papers