Pauli-based Computation (PBC)

• Pauli-based Computation (PBC) is a measurement-only quantum model that utilizes magic states and adaptive non-destructive Pauli measurements to achieve universal computation.
• It replaces explicit Clifford+T gate sequences with classical feed-forward, Pauli-frame tracking, and adaptive measurement scheduling to optimize circuit compilation and depth.
• PBC supports fault-tolerant implementations in surface-code and qLDPC architectures, enabling a trade-off between quantum resources and classical processing for scalable quantum protocols.

Pauli-based Computation (PBC) is a measurement-only model of quantum computation in which the input is a tensor product of magic states and the computation is driven by an adaptive sequence of non-destructive Pauli measurements, with polynomial-time classical post-processing selecting later measurements and interpreting outcomes (Bravyi et al., 2015). In later fault-tolerant and architectural literature, the same term also denotes a compilation and execution style that replaces much of an explicit Clifford+$T$ gate sequence by Pauli measurements, Pauli rotations, and Pauli-frame tracking, especially in surface-code and lattice-surgery settings (Hirano et al., 16 Apr 2025). Across these usages, the common structure is that non-Clifford power is supplied by magic states, while Clifford structure is largely transferred into classical feed-forward and measurement scheduling.

1. Canonical model and formal structure

In the original formulation, a PBC on $n$ qubits starts from the magic-state input $|H\rangle^{\otimes n}$ and consists of steps $t=1,\dots,m$ with $m\le n$, where each step performs a non-destructive eigenvalue measurement of a Pauli operator $P_t\in\mathcal P^n$ and records an outcome $\sigma_t\in\{+1,-1\}$. The choice of $P_t$ is adaptive: it may depend on earlier outcomes $\sigma_1,\dots,\sigma_{t-1}$, provided that dependence is classically computable in time $\mathrm{poly}(n)$. If the pre-measurement state is $n$0, then measuring $n$1 with outcome $n$2 updates the state by

$n$3

followed by normalization; the conditional outcome probability is

$n$4

After the final measurement, the quantum state is discarded and a single output bit is computed from the stored outcomes by classical post-processing in time $n$5 (Bravyi et al., 2015).

The magic state used in this model is

$n$6

or, in an unnormalized parameterization used for algebraic manipulations,

$n$7

The same work notes that any single-qubit magic state is Clifford-equivalent to either $n$8 or the eigenstate $n$9 of $|H\rangle^{\otimes n}$0, and that the $|H\rangle^{\otimes n}$1-state is Clifford-equivalent to $|H\rangle^{\otimes n}$2 (Bravyi et al., 2015).

A central simplification is that the computational power of PBC does not change if one additionally requires all measured Pauli operators to pairwise commute. In the original analysis, if a measured operator anticommutes with a previous one, that measurement can be replaced by a random Clifford unitary whose effect can be commuted to the end and removed. This standard form yields a commuting family of Pauli measurements with $|H\rangle^{\otimes n}$3 and only polynomial classical overhead. This commuting-measurement normal form remains one of the most distinctive structural features of canonical PBC, although later variants deliberately relax it.

2. Universality and relation to Clifford+$|H\rangle^{\otimes n}$4 and MBQC

The original universality theorem shows that any quantum computation in the circuit model with $|H\rangle^{\otimes n}$5 qubits and $|H\rangle^{\otimes n}$6 gates from the Clifford+$|H\rangle^{\otimes n}$7 set can be simulated by a PBC on $|H\rangle^{\otimes n}$8 qubits, where $|H\rangle^{\otimes n}$9 is the number of $t=1,\dots,m$0 gates, together with $t=1,\dots,m$1 classical processing (Bravyi et al., 2015). The proof uses magic-state injection: each $t=1,\dots,m$2 gate is replaced by a gadget consuming one $t=1,\dots,m$3-type resource, performing two adaptive Pauli measurements, and applying a corrective Clifford determined by the measurement outcomes. After commuting all Cliffords to the end and using the commutation simplification for Pauli measurements, the non-Clifford content of the circuit is concentrated into a PBC acting only on the magic-state register.

Later work made this reduction operational as a compilation method. A Clifford+$t=1,\dots,m$4 circuit with $t=1,\dots,m$5 $t=1,\dots,m$6 gates can be compiled into a standard PBC on $t=1,\dots,m$7 qubits, with practical adaptive-circuit realizations that use $t=1,\dots,m$8 quantum gates instead of a previous $t=1,\dots,m$9 scaling. The same compilation framework gives a depth reduction from $m\le n$0 to $m\le n$1 by introducing $m\le n$2 auxiliary qubits, and it supports hybrid execution in which a classical processor effectively supplies additional “virtual qubits” to a smaller quantum device (Peres et al., 2022).

