Execution-transcript privacy for fault-tolerant surface-code memories

AI summary

Overview

Research area: Quantum error correction and fault-tolerant quantum computing, specifically the privacy and side-channel security of the classical telemetry emitted during error-correction cycles.

Technical level: Advanced. The paper assumes familiarity with stabilizer codes, the rotated surface code, Pauli cosets, diamond norm, total variation distance, Knill–Laflamme conditions, and polymer/cluster expansions.

Scope: The paper analyzes whether the non-output execution transcript of a fault-tolerant surface-code memory — syndromes, decoder actions, resets, timing, and leakage flags — reveals the stored logical input, and it supports the analysis with a theorem, a converse, exact simulations, and measurements on a 156-qubit superconducting processor.

What This Paper Is About

A fault-tolerant quantum computer emits a large classical record while it runs: a distance-$d$ memory run for $T=\Theta(d)$ rounds produces $\Theta(d^3)$ syndrome and decoder records, and that stream is logged and shared with a control plane. The paper asks whether someone who sees this full transcript — such as a cloud provider, or anyone who later obtains the provider's control logs — can tell whether the memory held a logical $0$ or a logical $1$, even though the final logical output stays hidden.

The goal is to determine which records are provably private, which records leak, and which code parameter governs the leak. The central claim is that fault tolerance does not grant transcript privacy; it relocates privacy, and the relocation is governed by the distance of each logical axis rather than by a single code distance.

Key Contributions

1. Framing the transcript as a privacy channel. The paper defines the non-output execution transcript $U=(S,A,R,\tau,J)$ as a classical channel from the logical input to observed telemetry, with an explicit threat model that gives the adversary the entire transcript, unlimited classical computation, full knowledge of the circuit, noise model, and decoder, and denies only the hidden output and direct data-qubit access.

2. Identifying $d_Z$ as the governing parameter and separating "permitted order" from "attained order." The paper proves that no term appears below order $\gamma^{d_Z}$ in the basis-label leak, then separately determines when that order is actually attained. For the repetition family the coefficient is $nT$; for a measured algebra of $X$ type the leak vanishes identically and the order is never attained.

3. An anisotropic no-leakage theorem plus a matching converse. Under backbone blindness (H1*), local transcript summability (PWTS), and a Kotecký–Preiss smallness condition, each logical axis is suppressed at the distance of its own coset: $\sum_u |x_u| \le \kappa_{d_X}$, $\sum_u |y_u| \le \kappa_{d_Y}$, $\sum_u |z_u| \le \kappa_{d_Z}$. The converse identifies records that do leak: a witness must be both charged (carrying a logical operator rather than a stabilizer) and calibrated (its recorded value tracks that operator), with lattice-surgery parity readout as an example.

4. Hardware and exact-numerics evaluation. On a 156-qubit superconducting processor the paper measures the predicted $d_Z$ mechanism in the repetition family and separately evaluates the sufficient certificate for the smallness condition, which misses by $21.5\times$, so the theorem cannot be invoked on that device.

Main Findings

• Two distinct privacy notions. Full logical-channel privacy is the diamond-norm distance between the transcript channel and an input-independent one, covers arbitrary logical inputs including superpositions and reference-entangled states, and is governed by $d_{\min}$. Basis-label privacy is the total variation between the transcripts of the two $\bar{Z}$ eigenstates, protects one logical axis, and is governed by $d_Z$. The second is the weaker notion; the first order at which it can fail is set by $d_Z$.

• Ideal syndrome transcripts are exactly input-independent. The two logical states differ by $\bar{X}$, which commutes with every measured stabilizer, so $P_{U\mid 0_L}=P_{U\mid 1_L}$ exactly in the noiseless stabilizer model. The theorem's content is carrying this into the noisy regime and marking where it breaks.

• Logical charge costs distance. Expanding the noisy transcript into fault paths, a homologically trivial bra–ket pair is proportional to the identity on the logical subsystem within its syndrome sector and cancels between the two input-conditioned laws. A surviving input-sensitive contribution must carry a homologically nontrivial cycle of support at least $d$, occupying at least $d/\ell_$ cells, where $\ell_$ is the cell-support constant. Classical decoder post-processing cannot change this, since a fixed channel cannot increase distinguishability.

