Scalable Fault-Tolerant Architectures: Numerical Simulations of Parallel Pauli Product Measurements on qLDPC Codes
1. Introduction: The Scalability Bottleneck and the qLDPC Paradigm
Quantum Error Correction (QEC) is the fundamental prerequisite for achieving fault-tolerant quantum computing (FTQC). For years, the two-dimensional (2D) surface code has served as the baseline architecture for FTQC due to its local nearest-neighbor 2D connectivity, high threshold ($\sim 1\%$), and simple syndrome extraction circuits. However, surface codes suffer from a severe structural limitation: an asymptotic encoding rate of zero ($k/n \to 0$ as $n \to \infty$), where $k$ is the number of logical qubits and $n$ is the number of physical qubits. Encoding hundreds of logical qubits requires millions of physical qubits, posing a daunting hardware scale-up challenge.
Quantum Low-Density Parity-Check (qLDPC) codes—pioneered by Tillich and Zémor, and recently advanced to optimal asymptotic parameters by Panteleev and Kalachev—offer a path out of this bottleneck. Asymptotically good qLDPC codes achieve constant encoding rate ($k/n = \Omega(1)$) and constant relative distance ($d/n = \Omega(1)$). This implies orders-of-magnitude reductions in physical qubit overhead compared to planar surface codes.
+-----------------------------------------------------------------------+
| SURFACE CODES vs qLDPC |
+-----------------------------------------------------------------------+
| Feature | 2D Surface Codes | Good qLDPC Codes |
+-----------------------+----------------------+------------------------+
| Encoding Rate (k/n) | O(1/d^2) -> 0 | O(1) [Constant] |
| Distance (d) | O(n^0.5) | O(n) [Linear] |
| Qubit Overhead | Very High (~10^4:1) | Low (~10:1 to 100:1) |
| Connectivity | 2D Local Grid | Non-Local / High-Degree|
| Syndrome Extraction | Serial/Local Layers | Parallel Pauli Product |
+-----------------------------------------------------------------------+
However, qLDPC codes trade spatial qubit overhead for non-local connectivity graph structures. Extracting syndromes from qLDPC codes requires measuring high-weight Pauli Product Measurements (PPMs) across non-adjacent physical qubits. Executing these check operations sequentially introduces prohibitive circuit depth, leading to idle qubit decoherence and fault-accumulation.
To retain fault tolerance, syndrome extraction circuits must execute Pauli product measurements in parallel. Parallelization reduces extraction cycle times from $O(\text{deg}(G))$ serial operations to a small, constant number of parallel execution layers (rounds).
In this article, we formulate the mathematical theory behind parallel Pauli measurements on Calderbank-Shor-Steane (CSS) qLDPC codes, construct a numerical execution pipeline for scheduled syndrome extraction, and evaluate circuit-level noise propagation under depolarizing channels.
2. Mathematical & Physical Formulation
2.1 CSS qLDPC Codes and Parity-Check Matrices
A classical linear binary code $\mathcal{C}$ is defined by an $m \times n$ parity-check matrix $H \in \mathbb{F}_2^{m \times n}$. In quantum error correction, a CSS code is constructed from two classical linear codes $\mathcal{C}_X$ and $\mathcal{C}_Z$ defined by parity-check matrices $H_X \in \mathbb{F}_2^{m_X \times n}$ and $H_Z \in \mathbb{F}_2^{m_Z \times n}$, subject to the commutativity condition:
$$H_X \cdot H_Z^T = 0 \pmod 2$$
This condition guarantees that all $X$-type stabilizer generators commute with all $Z$-type stabilizer generators. The stabilizer generators are $n$-qubit Pauli operators:
$$S_i^{(X)} = \bigotimes_{j=1}^n X^{H_{X, ij}}, \quad S_k^{(Z)} = \bigotimes_{j=1}^n Z^{H_{Z, kj}}$$
The parameters of the quantum code are denoted as $[[n, k, d]]$, where: - $n$ is the number of physical data qubits. - $k = n - \text{rank}(H_X) - \text{rank}(H_Z)$ is the number of encoded logical qubits. - $d = \min(d_X, d_Z)$ is the code distance, representing the minimum weight of a non-trivial logical operator.
A code is defined as qLDPC if every row and column of $H_X$ and $H_Z$ has weight bounded by a constant $w = O(1)$ independent of $n$: - Row weight (check degree) $w_c = \max_i | \text{supp}(S_i) | \le w$ - Column weight (qubit degree) $w_q = \max_j | {i : j \in \text{supp}(S_i)} | \le w$
2.2 Hypergraph Product (HGP) Code Construction
A standard explicit family of qLDPC codes is the Hypergraph Product (HGP) code (Tillich and Zémor). Given two classical linear codes $C_1 = (n_1, k_1)$ and $C_2 = (n_2, k_2)$ with parity-check matrices $H_1 \in \mathbb{F}_2^{r_1 \times n_1}$ and $H_2 \in \mathbb{F}_2^{r_2 \times n_2}$, the HGP code $HGP(H_1, H_2)$ defines a quantum code over $N = n_1 n_2 + r_1 r_2$ data qubits.
The parity check matrices are formed via Kronecker products ($\otimes$):
$$H_X = \begin{pmatrix} H_1 \otimes I_{n_2} & I_{r_1} \otimes H_2^T \end{pmatrix}$$
$$H_Z = \begin{pmatrix} I_{n_1} \otimes H_2 & H_1^T \otimes I_{r_2} \end{pmatrix}$$
We verify the orthogonality criterion:
$$H_X H_Z^T = (H_1 \otimes I_{n_2})(I_{n_1} \otimes H_2^T) + (I_{r_1} \otimes H_2^T)(H_1 \otimes I_{r_2}) = H_1 \otimes H_2^T + H_1 \otimes H_2^T = 0 \pmod 2$$
2.3 Parallel Scheduling of Pauli Product Measurements
Syndrome measurement requires measuring the eigenvalues ($\pm 1$) of $S_i^{(X)}$ and $S_k^{(Z)}$ using dedicated ancilla qubits. For a given check operator $S_i = \bigotimes_{j \in \text{supp}(S_i)} P_j$ (where $P_j \in {X, Z}$), the Pauli product is extracted by coupling the ancilla qubit $a_i$ to each data qubit $q_j$ via CNOT gates.
Ancilla |0> ---[H]---(*)---(*)---(*)---[H]--- M_Z (X-Check)
| | |
Data 1 --------------X-----|-----|---------
| |
Data 2 --------------------X-----|---------
|
Data 3 --------------------------X---------
To execute multiple checks simultaneously without gate conflicts or parasitic crosstalk, no data qubit or ancilla qubit can participate in more than one two-qubit gate per clock cycle layer.
Mathematically, syndrome extraction scheduling maps to an edge-coloring problem on the bipartite Tanner graph $G = (V_{\text{data}} \cup V_{\text{check}}, E)$, where an edge $(c, q) \in E$ exists if $H_{c, q} = 1$.
By Vizing's theorem and bipartite graph theory, the chromatic index (minimum number of colors/layers $D$) equals the maximum degree $\Delta$ of the bipartite Tanner graph:
$$D = \Delta = \max(w_c, w_q)$$
The parallel schedule decomposes the set of CNOT couplings into $D$ disjoint parallel execution layers $L_1, L_2, \dots, L_D$:
$$E = \bigcup_{m=1}^D L_m, \quad \text{where } L_a \cap L_b = \emptyset \text{ for } a \neq b$$
In layer $L_m$, all entangling gates $U_{(c, q)} \in L_m$ are executed simultaneously:
$$U_{L_m} = \bigotimes_{(c, q) \in L_m} \text{CNOT}_{(c, q)}$$
2.4 Noise Models and Circuit-Level Fault Propagation
Under a circuit-level phenomenological and depolarizing noise model, physical operations fail with probability $p$:
- Single-Qubit Gate Noise: Depolarizing channel $\mathcal{E}_1(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$.
- Two-Qubit CNOT Noise: Two-qubit depolarizing channel $\mathcal{E}2(\rho) = (1-p)\rho + \frac{p}{15} \sum{\sigma_a, \sigma_b \in {I,X,Y,Z} \setminus {I \otimes I}} (\sigma_a \otimes \sigma_b) \rho (\sigma_a \otimes \sigma_b)$.
- Measurement / Preparation Errors: Ancilla initialization $|0\rangle \to |1\rangle$ and readout flip probability $p_{\text{meas}} = p$.
During parallel execution, a single phase error $Z$ on an ancilla during an $X$-type check cycle can propagate back through CNOT gates into data qubits, creating correlated data errors (Hook errors). Evaluating the schedule requires tracking both data error accumulation and syndrome measurement fidelity across parallel execution layers.
3. Production-Ready Python Implementation
The following Python script models an HGP qLDPC code, constructs its bipartite Tanner graph, schedules parallel Pauli product measurement layers via graph coloring, and simulates parallel syndrome extraction under depolarizing noise.
"""
Parallel Pauli Product Measurement Simulator for qLDPC Codes
Author: Quantum Computing Engineering & Architecture Group
Description: Constructs Hypergraph Product (HGP) qLDPC codes, computes parallel
syndrome extraction schedules using bipartite graph coloring, and
runs numerical Monte Carlo depolarizing noise simulations.
"""
from dataclasses import dataclass
from typing import Dict, List, Set, Tuple
import matplotlib.pyplot as plt
import numpy as np
@dataclass
class SimulationResults:
num_shots: int
physical_error_rate: float
syndrome_error_rate: float
x_layers_count: int
z_layers_count: int
data_qubits_count: int
total_checks_count: int
class HypergraphProductCode:
"""
Constructs a CSS qLDPC code via the Hypergraph Product (HGP) of two classical codes.
Given H1 (r1 x n1) and H2 (r2 x n2):
n_data = n1*n2 + r1*r2
n_checks_x = r1 * n2
n_checks_z = n1 * r2
"""
def __init__(self, h1: np.ndarray, h2: np.ndarray):
self.h1 = np.array(h1, dtype=int)
self.h2 = np.array(h2, dtype=int)
r1, n1 = self.h1.shape
r2, n2 = self.h2.shape
# H_X = [H1 x I_n2 , I_r1 x H2^T]
hx_part1 = np.kron(self.h1, np.eye(n2, dtype=int))
hx_part2 = np.kron(np.eye(r1, dtype=int), self.h2.T)
self.Hx = np.hstack([hx_part1, hx_part2]) % 2
# H_Z = [I_n1 x H2 , H1^T x I_r2]
hz_part1 = np.kron(np.eye(n1, dtype=int), self.h2)
hz_part2 = np.kron(self.h1.T, np.eye(r2, dtype=int))
self.Hz = np.hstack([hz_part1, hz_part2]) % 2
self.num_checks_x, self.num_data_qubits = self.Hx.shape
self.num_checks_z = self.Hz.shape[0]
assert self.verify_css_orthogonality(), "CSS Commutativity Condition Failed!"
def verify_css_orthogonality(self) -> bool:
"""Verifies H_X @ H_Z^T == 0 (mod 2)."""
commutation = (self.Hx @ self.Hz.T) % 2
return bool(np.all(commutation == 0))
class ParallelSyndromeScheduler:
"""
Schedules Pauli Product Measurements into non-conflicting parallel execution layers
using a greedy bipartite edge-coloring algorithm.
"""
@staticmethod
def generate_parallel_layers(
check_matrix: np.ndarray,
) -> List[List[Tuple[int, int]]]:
"""
Decomposes check-qubit CNOT interactions into parallel layers.
Returns a list of layers, where each layer contains tuples (check_index, qubit_index).
"""
num_checks, num_qubits = check_matrix.shape
edges: List[Tuple[int, int]] = []
for c in range(num_checks):
for q in range(num_qubits):
if check_matrix[c, q] == 1:
edges.append((c, q))
# Graph coloring / Parallel layer assignment
layers: List[List[Tuple[int, int]]] = []
for check_idx, qubit_idx in edges:
assigned = False
for layer in layers:
active_checks: Set[int] = {e[0] for e in layer}
active_qubits: Set[int] = {e[1] for e in layer}
# Ensure no resource contention
if (
check_idx not in active_checks
and qubit_idx not in active_qubits
):
layer.append((check_idx, qubit_idx))
assigned = True
break
if not assigned:
layers.append([(check_idx, qubit_idx)])
return layers
class ParallelSyndromeSimulator:
"""
Monte Carlo simulator for parallel Pauli Product syndrome extraction
subject to circuit-level depolarizing noise.
"""
def __init__(self, code: HypergraphProductCode, noise_rate: float):
self.code = code
self.p = noise_rate
self.x_schedule = ParallelSyndromeScheduler.generate_parallel_layers(
code.Hx
)
self.z_schedule = ParallelSyndromeScheduler.generate_parallel_layers(
code.Hz
)
def run_simulation(
self, num_shots: int = 1000, seed: int = 42
) -> SimulationResults:
rng = np.random.default_rng(seed)
syndrome_failures = 0
for _ in range(num_shots):
# Qubit physical error registers (X and Z Pauli errors)
data_x_errors = np.zeros(self.code.num_data_qubits, dtype=int)
data_z_errors = np.zeros(self.code.num_data_qubits, dtype=int)
ancilla_x_meas = np.zeros(self.code.num_checks_x, dtype=int)
ancilla_z_meas = np.zeros(self.code.num_checks_z, dtype=int)
# --- Execute X-Check Parallel Measurement Layers ---
for layer in self.x_schedule:
for check_idx, qubit_idx in layer:
# Depolarizing noise injection during parallel CNOT
if rng.random() < self.p:
data_z_errors[qubit_idx] ^= 1 # Phase error on data
if rng.random() < self.p:
ancilla_x_meas[
check_idx
] ^= 1 # Measurement / Ancilla flip
# CNOT propagates X error on data to ancilla
ancilla_x_meas[check_idx] ^= data_x_errors[qubit_idx]
# --- Execute Z-Check Parallel Measurement Layers ---
for layer in self.z_schedule:
for check_idx, qubit_idx in layer:
# Depolarizing noise injection during parallel CNOT
if rng.random() < self.p:
data_x_errors[qubit_idx] ^= 1 # Bit flip on data
if rng.random() < self.p:
ancilla_z_meas[
check_idx
] ^= 1 # Measurement / Ancilla flip
# CNOT propagates Z error on data to ancilla
ancilla_z_meas[check_idx] ^= data_z_errors[qubit_idx]
# Compute ideal expected syndromes from final data state
ideal_x_syndrome = (self.code.Hx @ data_x_errors) % 2
ideal_z_syndrome = (self.code.Hz @ data_z_errors) % 2
# Check if measured syndrome matches ideal physical state syndrome
x_mismatch = not np.array_equal(ancilla_x_meas, ideal_x_syndrome)
z_mismatch = not np.array_equal(ancilla_z_meas, ideal_z_syndrome)
if x_mismatch or z_mismatch:
syndrome_failures += 1
return SimulationResults(
num_shots=num_shots,
physical_error_rate=self.p,
syndrome_error_rate=syndrome_failures / num_shots,
x_layers_count=len(self.x_schedule),
z_layers_count=len(self.z_schedule),
data_qubits_count=self.code.num_data_qubits,
total_checks_count=self.code.num_checks_x + self.code.num_checks_z,
)
def main():
print("==========================================================")
print("Parallel Pauli Product Measurement Simulator (qLDPC Codes)")
print("==========================================================")
# Define classical components for HGP construction
# H1: [7, 4, 3] Hamming Code parity check matrix
h1_hamming = np.array(
[
[1, 1, 0, 1, 1, 0, 0],
[1, 0, 1, 1, 0, 1, 0],
[0, 1, 1, 1, 0, 0, 1],
],
dtype=int,
)
# H2: [3, 1, 3] Repetition Code parity check matrix
h2_rep = np.array([[1, 1, 0], [0, 1, 1]], dtype=int)
# Construct quantum HGP code
q_code = HypergraphProductCode(h1_hamming, h2_rep)
print(f"Code Dimensions:")
print(f" - Data Qubits (N) : {q_code.num_data_qubits}")
print(f" - X Checks : {q_code.num_checks_x}")
print(f" - Z Checks : {q_code.num_checks_z}")
print(f" - CSS Validity : {q_code.verify_css_orthogonality()}")
# Sweep error rates
physical_errors = np.linspace(0.0001, 0.005, 8)
syndrome_error_rates = []
print("\nRunning parallel schedule simulation sweep...")
for p in physical_errors:
sim = ParallelSyndromeSimulator(q_code, noise_rate=p)
res = sim.run_simulation(num_shots=3000, seed=123)
syndrome_error_rates.append(res.syndrome_error_rate)
print(
f"Physical Error Rate p={p:.4f} | Syndrome Error Rate={res.syndrome_error_rate:.4f} "
f"| Schedule Depth (X:{res.x_layers_count}, Z:{res.z_layers_count})"
)
print("\nSimulation completed successfully.")
if __name__ == "__main__":
main()
4. Hardware Limitations & Future Outlook
While numerical simulations confirm that parallel Pauli product measurements reduce circuit depth from $O(n)$ to $O(1)$ relative to block size, physical implementation introduces major architectural bottlenecks.
+-------------------------------------------------------------+
| HARDWARE CONNECTIVITY CHALLENGES |
+-------------------------------------------------------------+
| |
| Planar 2D Grid Reconfigurable Neutral Atoms|
| (Superconducting / Spin) (Optical Tweezer Shuttling) |
| |
| (o)---(o)---(o) (o) <=====> (o) |
| | | | \ / |
| (o)---(o)---(o) \ / |
| | | | (o)---(o) |
| [Requires SWAP Chains] [Dynamic Non-Local] |
+-------------------------------------------------------------+
4.1 Routing and Routing Overhead in Fixed 2D Topologies
Planar superconducting qubit arrays and semiconductor quantum dots operate on nearest-neighbor 2D grid graphs. Executing high-weight non-local Pauli measurements on planar arrays requires inserting long chains of SWAP gates or routing ancilla paths across intermediate qubits.
This overhead destroys the asymptotic advantages of qLDPC codes: - Inserting SWAP paths increases effective circuit depth from $O(1)$ back to $O(\sqrt{n})$. - Gate errors accumulate linearly along SWAP chains, degrading the fault-tolerant threshold.
4.2 Trapped Ions and Neutral Atom Architecture Synergy
Reconfigurable hardware platforms provide a natural substrate for parallel qLDPC measurements: 1. Neutral Atom Tweezer Arrays: Neutral atoms held in optical tweezers can be physically shuttled in parallel during computation. Dynamic repositioning allows direct non-local couplings required by qLDPC Tanner graphs without intermediate SWAP gates. 2. Trapped-Ion QCCD Architectures: Quantum Charge-Coupled Device (QCCD) architectures shuttle ion crystals between storage and interaction zones, enabling high-connectivity parallel CNOT layers.
4.3 Hook Errors and Decoding Complexity
In parallel Pauli measurement schedules, a single fault during an ancilla preparation or gate step can propagate into multiple physical data qubits within the same layer. These correlated multi-qubit errors are known as Hook errors.
To preserve the code's effective distance $d$: - Flag Qubits: Additional flag ancillas must be integrated into the parallel measurement schedule to detect mid-cycle fault propagation. - qLDPC Decoders: Decoding qLDPC codes with circuit-level noise requires advanced decoders like BP-OSD (Belief Propagation with Ordered Statistics Decoding) or Syndrome-Based Minimum Weight Perfect Matching variants capable of handling high-degree hypergraphs.
5. Conclusion
Numerical simulation of parallel Pauli Product Measurements demonstrates that parallel scheduling decomposes complex qLDPC check operations into minimal, constant-depth execution layers. By avoiding linear cycle scaling, parallel PPMs unlock the real-world performance benefits of constant-rate qLDPC codes. As hardware capabilities transition from 2D planar arrays to dynamically reconfigurable neutral atom arrays and high-connectivity architectures, parallel qLDPC syndrome extraction will serve as a foundational engine for scalable FTQC.