The model is not confined to qubits. For odd-prime-dimensional systems, PBC generalizes to a computation on $m\le n$3-dimensional qudits driven by adaptive measurements of commuting, independent multiqudit Pauli observables on a magic-state input $m\le n$4. The resulting qudit PBC is universal, and any such computation can be mapped to adaptive circuits with either $m\le n$5 qudits and $m\le n$6 $m\le n$7 gates and depth, or reduced depth $m\le n$8 at the expense of larger width (Peres, 2023).

PBC is also closely related to MBQC, but the relation is not identity. The original PBC measures global Pauli observables on a separable magic-state input, whereas standard MBQC measures single qubits in an entangled resource such as a graph state. A later MBQC construction based on generalized parity-phase interactions was described as fitting squarely within the PBC paradigm because it achieves deterministic, approximately universal computation using only single-qubit Pauli $m\le n$9 and $P_t\in\mathcal P^n$0 measurements with feed-forward, while embedding the non-stabilizer resource into the entangling fabric rather than into explicit input magic states (Kissinger et al., 2017). This suggests that “PBC” names both a specific canonical model and a broader design principle centered on Pauli-only adaptive computation with non-stabilizer resources.

3. Resource tradeoffs and classical simulation

A major theoretical result for the original model is a quantum–classical tradeoff: any PBC on $P_t\in\mathcal P^n$1 qubits can be simulated by PBCs on $P_t\in\mathcal P^n$2 qubits together with classical processing costing $P_t\in\mathcal P^n$3, and the reduced PBC needs to be repeated only $P_t\in\mathcal P^n$4 times (Bravyi et al., 2015). The proof expands the $P_t\in\mathcal P^n$5-qubit magic-state density operator into a linear combination of stabilizer projectors,

$P_t\in\mathcal P^n$6

and then replaces each term by a reduced computation on $P_t\in\mathcal P^n$7 qubits with a stabilizer input on the removed subsystem. A simple decomposition gives $P_t\in\mathcal P^n$8, so the overall cost remains $P_t\in\mathcal P^n$9.

The same paper gave a purely classical exact weak simulation algorithm for PBC with runtime

$\sigma_t\in\{+1,-1\}$0

This improves on brute-force $\sigma_t\in\{+1,-1\}$1 simulation by using stabilizer-rank decompositions of $\sigma_t\in\{+1,-1\}$2. The key explicit bound is $\sigma_t\in\{+1,-1\}$3, which implies $\sigma_t\in\{+1,-1\}$4 and hence the exponent $\sigma_t\in\{+1,-1\}$5. The algorithm computes exact probabilities for arbitrary outcome prefixes and then samples the full measurement sequence exactly by conditional probabilities (Bravyi et al., 2015).

Compilation-oriented work recast these ideas as hybrid quantum computation. If a compiled PBC needs $\sigma_t\in\{+1,-1\}$6 qubits but only $\sigma_t\in\{+1,-1\}$7 are available, a classical processor can replace the missing $\sigma_t\in\{+1,-1\}$8 magic qubits through a stabilizer pseudo-mixture, so the quantum device runs only the smaller PBC while classical Monte Carlo handles the missing non-stabilizer contribution. In the implementation-oriented analysis, the number of shots scales as $\sigma_t\in\{+1,-1\}$9 in the best known regime, again emphasizing that PBC permits an explicit exchange between quantum memory and classical time (Peres et al., 2022).

For odd-prime qudits, the corresponding hybrid complexity is expressed in terms of the robustness of magic of the input states. Numerical computations in the qudit generalization yield sampling upper bounds

$P_t$0

together with lower bounds

$P_t$1

for qubits, qutrits, and ququints respectively (Peres, 2023). These results place hybrid PBC within a broader magic-resource theory rather than only within stabilizer-rank analysis.

4. Compilation, Pauli frames, measurement weight, and depth

As PBC matured into a compilation target, attention shifted from mere universality to the cost of the required Pauli measurements. A low-level Pauli tracking library formalized the propagation of Pauli frames through Clifford circuits using binary symplectic representations. In this framework, pending Pauli corrections are commuted forward through Clifford layers, absorbed at measurement points, and used to infer the strict partial order of measurements in MBQC-style executions. For local Clifford gates, the resulting tracking runs in $P_t$2 time for $P_t$3 gates and $P_t$4 frames, and time-optimal MBQC schedules can be extracted in polynomial time from the induced dependency DAG (Ruh et al., 2024).