• The leak order is $d_Z$, not $d_{\min}$. Under amplitude damping, whose Kraus operators map computational basis states to computational basis states up to scalars, the transcript depends on the logical bit only through moments $\langle Z_S\rangle$ that differ between inputs only on the coset $\bar{Z}\cdot\mathcal{S}$. The lowest differing weight is the minimum weight of a logical-$Z$ representative, $d_Z$. Since $d_Z\ge d_{\min}$, a code can be a poor quantum memory and still hide its computational-basis label.

• Two codes of quantum distance 1 make the gap concrete. A phase-flip code has $d_X=1$ and therefore no correctability guarantee, yet its $X$-syndrome transcript is exactly input-independent under unobserved damping for every $\gamma$ and every $T$. A repetition code with the same quantum distance leaks at first order, with $\mathrm{TV}=nT\gamma+O(\gamma^2)$. After one damping layer at $\gamma=0.1$, the two damped codewords are $1.70$ apart in trace distance at $n=3$, near the maximum of $2$, so direct measurement separates the states almost perfectly while the syndrome record carries nothing.

• Exposing the jump record restores the leak at exactly order $d_Z$. When the environment's which-qubit-decayed pattern is adjoined to the syndrome record, the phase-flip code leaks already at $T=1$ with $\mathrm{TV}=\gamma^n(1+O(\gamma))$ at $n=d_Z$ and coefficient $1$. Exact computation gives $\mathrm{TV}=1.0000\times 10^{-6}$ at $n=3$, $\gamma=10^{-2}$ and $1.0000\times 10^{-8}$ at $n=4$, $\gamma=10^{-2}$, with measured log-log slopes $3.0000$ and $4.0000$ against $d_Z=3,4$. The same code family therefore exhibits all three regimes — exact blindness, first-order leakage, and order-$d_Z$ leakage — with only the set of exposed records changing.

• Exact numerical slopes match $d_Z$. Using full density-matrix evolution with projective stabilizer measurement and no sampling, the measured slopes at $\gamma=10^{-4}$ are $0.9995$ (repetition $n=3$, $\mathrm{TV}=5.9985\times10^{-4}$), $0.9992$ (repetition $n=5$, $\mathrm{TV}=9.9955\times10^{-4}$), $1.9994$ ($[[4,1,2]]$, $\mathrm{TV}=7.9974\times10^{-8}$), and $2.9995$ (rotated surface $d=3$, $\mathrm{TV}=6.9981\times10^{-12}$). The phase-flip family gives $\mathrm{TV}\equiv 0$ with values below $10^{-16}$. The slope is absent exactly where the $X$-only blindness proposition says it must be.

• Structural proxy decreases with distance, but the asymptotic claim is not made. For the rotated surface code $d_Z=d$, and the proxy $M_d\gamma^{d_Z}$ decreases by $1538\times$ between $d=3$ and $d=5$ at $\gamma=10^{-2}$, while the multiplicity grows from $M_3=8$ to $M_5=52$, an effective finite-distance growth factor $\lambda_{\rm eff}=\sqrt{52/8}\approx 2.55$ per unit distance. The paper explicitly stops short of an asymptotic claim: the proposition is a statement about $\gamma\to 0$ at fixed $(d,T)$, not about $d\to\infty$ at fixed $\gamma$, and control of $c_{d,T}$ and the remainder as $d$ grows is not available.

• The theorem is anisotropic and strengthens the single-exponent statement. Corollary 1 gives $|\mathcal{M}-\mathcal{C}|\diamond \le \kappa{d_X}+\kappa_{d_Y}+\kappa_{d_Z} \le 3\kappa_{d_{\min}} = e^{-\Theta(d_{\min})}$, which for the rotated surface code is $e^{-\Theta(d)}$. Corollary 2 gives $\mathrm{TV}(P_{U\mid 0_L},P_{U\mid 1_L})=\sum_u|z_u|\le \kappa_{d_Z}$, so a code with $d_Z\gg d_{\min}$ can hide its computational-basis label exponentially better than it hides an arbitrary logical input. The extension from a basis pair to arbitrary inputs is not a triangle inequality over basis states; the measurement ${(I\pm\bar{X})/2}$ has identical laws on $|0_L\rangle$ and $|1_L\rangle$ yet separates $|\pm_L\rangle$ perfectly.

• Charged calibrated records leak. If the transcript exposes a record calibrated to a logical operator that it recovers with error $p_W$, the leak is at total variation at least $1-2p_W$, and for a witness whose $p_W$ decays with distance the leak scales with code distance toward full disclosure. A lattice-surgery parity measurement places $\bar{Z}_1\bar{Z}_2$ into the measured algebra, violating H1*, and is protected by a seam of length $d$. Simulation gives lattice-surgery seam error falling from $6.5\times10^{-3}$ to $2.2\times10^{-4}$ for $d=3$ to $11$, with fit $e^{-0.43d}$. The design instruction is single: keep logical operators out of the exposed algebra.

