Interactive Research Companion & Fault-Tolerant Circuit Compiler

SpiderCSS: Scalable Fault-Tolerant CSS State Preparation

Boldizsár Poór¹ Andrey Boris Khesin¹ Sarah Meng Li^2,3 Benjamin Rodatz¹ John van de Wetering^2,3 Richie Yeung¹

¹University of Oxford ²University of Amsterdam ³QuSoft

Launch Interactive Studio → Read Paper (arXiv:2610.03714) Explore 18 Code Benchmarks

Abstract

Fault-tolerant preparation of logical states is a critical primitive for the realization of large-scale fault-tolerant quantum computing. SpiderCSS introduces a scalable compilation pipeline that generates highly optimized, fault-tolerant state preparation circuits for arbitrary Calderbank–Shor–Steane (CSS) codes. Starting from an idealized bipartite ZX-diagram specification of a CSS state, we apply fault-equivalent rewrites and precomputed well-ordered Cat states to construct a diagram that is CNOT-minimal both within each component and across their interconnections—provably preserving fault tolerance by construction without expensive verification.

Avg. LER Reduction

−33.7%

Up to −90% vs. Flag at Origin

CNOT Reduction

Up to 53.8%

Matches or beats FaO on all codes

Preloaded QECCs

Distances d = 2 to 15 (n ≤ 144)

Well-Ordered Cats

593

Bundled for instant client-side synthesis

Interactive 5-Phase Compiler Studio

From CSS Stabilizers to Fault-Tolerant Quantum Circuits

Choose how you want to interact with SpiderCSS: explore the step-by-step theoretical walkthrough or synthesize circuits directly with the full compiler.

CSS Code & Target Logical State Specification

Select from 43 benchmarked CSS codes or define custom $H_X, H_Z$ parity-check matrices / Pauli strings, target basis, and distance $d$ .

[[7, 1, 3]]Steane Code

rank(H_X)=3•rank(H_Z)=3•t=1

Perfect QECC (X-spiders at t−1 = 0)

QECC Code Preset (43 Preloaded Codes)

Target Logical State

Distance

d

& Faults

t = \lfloor d / 2 \rfloor

FT Level:t = 1

Quick Presets:

Click any cell to toggle 0/1

H_X

X-Stabilizer Parity Matrix(3 × 7)

gen	q₀	q₁	q₂	q₃	q₄	q₅	q₆	wt
S_X,0								4
S_X,1								4
S_X,2								4

H_Z

Z-Stabilizer Parity Matrix(3 × 7)

gen	q₀	q₁	q₂	q₃	q₄	q₅	q₆	wt
S_Z,0								4
S_Z,1								4
S_Z,2								4

Bipartite ZX-Diagram & Column-Permuted RREF Basis Optimization

Different stabilizer generator bases yield different bipartite ZX-diagrams. Column-permuted Gaussian elimination over $\mathbb{F}_2$ embeds an identity submatrix $I_r$ into the pivot columns (guaranteeing the unique-ones property) while minimizing Eq. (8) CNOT cost.

max_basis_tries:

Step-by-Step RREF Procedure (Single Trial Inspector):

Eq. (8) Fault-Tolerant CNOT & Flag Cost Model

t = ⌊d / 2⌋ = 1

