---
title: Walking Cat Architecture
url: https://www.emergentmind.com/topics/walking-cat-architecture
type: topic
---

# Walking Cat Architecture

The Walking Cat architecture defines a comprehensive and practical fault-tolerant quantum computing blueprint for trapped-ion platforms, integrating cat-state-based logical measurements, LDPC code-based quantum error correction, a 2D QCCD micro-architecture, fast streaming decoders, and hierarchical compilation. The architecture is characterized by its use of “cat factories”—dedicated regions producing large entangled cat states as key ancillas—and its compatibility with experimentally demonstrated hardware elements. The approach emphasizes high-throughput, parallelizable operations, and scalability, with configurations enabling hundreds of logical qubits and execution of millions of $T$ gates per day using only thousands of physical qubits [2604.19481].

## 1. Cat States and the Walking Cat Protocol

At its core, the Walking Cat architecture employs cat states—$w$-qubit GHZ-type entangled states 
$$|\mathrm{CAT}_w\rangle = (|0\rangle^{\otimes w} + |1\rangle^{\otimes w})/\sqrt{2}$$ 
—as ancillas for fault-tolerantly measuring multi-qubit Pauli operators $\overline{P} = \prod_{i=1}^w P_i$. Logical measurements proceed via 
(a) entangling each $P_i$-rotated data qubit with a cat ancilla qubit (using CNOT/CZ),
(b) measuring all cat qubits in the $X$ basis, and
(c) evaluating the parity of measurement outcomes.

Cat factories produce cat states via a doubling-tree CNOT circuit in $\lceil \log_2 w \rceil + 1$ rounds, followed by $m$ rounds of $ZZ$-check verification with ancillas. Only cat states passing all checks (rejection probability $\sim (2m+1)\,w\,p$ for $p$ the gate error rate) are distributed for consumption.

The "walking cat" protocol shuttles verified cat qubits under target memory/data blocks along QCCD junctions, merges them for logical measurements, and returns them for possible reuse. For inter-block measurements, two cat states are stitched using Bell pairs generated in Bell factories.

## 2. Quantum LDPC Codes and Error Model

Logical qubits are encoded in quantum LDPC codes with parameters:

- [[70, 6, 9]]: 6 logical qubits, distance 9, code rate $r \approx 0.086$
- [[102, 22, 9]]: 22 logical qubits, distance 9, code rate $r \approx 0.216$

A standard circuit-level noise scaling for code distance $d$ models the logical error per operation as
$$
\epsilon_L \approx A \left( \frac{\epsilon_{\text{phys}}}{\epsilon_{\text{thresh}}} \right)^{(d+1)/2}
$$
with $\epsilon_{\text{phys}}$ the two-qubit physical error rate, $\epsilon_{\text{thresh}}\sim 10^{-3}$ the code threshold, and $A=O(\mathrm{poly}(d))$. At $\epsilon_{\text{phys}}=10^{-4}$, one finds $\epsilon_L \sim 10^{-10}$–$10^{-11}$.

## 3. Fault-Tolerance Protocols

### Syndrome Extraction

The three-ring framework arranges data and ancilla qubits in concentric rings on the 2D QCCD array. Ancillas undergo cyclic shifts along three nested “loops” (short, medium, long) to enact stabilizer CNOTs without all-to-all ion connectivity. Each syndrome-extraction cycle (SEC) combines parallel CNOTs and ancilla shuttling, requiring $\sim 30$ physical-operation cycles (POCs), $200\,\mu$s each, yielding a SEC time of approximately $6\,$ms.

### Decoding

A streaming beam search decoder converts syndrome bits $\mathbf{s}_i$ to detector outcomes $\mathbf{d}_i = \mathbf{s}_i \oplus \mathbf{s}_{i-1}$, rendering the parity-check matrix into a banded staircase form. Using a sliding-window (window size $w=5$, commit size $c=3$), the inner decoder tackles $5\times 10$ block subproblems and commits corrections for three SECs at a time. The achieved logical error rate is within $2\times$ of an optimal global decoder, down to $p = 5\times 10^{-4}$. Latency per SEC is approximately $0.15\,$ms (Q70), $0.40\,$ms (Q102); the 99\%-tile reaction time is $0.54\,$ms (Q70), $1.29\,$ms (Q102).

### Clifford-Frame Tracking

Logical Pauli measurements and Clifford gates are implemented by updating a Clifford-frame matrix $F \in \mathrm{Sp}(2k,2)$ for each block and by measuring appropriate conjugated operators. This Pauli-by-measurement/Clifford-by-frame scheme requires no physical Pauli/Clifford gates.