• Records fall into three groups. Certified private records include reset-ancilla syndrome detectors, decoder actions $A=f(S)$, and fixed timing and reset flags. Leaking records include lattice-surgery measurement, per-data-qubit QND or dispersive readout, a persistent data-calibrated sensor, and a mobile leakage excitation carrying a record — each leaking once local reports combine along a logical string over $T=\Theta(d)$ rounds. Nuisance records such as input-independent $1/f$ or common-mode drift break locality without carrying a logical signal and can be handled by conditioning.

• Simulation honesty check. In the stabilizer setting the second logical input is prepared by verified $\bar{X}$ injection, which commutes with every measured stabilizer, so the two detector records are drawn from the same distribution by construction and $\mathrm{TV}=0$ exactly. The honest-arm simulation rows are therefore a pipeline check, not a measurement of device privacy. Simulation at physical rate $p=0.005$ with circuit-level depolarizing noise gives adversary AUC on honest $U$ of $0.499$, $0.498$, $0.498$ for $d=3,5,7$ (chance), AUC with witness $W$ of $0.982$, $0.986$, $0.990$, coherent-plus-leakage AUC in $[0.497,0.507]$ across five noise models at $d=3$, and MMD two-sample tests with $p=0.45,0.76$ (not significant) on honest records versus $p=0.003$ with a witness.

• Hardware result: privacy fails where the theory cannot certify it. On a 156-qubit superconducting processor the sufficient certificate for the smallness condition misses by $21.5\times$, so Theorem 1 cannot be invoked there. Measured directly, a $d_Z=1$ memory's record identifies its input with total variation at least $0.927$ under randomised, label-balanced acquisition. Holding the code fixed and varying the damping exposure reproduces the parameter-free law with exponent $0.85\pm0.03$ against a predicted $0.86$.

• Randomized encoding is a cheap mitigation. Physical basis-state randomized encoding equalizes the two transcript laws by construction at no cost in additional two-qubit gates, returning the measured statistic to its finite-sample floor.

Methodology in Plain English

The authors treat the machine's logging stream as a communication channel and ask how well an eavesdropper can distinguish two possible logical inputs from it. They measure leakage with total variation distance between the two input-conditioned transcript distributions, because by Neyman–Pearson this bounds the optimal distinguishing power of any adversary at once, regardless of prior or computation, and because the adversary makes a single binary decision.

On the theory side, they expand the noisy transcript into fault paths and group contributions by the spacetime detector region they produce. The Knill–Laflamme condition shows that contributions with homologically trivial support multiply the code space by a scalar within a syndrome sector, so they appear equally under both inputs and cancel. Only contributions carrying a homologically nontrivial cycle of size at least $d$ survive, and these occupy a large region whose total activity is controlled by a polymer cluster expansion. Uniformity of the suppression in spacetime volume is the technical core, and it is where the two locality hypotheses and the smallness condition enter.

On the numerical side, they compute rather than sample. They verify $d_Z$ and the multiplicity of minimum-weight representatives two independent ways — GF(2) enumeration in the binary-symplectic representation and dense statevector simulation — agreeing on both order and multiplicity for four codes, with ratios $3/3$, $5/5$, $4/4$, and $8/8$. Enumeration beyond the rank cap is refused rather than approximated, because an under-search would return a $d_Z$ that is too large and would flatter the privacy claim. Exact density-matrix evolution with projective stabilizer measurement enumerates every outcome branch and reads off the local log-log slope as $\gamma\to 0$.

On the hardware side, they use randomised, label-balanced acquisition so that the measured total variation is not confounded by label imbalance, then vary the damping exposure while holding the code fixed to test the parameter-free prediction. They also evaluate the theorem's sufficient certificate directly against the device, which is how they establish that the theorem's hypotheses are not met there.

Why This Matters

The paper changes the security question for fault-tolerant quantum computing from "is the output protected?" to "is the telemetry protected?" Real-time decoding requires syndrome and decoder information to be shared with a control plane, so the transcript is a large, permanent, and necessary interface to a running computation. The paper shows that this interface is not automatically safe, that the relevant safety parameter can differ from the code distance, and that the same distance which suppresses accidental leakage makes an intentional logical readout more reliable.