C_{\text{total}}(M', t) = \underbrace{\sum_{i:\, w_i > 1} 2\,f(w_i + 1, t)}_{\text{Col Flag CNOTs}} \;+\; \underbrace{\sum_{j=1}^{r} (w_j - 1)}_{\text{Row Fan-Out CNOTs}} \;+\; \underbrace{\sum_{j=1}^{r} 2\,f(w_j, t)}_{\text{Row Flag CNOTs}}

Row Fan-Out

Σ(w_j − 1)

Row Flag CX

Σ 2f(w_j, t)

Col Flag CX

Σ 2f(w_i+1, t)

Eq. (8) CNOTs

Init: 17 CX

Eq. (8) Flags

Init: 4 flags

Perfect QECC (is_perfect): Col (X) spiders unfuse at

t-1=0

instead of

t=1

Actual Circuit: 15 CNOTs, 3 Flags

Stage 4/4Un-Permuted RREF Basis M' = RREF(M[:, π])[:, π⁻¹]

Pivot Rows (3/3)Non-Pivot Cols (4)Active: H_X

Column Permutation

\pi

:[]

Click any two π entries to swap columns

Row	q₀	q₁	q₂	q₃	q₄	q₅	q₆	$w_j$	$f(w_j,t)$
Z₀(q₀)	1	0	0	1	1	1	0	4	+1
Z₁(q₁)	0	1	0	1	1	0	1	4	+1
Z₂(q₂)	0	0	1	1	0	1	1	4	+1
Col $w_i$	1	1	1	3	2	2	2	—	—
$f(w_i{+}1,t)$	·	·	·	+1	0	0	0	Flags: 4

Unique-1 Pivot (Z-Spider)Pivot Row (Green |0̄⟩)Non-Pivot Column (Red |+̄⟩ comp.)Non-Pivot 1 (Idealized Bipartite Edge)

Bipartite ZX-State Diagram (RREF Form)

3 row spiders ( $Z_j$ ) • 4 non-pivot spiders ( $X_i$ ) • all 7 output legs on the right • 9 idealized internal edges

Z-spiderX-spiderIdealized Edge

Hover over any spider to highlight its incident edges.State outputs: 7 right-hand boundary legs

Post-Phase 2 Exploration Branch

How would you like to proceed from the idealized bipartite ZX-diagram?

Explore the theoretical fault-equivalent ZX-calculus rewrites (Section III.A) or jump directly into the Algorithm 1 compiler pipeline (Section IV).

Global Port Matching (`G_global`, `D_global`) Without Backtracking

Each external bipartite edge $(a, b)$ is matched to the earliest unassigned 3-ary ports $u(a) \in V(a)$ and $u(b) \in V(b)$ , adding CNOT edge $(u(a), u(b))$ to $G_{\text{global}}$ and causal dependencies $P_{D_{\text{global}}}(u(a)) \to u(b)$ , $P_{D_{\text{global}}}(u(b)) \to u(a)$ to $D_{\text{global}}$ .

Edge Ordering Heuristic:

Safe Hook-Error Splits

Step 0 / 9 (Initial State)Disjoint Union of Well-Ordered Cat States (Before Adding External CNOT Edges)

Heuristic selected: SA Sequence Distance (Simulated annealing minimizing cat-state sequence span). Click Next >, Play, or click any dashed edge in Panel 1 to step through Algorithm 1.

Perfect QECC: X-spiders unfused at t−1

Panel 1 • Edge Schedule

Target Bipartite ZX-State

Click any dashed remaining edge to schedule it next, or click an added edge to inspect that step.0 / 9 edges

Added (0)Active (a, b)Remaining (9)

Panel 2 • Global Structure Network

32 spiders • 7 rootsDepth: 4 (5 generations)

Spiders copy the horizontal topological positions from the Global Digraph, updating with each added edge. All ports exit to the right boundary as output qubits q_0..q_6 (quantum state preparation). Bold edges form spanning forest F from roots r_k (blue boxes).

Spanning Forest FNon-Tree ClosureRoot r_kAdded CNOTActive (u(a), u(b))Output Qubit Wires

Topological Grid Alignment & Post-Extraction Qubit Reuse

Because D_global is guaranteed acyclic and every port satisfies Lemma III.7 or Lemma III.8, CatStateExtractor extracts a CNOT circuit in linear time, followed by interval-coloring qubit reuse.

9 Qubits (−1 via reuse)•15 CX•Depth 8

Interactive 3-Stage Circuit Extraction Morph (Figure 7 of Paper)

Step through $\text{(b)} \to \text{(c)} \to \text{(d)}$ to see how $(G_{\text{global}}, F, D_{\text{global}})$ is aligned onto qubit wires and translated into CNOT gates.

(d) Extracted Quantum Circuit: Every vertical (Z-spider, X-spider) pair becomes a CNOT gate (control • on the Z-spider wire, target ⊕ on the X-spider wire), degree-1 starts become |0⟩ (red) / |+⟩ (green) resets, and flag ends become meters.

7 data wires + 3 flag wires

|0⟩|0⟩ Reset (X-basis)|+⟩|+⟩ Reset (Z-basis)—+CX GateXX Measurement (green)ZZ / Flag Measurement (red)

Post-Extraction Qubit Reuse Mode

Select Qubit Reuse Strategy (Switch Dynamically Above Circuit)

Ancilla merges: 1 flag wires recycled

Simultaneous Qubits

9(7d + 2a)

Data Qubits (n)

Flag Measurements

CNOT Count

CNOT Depth

Total Circuit Depth

Compiled Quantum Circuit Diagram (9 Physical Qubits, 15 CNOTs, Depth 8)

Data wires q_0..q_6 persist to the output boundary; flag wires q_7..q_8 are measured and recycled when Qubit Reuse is enabled.

Highlight Ancilla Reuse Lifetimes

31 lines

Inject Depolarizing Noise

RX 2
R 3
R 5
R 6
R 0
CX 2 0
CX 0 3
CX 2 5
CX 0 6
CX 2 0
M 0
RX 0
R 7
CX 0 7
CX 7 5
RX 1
R 8
CX 1 8
CX 1 6
R 4
CX 8 4
CX 8 3
CX 0 4
CX 7 3
CX 0 7
CX 1 8
M 8
M 7
DETECTOR rec[-2]
DETECTOR rec[-3]
DETECTOR rec[-1]

[[7, 1, 3]] Steane Code — $|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$ Simulation Results

Circuit-level depolarizing noise (p = 0.001, 1.0e+8 Stim shots per heuristic) comparing SpiderCSS against Flag at Origin (FaO) with 95% Wilson confidence intervals.

All 18 Codes ↓

Logical Error Rate (LER)

[2.3, 2.5] × 10^-5

FaO: [2.1, 2.2] × 10^-5(+10.0%)

Acceptance Rate (AR)

98.70%

FaO: 98.70%(-0.0%)

CNOTs / Flag Ancillas

15 CX • 3 Flags

FaO: 15 CX • 3 Flags

Min Circuit Depth (Depth-Opt)

Depth 5 (10 Q)

FaO: Depth 8 (10 Q)(−37.5% D)

Min Sim. Qubits (Qubits-Opt)

8 Qubits (D=12)

FaO: 8 Qubits (D=15)(−0.0% Q)

Evaluated Heuristics vs. Flag at Origin for [[7, 1, 3]]

Method / Heuristic	CNOTs	Flags	Sim. Qubits Opt (Q / D)	Depth Opt (Q / D)	Logical Error Rate (95% CI)	Acceptance Rate (95% CI)
Flag at Origin (FaO)	15	3	8 / 15	10 / 8	[2.1, 2.2] × 10^-5	[0.9870, 0.9871]
SpiderCSS (Earliest Start)Best LER	15	3	8 / 12	10 / 5	[2.3, 2.5] × 10^-5	[0.9870, 0.9871]
SpiderCSS (Seq. Dist. / Joint)	15	3	8 / 12	10 / 5	[2.3, 2.5] × 10^-5	[0.9870, 0.9871]
SpiderCSS (Crit. Path)	15	3	8 / 12	10 / 5	[2.4, 2.6] × 10^-5	[0.9870, 0.9871]
SpiderCSS (Active Spider)	15	3	8 / 12	10 / 5	[2.4, 2.6] × 10^-5	[0.9870, 0.9871]
SpiderCSS (Seq. Dist. SA)Active in Phase 3	15	3	8 / 12	10 / 5	[2.5, 2.7] × 10^-5	[0.9870, 0.9871]

Section V • Global Benchmark Explorer (arXiv:2610.03714)

SpiderCSS vs. Flag at Origin Across 18 Benchmarked CSS Codes

Interactive reproduction of Figure 1, Figure 8, and Table I from the paper across 95 Stim Monte Carlo simulation runs (distances d = 3 to 15, up to n = 144 physical qubits).

Mean LER Reduction

−33.7%

Mean AR Increase

+9.5%

Depth Reduction

−60.3%

Sim. Qubits Saved

−20.2%

Click any point to inspect code & heuristics

Figure 1(a) • Noise Performance

Logical Error Rate vs. Acceptance Rate Improvement (%)

Avg LER: +33.7%

Avg AR: +9.5%

Benchmarked CSS Code★Mean (+33.7% LER, +9.5% AR)+FaO Baseline (0%, 0%)

Figure 1(b) • Spacetime Footprint

Circuit Depth vs. Simultaneous Qubits Improvement (%)

▲Depth Opt. (Avg +60.3% D, +20.2% Q)■Footprint Opt. (Avg +13.1% D, +8.9% Q)

Table I: Resource Overhead, Logical Error Rate & Acceptance Rate Comparison

Bold entries indicate the best result for each CSS state. Click any column header to sort, or click Load in Studio ↑ to inspect that code in Phases 1–5.

QEC Code & State ↑	Method	CNOT Count	Flag Count	Qubit Reuse Target	Sim. Qubits	Depth	LER (95% Wilson CI)	AR (95% Wilson CI)
[[7, 1, 3]] Steane $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	15	3	sim. qubits	8	15	[2.1, 2.2] × 10^-5	[0.9870, 0.9871]
	Flag at Origin	15	3	depth	10	8	[2.1, 2.2] × 10^-5	[0.9870, 0.9871]
	SpiderCSS (Earliest Start)	15	3	sim. qubits	8	12	[2.3, 2.5] × 10^-5	[0.9870, 0.9871]
	SpiderCSS (Earliest Start)	15	3	depth	10	5	[2.3, 2.5] × 10^-5	[0.9870, 0.9871]
[[9, 1, 3]] rot. surface $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	26	9	sim. qubits	11	20	[17.7, 19.5] × 10^-6	[0.9622, 0.9623]
	Flag at Origin	26	9	depth	18	6	[17.7, 19.5] × 10^-6	[0.9622, 0.9623]
	SpiderCSS (Crit. Path)	12	2	sim. qubits	9	5	[9.3, 10.5] × 10^-6	[0.9913, 0.9913]
	SpiderCSS (Crit. Path)	12	2	depth	11	4	[9.3, 10.5] × 10^-6	[0.9913, 0.9913]
[[17, 1, 5]] color code $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	74	21	sim. qubits	22	47	[4.9, 8.2] × 10^-7	[0.9009, 0.9010]
	Flag at Origin	74	21	depth	38	17	[4.9, 8.2] × 10^-7	[0.9009, 0.9010]
	SpiderCSS (Seq. Dist. (Joint))	74	21	sim. qubits	22	47	[4.7, 8.0] × 10^-7	[0.9107, 0.9108]
	SpiderCSS (Seq. Dist. (Joint))	74	21	depth	36	13	[4.7, 8.0] × 10^-7	[0.9107, 0.9108]
[[25, 1, 5]] rot. surface $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	92	28	sim. qubits	33	64	[5.0, 8.5] × 10^-7	[0.8735, 0.8736]
	Flag at Origin	92	28	depth	53	20	[5.0, 8.5] × 10^-7	[0.8735, 0.8736]
	SpiderCSS (Crit. Path)	78	21	sim. qubits	29	38	[3.3, 6.1] × 10^-7	[0.9101, 0.9102]
	SpiderCSS (Crit. Path)	78	21	depth	46	8	[3.3, 6.1] × 10^-7	[0.9101, 0.9102]
[[49, 1, 5]] triorthogonal $\|\mkern2mu\overline{\vphantom{0}+}\mkern2mu\rangle$	Flag at Origin	361	105	sim. qubits	89	195	[10.0, 10.5] × 10^-5	[0.4968, 0.4970]
	Flag at Origin	361	105	depth	154	56	[10.0, 10.5] × 10^-5	[0.4968, 0.4970]
	SpiderCSS (Earliest Start)	361	105	sim. qubits	80	232	[7.8, 8.3] × 10^-5	[0.5281, 0.5283]
	SpiderCSS (Earliest Start)	361	105	depth	128	29	[7.8, 8.3] × 10^-5	[0.5281, 0.5283]
[[20, 2, 6]] self-dual $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle^{\otimes 2}$	Flag at Origin	145	47	sim. qubits	40	101	[3.8, 11.3] × 10^-8	[0.7895, 0.7896]
	Flag at Origin	145	47	depth	67	51	[3.8, 11.3] × 10^-8	[0.7895, 0.7896]
	SpiderCSS (Seq. Dist. (Joint))	145	47	sim. qubits	39	91	[0.5, 4.4] × 10^-8	[0.8089, 0.8089]
	SpiderCSS (Seq. Dist. (Joint))	145	47	depth	60	16	[0.5, 4.4] × 10^-8	[0.8089, 0.8089]
[[23, 1, 7]] Golay $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	237	80	sim. qubits	53	142	[3.5, 5.6] × 10^-7	[0.6441, 0.6442]
	Flag at Origin	237	80	depth	103	29	[3.5, 5.6] × 10^-7	[0.6441, 0.6442]
	SpiderCSS (Active Spider)	237	80	sim. qubits	54	143	[1.9, 3.4] × 10^-7	[0.6771, 0.6772]
	SpiderCSS (Active Spider)	237	80	depth	83	22	[1.9, 3.4] × 10^-7	[0.6771, 0.6772]
[[31, 1, 7]] color code $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	211	69	sim. qubits	53	129	[14.0, 27.3] × 10^-8	[0.6954, 0.6956]
	Flag at Origin	211	69	depth	100	55	[14.0, 27.3] × 10^-8	[0.6954, 0.6956]
	SpiderCSS (Earliest Start)	211	69	sim. qubits	45	136	[5.5, 14.5] × 10^-8	[0.7189, 0.7190]
	SpiderCSS (Earliest Start)	211	69	depth	84	19	[5.5, 14.5] × 10^-8	[0.7189, 0.7190]
[[49, 1, 7]] rot. surface $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	262	85	sim. qubits	79	174	[11.4, 24.5] × 10^-8	[0.6215, 0.6216]
	Flag at Origin	262	85	depth	134	43	[11.4, 24.5] × 10^-8	[0.6215, 0.6216]
	SpiderCSS (Earliest Start)	226	69	sim. qubits	65	129	[4.7, 13.2] × 10^-8	[0.7121, 0.7122]
	SpiderCSS (Earliest Start)	226	69	depth	101	18	[4.7, 13.2] × 10^-8	[0.7121, 0.7122]
[[95, 1, 7]] triorthogonal $\|\mkern2mu\overline{\vphantom{0}+}\mkern2mu\rangle$	Flag at Origin	1175	380	sim. qubits	243	804	[1.6, 2.0] × 10^-4	[0.0259, 0.0260]
	Flag at Origin	1175	380	depth	475	386	[1.6, 2.0] × 10^-4	[0.0259, 0.0260]
	SpiderCSS (Seq. Dist. (Joint))	1173	379	sim. qubits	184	752	[3.0, 3.4] × 10^-4	[0.0372, 0.0373]
	SpiderCSS (Seq. Dist. (Joint))	1173	379	depth	332	44	[3.0, 3.4] × 10^-4	[0.0372, 0.0373]
[[49, 1, 9]] color code $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	408	136	sim. qubits	89	256	[3.1, 13.1] × 10^-8	[0.4413, 0.4414]
	Flag at Origin	408	136	depth	185	120	[3.1, 13.1] × 10^-8	[0.4413, 0.4414]
	SpiderCSS (Seq. Dist. (SA))	402	133	sim. qubits	81	265	[0.5, 6.2] × 10^-8	[0.4678, 0.4679]
	SpiderCSS (Seq. Dist. (SA))	402	133	depth	144	24	[0.5, 6.2] × 10^-8	[0.4678, 0.4679]
[[81, 1, 9]] rot. surface $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	614	206	sim. qubits	135	375	—	[0.2454, 0.2459]
	Flag at Origin	614	206	depth	287	126	—	[0.2454, 0.2459]
	SpiderCSS (Active Spider)	486	155	sim. qubits	116	308	—	[0.3816, 0.3822]
	SpiderCSS (Active Spider)	486	155	depth	198	25	—	[0.3816, 0.3822]
[[47, 1, 11]] self-dual $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	1033	388	sim. qubits	163	659	[27.7, 46.0] × 10^-7	[0.0672, 0.0672]
	Flag at Origin	1033	388	depth	435	289	[27.7, 46.0] × 10^-7	[0.0672, 0.0672]
	SpiderCSS (Crit. Path)	971	355	sim. qubits	185	635	[1.6, 6.9] × 10^-7	[0.0838, 0.0839]
	SpiderCSS (Crit. Path)	971	355	depth	303	38	[1.6, 6.9] × 10^-7	[0.0838, 0.0839]
[[71, 1, 11]] color code $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	Flag at Origin	829	268	sim. qubits	163	546	—	[0.1344, 0.1348]
	Flag at Origin	829	268	depth	339	279	—	[0.1344, 0.1348]
	SpiderCSS (Active Spider)	727	251	sim. qubits	135	475	—	[0.2060, 0.2065]
	SpiderCSS (Active Spider)	727	251	depth	258	28	—	[0.2060, 0.2065]
[[144, 12, 12]] gross $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle^{\otimes 12}$	SpiderCSS (Active Spider)	5018	1824	sim. qubits	800	2993	—	[0.0504, 0.0512]*
	SpiderCSS (Active Spider)	5018	1824	depth	1191	97	—	[0.0504, 0.0512]*
[[82, 2, 13]] 2bga $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle^{\otimes 2}$	SpiderCSS (Active Spider)	2586	970	sim. qubits	488	1587	—	[0.3453, 0.3472]*
	SpiderCSS (Active Spider)	2586	970	depth	640	76	—	[0.3453, 0.3472]*
[[92, 2, 14]] 2bga $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle^{\otimes 2}$	SpiderCSS (Active Spider)	3647	1409	sim. qubits	647	2164	—	[0.1346, 0.1359]*
	SpiderCSS (Active Spider)	3647	1409	depth	857	96	—	[0.1346, 0.1359]*
[[79, 1, 15]] self-dual $\|\mkern2mu\overline{\vphantom{+}0}\mkern2mu\rangle$	SpiderCSS (Active Spider)	3257	1270	sim. qubits	576	2032	—	[0.2005, 0.2020]*
	SpiderCSS (Active Spider)	3257	1270	depth	709	98	—	[0.2005, 0.2020]*

* Note: Logical error rates marked — were not estimated as the code-capacity syndrome lookup table exceeded memory. For the 4 largest codes (d ≥ 12), values marked with * indicate simulations performed at physical error rate p = 0.0001 instead of p = 0.001.