## 4. Micro-Architecture and Parallelism

The underlying hardware comprises a 2D QCCD chip, partitioned into:

- “Gate” rows for one- and two-qubit RF gates
- “Optical” rows for measurement/reset
- Ion transport junctions for shuttling

Memory blocks organize data, ancilla, and beacon rows in a folded three-ring structure, with each block containing $3n$ qubits plus ten-qubit reservoirs. Cat factories possess four rows of $w/2$ wells for in-place cat state preparation and verification.

Movement strategies include block-swapping (long-ring), cyclic translation of ancillas (medium-ring), and intra-row permutations (short-ring). RF antennas beneath all gate rows enable billion-scale single/two-qubit gate parallelism. Measurement/reset operations in optical rows are pipelined with shuttling.

Cat-state routing involves shuttling batches of $w/2$ qubits under target blocks via vertical injection, accordion-like horizontal transport, and merging. The routing cost for $w=18$, $h=10$ is $\sim 2.7$ POC.

## 5. Compilation, Decoding, and Resource Estimates

A hierarchical compiler (Qualtran/QREF style) expands algorithmic specifications to logical instructions—Pauli preparations, logical measurements (LM1, LM2), frame-tracked Cliffords, and magic-state injections. Magic-state injection/verification employs IS+H primitives (logical $R_y(\pm\pi/4)$ via cat-based $Y\bar{Y}$ measurement).

The decoder operates continuously during SECs, delivering logical outcomes with $<1$ ms latency. 

Representative resource estimates include:

| Instance           | Memory Code         | Magic Factory Code | Logical Qubits | Physical Qubits |
|--------------------|--------------------|-------------------|----------------|-----------------|
| Dense              | $5 \times$ [[102,22,9]] | $1\times$CH₂ [[54,2,10]] | 110            | 2,514           |

Throughput for $T$-gates (double $T$ via paired $H$ states) is $\approx 0.165$ ms latency, yielding $6,000$ $T$-gates/s ($\approx 5\times 10^8$/day). One million $T$-gates/day is supported with $2,500$–$10,000$ physical qubits.

## 6. Application Benchmarks and Performance

The architecture supports quantum simulations and factoring tasks with practical runtimes:

- **Hamiltonian simulation** (100-site Heisenberg model, degree 7): Sixth-order Trotter with 10 steps ($\sim 250$ 2nd-order steps, $\sim 2{,}000$ sequential $2$QZ layers plus controlled-phase estimation). Using $10,000$ physical qubits:
  - 80 sites: $\sim$10 hours
  - 100 sites: $\sim$18 hours
  - 120 sites: $\sim$53 hours
  - Aggregate time for iterative QPE (50 shots): $\sim 1$ month

- **Shor’s algorithm**: Factoring a 30-bit integer (1,071,514,531) requires 34 Q70 and 9 CH₂ codes, runtime $<1$ day. 10/20/40-bit instances require $\sim$1 hour to 2 days, respectively.

Simulation results at $p_{\text{phys}}=10^{-4}$, leakage $10^{-5}$, and loss $10^{-7}$ yield logical errors per SEC of $7 \times 10^{-11}$ (Q70) and $2 \times 10^{-12}$ (Q102).

Magic-state factories:  
- CH₂ in [[54,2,10]] (two $H$-injections, weight-54 Viterbi check): rejection $\sim 2.3$\%, output error $\sim 7\times 10^{-8}$, average $13.4$ SEC/attempt.
- MEK in [[70,6,9]] (ten $H$-injections, 3 Viterbi checks): rejection $\sim 12$\%, output error $\sim 3.6\times 10^{-7}$, average $47.6$ SEC/attempt.

## 7. Architectural Variants and Trade-Offs

Three principal architectural realizations are distinguished:

- **Simple**: single [[70,6,9]] code for both memory and magic state distillation; minimal code diversity but higher magic factory overhead and reduced throughput
- **Fast**: magic-state distillation using CH₂ in [[54,2,10]], memory in [[70,6,9]], and $H$–frame tracking for optimal $T$ throughput
- **Dense**: memory using [[102,22,9]] for maximal logical qubits per physical qubit

Trade-offs relate primarily to code overhead, throughput, and micro-architectural complexity. The architecture demonstrates that hundreds of logical qubits and millions of logical gates per day are attainable with near-term trapped-ion hardware, enabling classically intractable simulations and practical Shor’s algorithm execution [2604.19481].

Source: https://www.emergentmind.com/topics/walking-cat-architecture