• Cloud quantum computing. A provider that runs a customer's circuit sees the full syndrome and decoder stream. The paper identifies which parts of that stream must be treated as logical outputs and guarded accordingly.

• Control-log retention and auditing. Logs kept for debugging, billing, or compliance persist long after a computation finishes. The results give a screening diagnostic for deciding which retained record types are safe to expose.

• QEC decoder and control-plane design. The three-group record map (certified private, leaking, nuisance) is directly actionable for what a decoder is allowed to emit and what must be padded or restricted.

• Privacy benchmarking for hardware. The protocol of randomised, label-balanced acquisition plus a measured total-variation lower bound gives a way to test a device's transcript privacy empirically, including where the theoretical certificate cannot be applied.

Industry relevance: superconducting hardware providers, cloud quantum-computing services, and developers of real-time decoders and control electronics all sit on the leaking side of this analysis. The finding that the sufficient certificate misses by $21.5\times$ on a 156-qubit processor indicates that present devices are outside the regime where the theorem applies, which is directly relevant to any near-term claim of telemetry privacy.

Future Directions

• Closing the certificate gap. The sufficient smallness certificate misses by $21.5\times$ on the 156-qubit processor. Whether a tighter certificate, or a different but still rigorous condition, can be met by present hardware is left open.

• The asymptotic growth of $M_d$. The paper explicitly leaves this open. Two distances cannot determine the growth rate, so it does not extrapolate $\lambda_{\rm eff}$ into a statement of the form $\mathrm{TV}=\Theta((\lambda\gamma)^d)$ or into a threshold in $\gamma$. Passing from $\gamma\to 0$ at fixed $(d,T)$ to $d\to\infty$ at fixed $\gamma$ would require control of $c_{d,T}$ and of the remainder as $d$ grows.

• Extending beyond amplitude damping and the stated hypotheses. The theorem rests on backbone blindness, local transcript summability, and Kotecký–Preiss smallness. The supplementary derives the locality hypothesis from the device model, but coherent, non-Markovian, and other record types — including nuisance records such as $1/f$ drift — remain only partially classified.

• Designing and testing privacy-preserving transcripts at scale. Randomised encoding returns the measured statistic to its floor at no two-qubit-gate cost. Whether this mitigation holds for larger codes, longer schedules, and the full record set on hardware is a natural next test, as is turning "keep logical operators out of the exposed algebra" into concrete architectural constraints.

Target Audience

This paper is for researchers in quantum error correction and fault-tolerant architecture, quantum-software and control-plane engineers who design decoder and telemetry pipelines, and security researchers working on side channels in quantum systems. It is also relevant to cloud quantum-computing providers and hardware vendors who need to reason about what their control logs reveal. Readers without a background in stabilizer formalism, Pauli cosets, and diamond-norm channel distances will find the theoretical sections demanding; the hardware result and the three-group record map are accessible with less preparation.

Authors’ abstract

A fault-tolerant quantum computer runs behind a telemetry stream logging syndromes, decoder actions, resets and timing separately from the answer. Can it reveal the logical input? For a distance-$d$ rotated surface-code memory on a fixed schedule of $T=Θ(d)$ rounds, under three stated hypotheses (sector-scalar honest backbone, transcript locality, Kotecky-Preiss smallness), the channel from logical qubit to transcript is $e^{-Θ(d)}$-close in diamond norm to one that ignores the input. A statement of this kind follows generically from correctability-privacy duality. Anisotropy does not. Each logical axis pays the distance of its own coset, so under amplitude damping the computational-basis label is governed by the code's $Z$-distance $d_Z\ge d_{\min}$ and not by the code distance. Two codes of quantum distance $1$ make the gap concrete. A phase-flip code's $X$-syndrome transcript is exactly input-independent under unobserved damping, while a repetition code leaks at first order. A matched converse identifies the records that do expose it, among them a lattice-surgery parity readout. On a 156-qubit superconducting processor our sufficient certificate misses by $21.5\times$, so the theorem cannot be invoked there. Measured directly, a $d_Z=1$ memory's record identifies its input with total variation $\ge 0.927$ under randomised, label-balanced acquisition. Holding the code fixed and varying the damping exposure reproduces the parameter-free law, with exponent $0.85\pm0.03$ against a predicted $0.86$. Randomized encoding returns the statistic to the floor at no two-qubit-gate cost. Fault tolerance does not grant transcript privacy. It relocates it, and only to the logical state, not to the circuit's identity.