From Monolithic to Modular: Surface Codes & GHZ States

Introduction

Quantum error correction (QEC) is the cornerstone of fault-tolerant quantum computing, enabling us to suppress errors beyond the physical noise rates of our hardware. The surface code—one of the most practical topological codes—has become the leading candidate for near-term quantum computers due to its relatively high threshold (~0.5%) and local stabilizer structure.

However, a fundamental challenge remains: how do we scale quantum computers when physical qubits are limited in number? The answer lies in modular quantum architectures, where multiple smaller quantum processors are connected via high-fidelity entanglement. This blog post explores the elegant mathematical bridge that converts traditional monolithic surface code circuits into distributed implementations using multipartite Greenberger-Horne-Zeilinger (GHZ) states.

The Monolithic Surface Code

Before discussing distributed implementations, let's briefly review the monolithic setup. In a standard surface code, stabilizer measurements involve four-body or three-body operators acting on neighboring data qubits. For a weight-4 code, the most direct translation, we measure operators like:

\[S_Z = Z_1 Z_2 Z_3 Z_4\]

In the monolithic case, all four data qubits reside on the same quantum processor, and their joint parity is measured using a single auxiliary qubit and local controlled gates. The measurement outcome is deterministic once the syndrome is extracted.

The Challenge of Modularity

In a modular architecture, the four data qubits are spread across different quantum modules, each with:

A single communication qubit (CQ) that can establish optical entanglement with neighboring modules
Multiple memory qubits serving as data or auxiliary qubits
Local two-qubit gates only within the same module

This introduces a critical constraint: we cannot apply global controlled operations across modules. We need a fundamentally different approach to measure multi-qubit stabilizers nonlocally.

Enter the GHZ state.

GHZ States as the Bridge

A 4-qubit GHZ state is defined as:

|\text{GHZ}_4\rangle = \frac{1}{\sqrt{2}}(|0000\rangle + |1111\rangle)

This state exhibits a remarkable property: measuring it in the computational basis reveals perfect correlations among all four qubits. More importantly, a GHZ state can be generated on demand using spin-photon interfaces, creating entanglement between modules without requiring local interactions.

The key insight is this: a multipartite measurement can be decomposed into local measurements on a GHZ state.

The Core Calculation: From Global to Local

Here's where the mathematics becomes elegant. Consider measuring the joint parity $S_Z = Z_1 Z_2 Z_3 Z_4$ on data qubits at modules A, B, C, and D. In the distributed scheme:

Generate a 4-qubit GHZ state on the communication qubits of modules A, B, C, D
Perform local controlled-Z gates between the communication qubit and data qubit at each module: $\text{CZ}_i = \text{diag}(1, 1, 1, -1)\text{ acting on }(c_i, d_i)$ where $c_i$'s are the communication qubits of the modules and $d_i$'s are the data qubits in the modules.
Measure each communication qubit locally in the $X$-basis, obtaining outcomes $m_1, m_2, m_3, m_4 \in \{0, 1\}$
Compute the stabilizer eigenvalue as: $s = m_1 \oplus m_2 \oplus m_3 \oplus m_4$

This is the core calculation. The joint parity measurement outcome is obtained by adding the individual measurement results.

Mathematically, the local CZ gates transform the joint state of the communication and data qubits into:

|\Psi\rangle = \frac{1}{\sqrt{2}} \left( |0000\rangle_c \otimes |\psi\rangle_d + |1111\rangle_c \otimes (Z_1 Z_2 Z_3 Z_4 |\psi\rangle_d) \right)

In this expression, $|\psi\rangle_d$ represents the joint state of the data qubits. By measuring the communication qubits in the $X$-basis, the system is projected into an eigenstate of the global operator $S_Z = Z_1 Z_2 Z_3 Z_4$. The XOR sum of the local measurement outcomes, $m_1 \oplus m_2 \oplus m_3 \oplus m_4$, then provides the stabilizer eigenvalue required for error detection, effectively performing a non-local parity check across the distributed modules. This action projects the data qubits into the codespace with projectors $P = \frac{1}{2}(I \pm S_Z)$. Same argument holds for the $X$-type stabilizers, with CZ gates replaced by CNOT gates with the data qubits as the targets.