Measurement weight then became a principal compilation objective. A recent synthesis framework treats PBC as a model that simulates a non-adaptive Clifford+$P_t$5 circuit with $P_t$6-count $P_t$7 by preparing a separable $P_t$8-qubit magic-state register and measuring at most $P_t$9 independent, pairwise commuting Pauli observables. By pre-compiling through one-way quantum computing, it derives nontrivial upper bounds on both measurement weight and adaptive depth. Under one processing order, the worst-case average weight of the measured set satisfies

$\sigma_1,\dots,\sigma_{t-1}$0

under another, the PBC depth equals the underlying 1WQC depth $\sigma_1,\dots,\sigma_{t-1}$1; and under a mixed order the depth obeys

$\sigma_1,\dots,\sigma_{t-1}$2

The same work introduces incPBC, a universal constant-weight variant using only Pauli measurements of weight at most $\sigma_1,\dots,\sigma_{t-1}$3, at the cost of allowing incompatible measurements and more total operations. For a Clifford+$\sigma_1,\dots,\sigma_{t-1}$4 circuit with logical depth $\sigma_1,\dots,\sigma_{t-1}$5, $\sigma_1,\dots,\sigma_{t-1}$6 $\sigma_1,\dots,\sigma_{t-1}$7 gates, $\sigma_1,\dots,\sigma_{t-1}$8 CNOTs, and $\sigma_1,\dots,\sigma_{t-1}$9 computational-basis readouts, incPBC uses at most $\mathrm{poly}(n)$0 online qubits, $\mathrm{poly}(n)$1 Pauli measurements, and depth $\mathrm{poly}(n)$2 (Peres et al., 2024).

Optimization inside sequential PBC has also become more algebraic. In a sequential representation, a Clifford+$\mathrm{poly}(n)$3 circuit is rewritten as a Clifford block followed by a product of $\mathrm{poly}(n)$4 multi-Pauli rotations. Within this form, a multi-product commutation relation allows two commuting pairs of $\mathrm{poly}(n)$5 rotations to be swapped as composite blocks even when every cross-pair anticommutes. The constructive condition is $\mathrm{poly}(n)$6 given $\mathrm{poly}(n)$7 and $\mathrm{poly}(n)$8. Benchmarks built by quantum circuit unoptimization indicate that this rewrite rule is not incorporated into current compilers, implying additional untapped T-count reductions in PBC-native optimization (Mori et al., 24 Sep 2025).

A separate heuristic line of work replaces each next measured Pauli by a product with previously measured commuting Paulis whenever this lowers weight, without changing the post-measurement state. On Clifford-dominated random circuits, this greedy search reduces the average measurement weight, and therefore the associated CNOT count in PBC-compiled circuits, by over $\mathrm{poly}(n)$9 for instances with up to $n$00 $n$01 gates and over $n$02 for larger $n$03 counts (Peres et al., 2024). In practice, PBC compilation has therefore evolved from a universality proof into a nontrivial optimization problem over Pauli frames, measurement generators, and adaptive schedules.

5. Fault-tolerant and architectural realizations

In fault-tolerant surface-code settings, PBC is often treated as an execution style rather than only a complexity model. In this usage, a circuit is simplified by Pauli-frame tracking so that most Clifford structure is removed from the time-critical path, leaving primarily $n$04 Pauli rotations and Pauli product measurements implemented through lattice surgery. A locality-aware variant preserves two-qubit locality by commuting only single-qubit Clifford rotations to the end and performing magic-state distillation in the computation area rather than in distant factories. Under the reported assumptions $n$05, per-attempt local distillation time $n$06, and acceptance ratio $n$07, this locality-aware PBC reduces execution time by $n$08 to $n$09 on random circuit sampling and 2D Ising benchmarks, while the measured parallelism scales approximately linearly with the number of data qubits and lifts the conventional throughput ceiling from $n$10 to $n$11 (Hirano et al., 16 Apr 2025).

Surface-code architectural optimization has also become explicitly PBC-aware. A recent framework, SPARO, models logical error rates during active PBC execution by incorporating Pauli product measurements, idling, and patch rotations into a layout-and-scheduling loop. Its numerical models capture the dependence of PPM error on ancilla path length and the contribution of waiting for magic states, then dynamically allocate area between routing and factories. On a $n$12-qubit ADDER circuit, SPARO reports up to $n$13 logical error rate reduction relative to static layouts with the same total hardware budget (Kan et al., 30 Apr 2025).

QLDPC architectures motivated a different realization. Extractor systems augment a QLDPC memory so that any logical Pauli operator supported on the memory can be fault-tolerantly measured in one logical cycle, defined as $n$14 physical syndrome measurement cycles, without rearranging qubit connectivity. Extractor-augmented computational blocks can be connected by bridge systems so that parallel logical measurements drive universal PBC, all single-block Clifford gates are compiled away, and inter-block Pauli measurements are supported by fixed-connectivity LDPC hardware. For a circuit of reduced depth $n$15 on blocks encoding $n$16 logical qubits each, the compiled schedule satisfies