Why This Works: The Stabilizer Measurement Circuit

The stabilizer measurement circuit consists of two phases:

Phase 1: GHZ Generation (Probabilistic)

The GHZ state is generated using one of several entanglement schemes:

Emission-based (EM): Bell pairs are generated between modules and then fused together
Reflection (RFL): A photon sequentially scatters off cavity-coupled spins
Carving (CAR): Spin-dependent reflection projects the initial state into a GHZ state

Each scheme has different success rates, fidelities, and timing characteristics. The choice of scheme significantly impacts the error threshold of the code.

Phase 2: Local Measurement (Deterministic)

Once the GHZ state is created, the remaining operations are entirely local:

\text{Circuit: } \text{CZ gates} \rightarrow \text{Measure} \rightarrow \text{XOR add } s \in \{0, 1\}

The Weight-3 Optimization

The paper introduces a clever variant: the weight-3 (WT3) architecture. Instead of requiring a 4-qubit GHZ state, modules are arranged so that each stabilizer involves only 3 modules:

|\text{GHZ}_3\rangle = \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)

s = m_1 \oplus m_2 \oplus m_3

The trade-off: While WT3 requires fewer qubits per GHZ state (reducing entanglement generation overhead), the modular arrangement doubles the number of stabilizer sub-rounds, increasing the QEC cycle time from 4 to 8 layers.

Hardware Performance and Thresholds

The critical question: Can modular implementations achieve fault-tolerant thresholds comparable to monolithic codes?

The research demonstrates that the answer is yes, but it depends critically on the GHZ generation scheme. Here's a comparison of key schemes:

Scheme	NTP*	FP†	Key Advantage
Reflection (RFL)	0.32	0.35	Fast, high fidelity
Cavity Carving	0.01	0.40	Highest FP threshold
Waveguide Carving	—	0.34	Integrated photonics
Emission-based	0.13	—	Low threshold, slow

* NTP: Near-term parameters | † FP: Future parameters | Error thresholds for WT4 architecture

Key insight: Scattering-based schemes (RFL, CAR) significantly outperform emission-based approaches because they:

Avoid slow two-qubit gate fusion required for Bell pair combination
Achieve much higher success rates (e.g., $P_\text{succ} \approx 0.38$ vs. $0.0999$)
Reduce decoherence window through faster GHZ generation

The Path Forward

The mathematics of distributing surface codes via GHZ states is elegant, but practical implementation requires:

High GHZ fidelity: Errors in the GHZ state propagate directly to syndrome measurement errors
High success rate: Probabilistic GHZ generation requires managing cut-off times and coherence
Coherence times: Memory qubits must survive long GHZ generation attempts without decoherence
Photonic efficiency: Optical links connecting modules must achieve high transmission efficiency

With near-term hardware parameters, thresholds around 0.3 are achievable. With modest improvements in coherence times and photonic link quality, thresholds approaching the monolithic limit of ~0.5% become feasible.

Conclusion

The transformation from monolithic to distributed surface code implementations via GHZ states represents a fundamental algorithmic achievement in distributed quantum computing. The core insight—that a global measurement can be decomposed into local measurements on a multipartite entangled state, with outcomes combined through multiplication—provides an elegant solution to the modularity constraint.

As quantum hardware platforms mature toward fully modular architectures (particularly those with efficient spin-photon interfaces like color centers), this protocol will become increasingly important. It bridges the gap between the theoretical promise of modular quantum computing and the practical reality of hardware constraints, opening the path toward scalable, fault-tolerant quantum computation.

Key Takeaway

Distributing stabilizer measurements across quantum modules using GHZ states transforms a global measurement problem into local measurements whose outcomes combine multiplicatively. This elegant decomposition enables fault-tolerant surface codes with comparable thresholds to monolithic implementations, provided that GHZ generation schemes achieve sufficient fidelity and success rates.

From Monolithic to Modular: Converting Surface Codes Using Distributed GHZ Measurements