$n$17

in logical cycles (He et al., 13 Mar 2025).

Distributed qLDPC settings further change the balance of costs. In monolithic architectures, the serialized nature of PBC ties runtime to T-count, but in distributed architectures the dominant bottleneck is remote Bell-pair generation. Within the Q-Fly architecture, large qLDPC code blocks and abundant nodes allow groups of qubits to be moved to free nodes, thereby bypassing the sequential bottleneck of PBC. On reported QAOA and decoded quantum interferometry workloads, this yields execution-time improvements of up to about one order of magnitude over a surface-code active-volume baseline, including approximately $n$18 faster QAOA at $n$19 and about $n$20 faster DQI under the same network assumption (Benchasattabuse et al., 5 May 2026). These results do not show that PBC is uniformly superior; they show instead that PBC becomes competitive when the architectural bottleneck shifts from local gate depth to communication structure.

6. Related models, determinism questions, and terminological boundaries

Pauli-heavy MBQC raises a distinct issue: determinism. In MBQC, Pauli measurements can invalidate the necessity of ordinary gflow, and even Pauli flow is not an exact criterion for a fixed correction strategy. The correct pattern-level characterization is Shadow Pauli Flow: a pattern is robustly deterministic if and only if it is consistent with a Shadow Pauli Flow on its underlying open graph, and such a flow can be computed in polynomial time given a partial order. At the resource level, an open graph supports robustly deterministic MBQC if and only if it has a Pauli Flow. These results matter for Pauli-based computation in the broad sense because they certify determinism, measurement order, and depth in MBQC patterns with substantial Pauli content (Mhalla et al., 2022).

Several nearby models should be distinguished from canonical PBC even when the terminology overlaps. “Pauli quantum computing” is a different formalism in which $n$21 and $n$22 in off-diagonal density-matrix blocks are treated as computational basis states, operations are implemented by block-diagonal quantum channels, and the formalism is used for tasks such as Lindbladian imaginary-time evolution, amplitude estimation, and a Pauli-encoded search oracle. Despite the name, this is not the magic-state, adaptive-Pauli-measurement model introduced in the original PBC literature (Shang, 2024).

Likewise, fermion-parity-based computation is a fermionic analogue modeled on PBC. It replaces Pauli measurements by adaptive measurements of fermion parity operators in Majorana systems, identifies the logical braid group as the fermionic analogue of the Clifford group, and commutes those logical braids to the end so that the hardware performs only parity measurements plus classical feed-forward (McLauchlan et al., 2021). A software-oriented dynamic Pauli constraints model is related in a different direction: it treats Pauli expectations and layer-by-layer tomography as the interface for specifying quantum computations and can coherently simulate PBC-style measurement patterns, but it generalizes beyond measurement-only Pauli schemes by reconstructing arbitrary local gates from tomographic constraints (Wootton et al., 21 May 2026).

The following summary captures the most important distinctions.

Model	Core primitive	Relation to canonical PBC
Original PBC	Adaptive non-destructive Pauli measurements on magic-state inputs	Canonical definition (Bravyi et al., 2015)
Pauli-only parity-phase MBQC	Pauli $n$23 measurements on parity-phase resource states	Described as fitting within the PBC paradigm (Kissinger et al., 2017)
Pauli quantum computing	NDME encoding and block-diagonal channels	Distinct formalism despite similar name (Shang, 2024)
Fermion-parity-based computation	Adaptive fermion-parity measurements on MZMs	Fermionic analogue modeled on PBC (McLauchlan et al., 2021)

A common misconception is that PBC is simply “Clifford computation with measurements.” In the canonical model, Clifford structure is indeed absorbed into classical control, but universality depends on non-stabilizer magic-state input (Bravyi et al., 2015). Another is that every Pauli-based measurement pattern is automatically deterministic once compatible observables are chosen; in MBQC this is false, and exact determinism requires the stronger Shadow Pauli Flow criterion (Mhalla et al., 2022). A third is that the original commuting-measurement formulation exhausts the design space; constant-weight incPBC shows that abandoning compatibility can trade simpler measurements for more layers and more online qubits (Peres et al., 2024).

Taken together, these developments show that PBC is best understood as a family of measurement-centric computational frameworks organized around three recurring ideas: non-Cliffordness concentrated into magic or other non-stabilizer resources, Clifford structure represented as classical Pauli-frame evolution, and computation expressed primarily through the selection, routing, and certification of Pauli observables.