Most surface-code roadmaps treat each logical qubit as its own square patch. A new paper from Google Quantum AI asks a modest but concrete question: can you take four ordinary surface-code patches, add a thin strip of ancilla qubits between them, and get a single block that stores two logical qubits at twice the patch distance, all on a planar nearest-neighbour chip? The authors say yes, back the claim with circuit-level simulations, and run the construction on a 105-qubit Willow processor.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth reading

Concatenated codes and high-rate qLDPC codes promise fewer physical qubits per logical qubit, but they usually need connectivity that superconducting chips with a fixed square lattice do not have. Earlier hybrid schemes that put an outer code on top of surface-code patches (yoked surface codes, hierarchical memories) are aimed at large machines and, as the authors note, need too many qubits to show non-trivial distance scaling on current devices. This paper targets the opposite end: the smallest concatenation that still adds distance, built to fit hardware that exists today.

What the paper does

Mohamed A. Shalby, Leonid P. Pryadko and colleagues (including Craig Gidney) concatenate four distance-t rotated surface-code patches with the [[4,2,2]] code, the smallest CSS code with distance 2. The result is a [[4t², 2, 2t]] code: two logical qubits at code distance d = 2t. Including all ancillas, the footprint is N = 2d² + 4d − 3 physical qubits. For t = 3 that is 93 qubits for two logical qubits at distance 6.

The paper contributes three things:

• a planar layout and syndrome-extraction schedule for the two outer-code checks,

• a way to declare detectors so that the whole circuit can be decoded by ordinary minimum-weight perfect matching (MWPM), and

• simulations plus a hardware memory experiment at d = 4 and d = 6.

The key idea: GHZ corridors

The [[4,2,2]] outer code has two stabilizer generators, XXXX and ZZZZ across the four patches. At the physical level each is a logical-operator product of weight 4t, spread over all four patches. The standard tools for measuring such an operator between surface-code patches are lattice surgery or long-range gates. Here the authors instead run narrow “corridors” of ancilla qubits in a cross shape between the patches. On each corridor they prepare a 4t-qubit GHZ state, check it, then couple it transversally to the relevant data qubits and read out the outer-stabilizer value in the Shor style.

The corridor overhead is 8t + 1 qubits, which grows only linearly with t. Corridor qubits next to a patch boundary also serve as that patch’s weight-two boundary ancillas: the boundary checks are switched off while those qubits are busy with the GHZ state and switched back on afterwards.

How it works

Preparation. The GHZ state is built by measurement: small GHZ clusters are fused by measuring intermediate qubits, giving a constant-depth circuit independent of t. The resulting Pauli corrections are not applied with feedforward; they are absorbed into the detector definitions.

Verification. One bad fault during preparation could leave a multi-qubit X error on the GHZ state that spreads into the data as a hook error. So each preparation is followed by r_v rounds of pairwise ZZ parity checks along the corridor (XX checks on the other corridor). For patch distances up to 10 and r_v ≥ 2, the authors find the circuit distance follows the empirical formula d_circ = min(2t, r_v + 3). It was computed with Stim and cross-checked with dist_m4ri. So the full design distance needs r_v = 2t − 3. The paper argues that fewer rounds are often better in practice, because the remaining short fault chains are confined to a few corridor sites. Each outer-generator measurement takes r_v + 1 surface-code cycles.

Decoding. A fault in the corridor can trigger detectors in the corridor and in several patches at once (a “hyperedge”), which plain matching cannot handle. The authors declare the corridor and verifier detectors so that Stim breaks every such mechanism into graphlike pieces. The full syndrome, including the outer-code detectors, is then decoded in a single PyMatching pass, optionally with correlated reweighting.

What was demonstrated

Simulations (demonstrated numerically). Under the SI1000 superconducting-inspired noise model, the stitched code’s logical error rate scales as roughly p^t, consistent with distance 2t. The authors compare it with two independent surface-code patches. At equal distance the stitched layout uses fewer qubits. To reach a target logical error rate, it overtakes two patches only above a crossover size: about N ≈ 157 at p = 10⁻⁴, ≈ 237 at p = 5×10⁻⁴ and ≈ 333 at p = 10⁻³. At p = (2–3)×10⁻³ its logical error rate at N ≈ 10³ is still 10–14% higher than the two-patch baseline. Asymptotically the encoding density kd²/N tends to 1, twice the single-patch value of 1/2.

Hardware (demonstrated experimentally). On a 105-qubit Willow processor the team ran d = 4 (t = 2, r_v = 1) and d = 6 (t = 3, r_v = 2, circuit distance 5) memory experiments in both the ZZ and XX bases. They used 1 to 8 outer-code rounds (up to 52 surface-code cycles) and 200,000 shots per circuit. A four-state Markov model captures the correlated errors between the two logical qubits. With correlated matching, the per-cycle block error probability fell from 5.836% at d = 4 to 3.850% at d = 6, an improvement factor Λ_4→6 = 1.516. With plain MWPM the numbers were 6.845% and 4.209% (Λ = 1.626). XX-basis runs had higher error rates than ZZ-basis runs, which the authors attribute to low-frequency phase noise.

Why it matters

The result is a working, matchable example of concatenation on a strictly planar nearest-neighbour lattice. No lattice surgery, long-range couplers or workspace patches are needed. The authors also point out a geometric benefit: both logical qubits sit in one nearly square region rather than a rectangle of two patches. That could matter for tiling, packaging and modular designs, independent of qubit count. They also suggest the corridor gadget could carry other small outer codes whose checks can be routed through planar corridors.

Technical perspective (interpretation)

My reading is that the paper’s most reusable contribution is the decoder-friendly detector design rather than the specific [[4,2,2]] block. Weight-4t checks measured through a GHZ state normally produce exactly the hyperedges that push people towards slower decoders such as BP+OSD or search-based decoding. Showing that careful detector declarations keep everything matchable is a practical result for anyone designing gadgets that act across patches.

The experiment should be read as a feasibility and scaling check, not a memory record. Per-cycle block error probabilities of a few percent are far from what single-patch surface-code memories on Willow-class hardware have shown. The paper itself says the device’s physical error rates lie above the simulated crossover where stitching starts to save qubits. As far as I can see, the main text reports no same-device surface-code baseline. So the hardware data show that error per cycle drops with distance, not that the stitched code beats ordinary patches today.

Limitations and open questions

• Slow outer-code parity. The outer-code detectors fire often (close to 1/2 at d = 6 on hardware) because the checks have large physical weight. A memory can tolerate this; a timed parity measurement cannot. In a stability simulation at p = 10⁻³, the t = 3 stitched code needed about 80 cycles to determine G_X with error probability 10⁻³, against about 5 cycles for a surface code of the same distance. The authors conclude that logical operations should go through patch boundaries or code automorphisms, not the corridors.

• Footprint advantage is conditional. It depends on the physical error rate and the target logical error rate, and needs t large enough to amortise the corridor noise.

• Circuit distance below code distance in the experiment. The d = 6 hardware circuit used r_v = 2, giving circuit distance 5.

• Hardware demands. Some qubits that would normally be data qubits become corridor ancillas, so they must be measured and reset every outer round. The hardware is not optimised for that.

• Open directions named by the authors: optimising corridor readout, reset and leakage removal; other planar-routable outer codes; logical gates on and between stitched blocks.

Paper information

• Title: Stitched surface codes: planar concatenation through GHZ corridors

• Authors: Mohamed A. Shalby, Alexandre Bourassa, Amir Karamlou, Leigh Martin, Alexis Morvan, Nicholas Noll, Craig Gidney, Leonid P. Pryadko (Google Quantum AI; M. A. Shalby also University of California, Riverside)

• arXiv: 2610.21357v1 [quant-ph], submitted 15 October 2026

• DOI: 10.48550/arXiv.2610.21357

• Length: 18 pages, 16 figures, 4 tables

• Code and data: the paper points to github.com/QEC-pages/Stitched-Surface-Code. When this article was written (16 October 2026) that URL returned “page not found”, so the repository may not be public yet.

Primary sources

• arXiv abstract page: arxiv.org/abs/2610.21357

• Full text (HTML): arxiv.org/html/2610.21357v1

• PDF: arxiv.org/pdf/2610.21357v1

Suppose Alice is handed the description of any qudit state and Bob the description of any measurement. In the quantum world, Alice simply prepares the state and sends a single d-dimensional system to Bob, who measures it. How much classical communication would they need to reproduce exactly the same outcome statistics, if they are allowed unlimited shared randomness? A new preprint by Riccardo Castellano, Pavel Sekatski and Nicolas Brunner (University of Geneva) gives an answer that is both reassuring and sobering: a finite number of bits suffices on average, but only in a precise and rather weak sense.

This article was drafted with Claude and fact-checked against the cited primary sources. It is worth reading because it closes most of a question that goes back to the Toner–Bacon result of 2003 and that was sharpened only weeks ago by a no-go theorem from de Gois, Santos and Vieira.

What the paper does

The setting is the one-way prepare-and-measure scenario. A classical simulation consists of shared randomness λ, an encoder that maps Alice’s pure state ψ to a message from an alphabet of size l_λ, and a decoder with which Bob samples an outcome given his measurement, λ and the message. The simulation must reproduce the Born-rule probabilities exactly, for every state and every POVM.

The authors separate three ways of counting communication: the worst-case alphabet size, the expected alphabet size E[l_λ], and the expected number of bits E[log l_λ]. Their two main results pull these apart:

• No-go (Theorem 1). For d ≥ 4, every exact one-way classical simulation of qudit correlations has infinite expected alphabet size. This strengthens the recent result of de Gois, Santos and Vieira (arXiv:2609.04182), who showed that the worst-case alphabet size must be infinite for d ≥ 4. The proof follows their original argument and assumes measurability of the encoder and decoder, an assumption the authors say can likely be removed.

• Exact simulation (Theorem 2). For every d ≥ 2 there is an exact one-way simulation of all states and all POVMs whose expected communication is finite: E[log l_λ] ≤ log d + n_d(⌈log(4dn_d)⌉ + 2), with n_d = 2d − 2, i.e. O(d log d) bits. The probability of using more than k bits decays exponentially in k.

Together, these say that a qudit cannot be faked with a finite average message dimension, yet can be faked with a finite average number of bits. That is the sense of the title’s claim that the cost is “as high as it could be”.

The key idea

The construction rests on a general simulation theorem that is not specific to quantum theory. Alice’s possible inputs form a set X and Bob’s task is described by a family of maps assigning each input a probability distribution. The authors define the mass deficit of a subset R of inputs: how much probability mass, in the worst case over Bob’s maps, is not shared by all inputs in R. A subset is “small” when every input in it produces nearly the same output distribution, whatever Bob measures.

From this they build a covering dimension, the “mass-deficit Minkowski dimension”, modelled on box-counting dimension. The general result (Theorem 3) is that whenever this dimension is finite, an exact one-way simulation with finite expected communication exists, again with an exponential tail on message length.

How it works

Alice and Bob agree in advance on a nested sequence of partitions of the state space, each one refining the previous. The shared randomness picks a level k with probability 2⁻ᵏ. Alice sends only the label of the cell at that level that contains her state; she does not need to send k, because it is shared.

Bob’s decoder is built recursively. At each level he knows a lower envelope: the probability mass that every state in the received cell is guaranteed to put on each outcome. The recursion assigns a cumulative sub-distribution of total mass 1 − 2⁻ᵏ that is safe for every state in the cell, and reserves the remaining mass for finer levels. Averaged over k, the contributions telescope and reproduce the Born probabilities exactly; the error after k levels is exactly 2⁻ᵏ in L1 norm before the limit is taken.

For qudits, the authors use a lemma bounding the mass deficit of a cell by d times its trace-distance diameter, and an explicit nested partition of pure-state space (real dimension 2d − 2) whose cells shrink geometrically. Since the expected level is 2 and the label length grows linearly in the level, the expected number of bits is finite. The expected alphabet size, however, diverges in their construction for every d ≥ 2, and Theorem 1 shows this is unavoidable for d ≥ 4.

Beyond qudits

Because the theorem only needs finite mass-deficit dimension, it also covers generalized probabilistic theories with finite-dimensional state spaces and some infinite-dimensional quantum systems. The paper works out the example of n-mode Gaussian states with mean photon number at most E, measured by arbitrary general-dyne measurements (which include heterodyne and, as a limit, homodyne detection). There, the expected number of bits grows logarithmically in E; for one mode the bound is 10 log E + O(1). The energy bound is essential: without it, the channel would have infinite classical capacity.

The paper also gives an approximate protocol with a fixed, finite alphabet and no shared randomness, accurate in Kullback–Leibler divergence, and notes consequences for the Bell scenario: by having Alice sample her outcome locally and then simulate Bob’s conditional state, correlations of entangled d × d states can be simulated with finite average one-way communication.

Why it matters

Communication-cost questions are one of the cleanest ways to quantify how “non-classical” quantum resources are. Earlier results gave lower bounds, showing that alphabet size must grow at least exponentially in d, and a growing list of exact models for small cases: one bit for projective measurements on a Bell state (Toner and Bacon), and a finite worst-case alphabet for qubits and qutrits. This paper pins down where the boundary lies for every finite d: finite in expected bits, infinite in expected alphabet size (for d ≥ 4). Notably, the simulation respects the causal structure of the scenario by using only one-way communication, unlike earlier two-way models.

Technical perspective (interpretation)

My reading is that the most reusable contribution is the general theorem, not the qudit bound. It turns an operational question into a geometric one: if the “operationally induced” size of state-space cells shrinks polynomially fast, exact simulation with finite expected bits follows almost automatically. The proof is short, and the necessity remark in the paper (the cumulative decoder must stay below the lower envelope) suggests the mass deficit is the right notion of size for this nested-encoding strategy.

It is also worth being clear about what “finite on average” buys. The scheme sometimes sends very long messages; they are just exponentially rare. The gap between expected bits and expected alphabet size is exactly the gap between the averages of log l and of l, which can differ dramatically under heavy-tailed distributions.

Limitations and open questions

• The O(d log d) expected-bit bound is an upper bound; the authors do not claim it is optimal. They frame the optimal tail exponent of the message-length distribution as open, with bounds 1/(2d − 2) ≤ β* ≤ 1 for d ≥ 4.

• Theorem 1 relies on measurability assumptions on encoder and decoder; the authors expect these can be removed but do not prove it here.

• Whether Haar-random rotation of the partition improves the approximate protocol’s asymptotic accuracy is left open.

• For bounded-energy Gaussian systems, it is open whether a model with finite expected alphabet size exists.

• Extensions to three or more parties, and to other continuous-variable classes, are proposed but not worked out.

• This is a v1 preprint and has not yet been peer reviewed. The results are theoretical; there is no experiment or code.

Paper information

• Title: The cost of classically simulating quantum communication is as high as it could be

• Authors: Riccardo Castellano, Pavel Sekatski, Nicolas Brunner (Department of Applied Physics, University of Geneva)

• arXiv: 2610.19060v1 [quant-ph], submitted 13 October 2026

• DOI: 10.48550/arXiv.2610.19060

• Length: 11 pages of main text, 11 pages of appendix, 1 figure

Primary sources

• Castellano, Sekatski, Brunner, arXiv:2610.19060 (HTML full text)

• de Gois, Santos, Vieira, “Quantum communication and Bell nonlocality require infinite classical communication to simulate”, arXiv:2609.04182

• Toner, Bacon, “Communication cost of simulating Bell correlations”, Phys. Rev. Lett. 91, 187904 (2003), quant-ph/0304076

For two decades, one of the most quoted expectations in quantum many-body physics has been the area law: in the ground state of a gapped local Hamiltonian, entanglement between a region and its complement should scale with the region’s boundary, not its volume. In one dimension this is a theorem, and it holds for every Rényi entropy. In two and higher dimensions it is still largely open. A new paper by Tomotaka Kuwahara (RIKEN) settles one well-defined piece of that question, and the answer is negative: for every Rényi index α strictly between 0 and 1, the higher-dimensional Rényi area law is false.

This article was drafted with Claude and fact-checked against the cited primary sources. All statements about the results are taken from the paper (arXiv:2610.15199v1); passages marked as interpretation are mine.

What the paper does

The Rényi area-law conjecture, as stated in the paper, asks whether every uniformly gapped local lattice Hamiltonian satisfies, for each fixed 0 < α < 1, a bound of the form “α-Rényi entropy ≤ C_α × (size of the cut’s cross-section)”, with a constant independent of system size. The paper proves three results:

• Result 1 (upper bound). For any finite-range Hamiltonian in any fixed dimension with a unique ground state and a spectral gap — no frustration-freeness or local-gap assumption — there is an approximate ground-state projector (AGSP) across a planar cut whose log operator Schmidt rank scales as roughly 𝒜 + (𝒜 · log 1/ε)^2/3, up to logarithmic factors and a gap-dependent factor, where 𝒜 is the cut’s cross-section and ε the target accuracy.

• Result 2 (optimality). In the high-accuracy regime (log 1/ε at least of order 𝒜), explicit uniformly gapped Hamiltonian families require log Schmidt rank at least c(𝒜 · log 1/ε)^2/3, both to approximate the ground state and for any AGSP. So the 2/3 exponent is optimal at fixed gap, up to logs. In one dimension this improves the earlier 3/4 exponent for general (frustrated) systems to 2/3 and shows it cannot be improved.

• Result 3 (the counterexample). For every fixed 0 < α < 1 and every dimension ν ≥ 2, there are finite-range Hamiltonians with fixed local dimension, a uniform spectral gap and unique ground states whose α-Rényi entropy across the cut is at least c_α·n — a volume law.

The key idea: complexity hidden in a tiny branch

The paper calls its mechanism error-space complexity. Write a state as a dominant component plus a small-amplitude component ε|φ⟩. If that small component can be singled out by a projector that is a product across the cut — fixed in advance by the construction, for example a “flag” qubit sitting on one side — then the Schmidt tail of the full state is at least the branch probability times the Schmidt tail of the extracted component. A branch of tiny probability that contains many Bell pairs across the cut therefore forces a long Schmidt tail on the whole ground state.

The von Neumann entropy barely notices such a branch. Rényi entropies with α < 1, however, weight small Schmidt coefficients more heavily, and the paper shows this is enough to produce a volume law for them while the von Neumann entropy still obeys an area law across the same cuts.

How the construction works

The lower-bound Hamiltonians are built from parallel Feynman–Kitaev-type history states. In outline, according to the paper:

• Each row runs a local “clock” based on an adjacent-exchange graph; a random-deletion flow argument bounds the relevant Poincaré constant by O(m³), with both a product source and a target containing m Bell pairs keeping constant stationary mass. This is realized with six local states and positive semidefinite local rewrite terms.

• Rather than stacking independent clocks, the rows share a single attractive “root” well and are activated in sequence by a local prefix track; the paper proves that the full-system spectral gap stays bounded below independently of system size.

• A fixed product projection then extracts a component equal (up to local isometries) to M·m Bell pairs across the cut, with weight at least exp[−C(M + M·m^3/2)], where M is the cross-section size and m sets the row length.

• Higher dimensions are reached by a cut-preserving serpentine re-embedding. The precise theorem gives local dimension at most 6, interactions of at most 5 sites and range at most 2. In 2D a suitable rectangular aspect ratio is chosen for each fixed α; in three and higher dimensions a single hypercubic family works for every α < 1.

Two further properties make the counterexample sharp. The ground states have a product state with overlap at least 1/2, and they can be connected to product states along uniformly gapped local paths — so they sit in the same gapped phase as a product state. And the von Neumann entropy obeys an area law across the same cuts.

Why it matters

The result separates two notions that are often used interchangeably. Low-index Rényi entropies (α < 1) and the von Neumann entropy capture different aspects of gapped ground states: according to the paper, neither criticality nor a phase transition is needed for a Rényi volume law. At the same time, the paper notes that a Rényi volume law does not by itself prevent accurate low-rank approximation across a given cut when the von Neumann entropy is area-law.

The optimality result also addresses proof technique. AGSP arguments drove the one-dimensional area law, and in higher dimensions they would need a square-root-type rank–error trade-off. The paper shows that in the worst case, using locality and a gap alone, the best possible exponent is 2/3, so optimizing the conventional AGSP condition cannot by itself establish a general higher-dimensional area law. A side result for one-dimensional Gibbs states shows that, for Rényi entanglement of purification with α of order β^−1/3, no universal inverse-temperature exponent smaller than 2/3 is possible.

Technical perspective (interpretation)

My reading is that the paper turns a known intuition — small Schmidt weights can make Rényi entropies with α < 1 large without harming MPS-style approximability (Schuch, Wolf, Verstraete and Cirac made this point in 2008) — into a statement about uniformly gapped ground states on genuine lattices. The essential new ingredient is engineering such a tail while keeping a size-independent physical gap and product-state connectivity. The “note added” in the paper is also worth flagging: it cites a recently released proposed proof of a two-dimensional von Neumann area law under a global gap assumption. If that proof holds, α = 1 would be exactly the threshold for a universal Rényi area law in 2D gapped systems; the paper states that its own results do not depend on it.

The paper also contains an explicit acknowledgment of AI assistance: the author reports extensive use of ChatGPT models, and says that the lower-bound construction giving the optimal scaling originated from a proposal by a model called GPT-6 Astra, then was developed and rigorously analysed with the author, who takes full responsibility for the statements and proofs.

Limitations and open questions

• The counterexample is worst-case and engineered (history-state Hamiltonians); it says nothing about whether typical physical models violate Rényi area laws.

• The rank lower bounds hold only in the high-accuracy regime; a matching lower bound at all accuracies is open.

• The optimal dependence of the AGSP upper bound on the spectral gap is unknown; optimality is claimed only at fixed gap.

• The lower-bound families have system size chosen according to the target accuracy, and the upper bound concerns a single prescribed cut, not an efficient global tensor-network construction.

• The paper leaves open whether adaptive, state-dependent AGSP schemes could still give efficient ground-state approximation.

• This is a v1 preprint with a 25-page appendix of proofs; it has not yet been peer reviewed.

Paper information

• Title: The Rényi area law conjecture is false below α=1 in high dimensions

• Author: Tomotaka Kuwahara (Analytical Quantum Complexity RIKEN Hakubi Research Team, RIKEN Center for Quantum Computing; RIKEN Pioneering Research Institute)

• arXiv: 2610.15199v1 [quant-ph], submitted 10 October 2026; 7 pages + 25 pages appendix, 6 figures

• DOI: 10.48550/arXiv.2610.15199

• Code/data: none (theoretical work)

Primary sources

• T. Kuwahara, “The Rényi area law conjecture is false below α=1 in high dimensions,” arXiv:2610.15199 (HTML full text, PDF)

• I. Arad, A. Kitaev, Z. Landau, U. Vazirani, “An area law and sub-exponential algorithm for 1D systems,” arXiv:1301.1162 — the earlier AGSP rank–error bounds the new paper improves on.

Some quantum channels become more useful when the sender and receiver are allowed to talk to each other over an ordinary classical line. The textbook example is photon loss: a pure-loss channel that lets through half the light or less cannot carry quantum information on its own, yet with two-way classical communication between uses it can distribute entanglement at a positive rate for any nonzero transmissivity. So it is a fair question whether the same kind of help pays off for the other major noise process in optical and microwave modes, dephasing. A new paper by Amir Arqand and Graeme Smith (University of Waterloo) answers it for bosonic dephasing channels with a fixed energy budget: it does not.

This article was drafted with Claude and fact-checked against the cited primary sources.

What the paper does

The paper, “No advantage from classical assistance for energy-constrained bosonic dephasing channels” (arXiv:2610.13854v1), studies single-mode bosonic dephasing channels. Such a channel applies a random phase rotation e^−iφn̂ to the mode, with the angle φ drawn from some probability density on [−π, π]. It leaves the photon-number distribution untouched and only damps the coherences between different Fock states.

The authors consider four capacities under an average photon-number constraint E: the unassisted quantum capacity, the unassisted private capacity, the quantum capacity assisted by two-way classical communication (LOCC), and the private (secret-key) capacity assisted by two-way public classical communication. Their main theorem states that, for every phase-noise density and every finite E ≥ 0, all four are equal. The common value is a single-letter formula: the coherent information, maximised over photon-number distributions whose mean is at most E (with the input taken diagonal in the Fock basis).

The assistance allowed is fully general. The parties may keep quantum memories, exchange classical messages between every channel use, and choose later inputs based on earlier outcomes. The energy constraint is imposed on the mean photon number averaged over all uses, so an adaptive protocol may spend more energy in some rounds and less in others.

Where this sits

Lami and Wilde had previously solved the quantum and private capacities of bosonic dephasing channels without an energy constraint (Nature Photonics, 2023), and showed that in that setting the assisted and unassisted capacities coincide. As Arqand and Smith point out, that achievability argument uses inputs spread uniformly over more and more Fock levels, so the mean photon number grows without bound. The unconstrained result therefore did not settle what happens at a fixed input energy, which is the physically natural constraint for bosonic communication. For a Gaussian phase-noise model, earlier work had obtained upper and lower bounds on the energy-constrained LOCC-assisted quantum capacity. The new paper closes this gap for all phase-noise distributions.

The key idea

The unassisted part is the easy half. Bosonic dephasing channels are degradable, and an existing energy-constrained coding theorem for degradable channels (Wilde and Qi) already gives the unassisted quantum and private capacities as a coherent-information optimisation. The authors show the optimum can be taken over Fock-diagonal inputs. Since an unassisted code is also a valid assisted protocol, the assisted capacities are at least this large.

The real work is the converse: proving that no adaptive LOCC protocol can beat that rate. The central trick is to compare the dephasing channel with the completely dephasing channel Δ, which measures the photon number and keeps only the diagonal. Two facts make this comparison clean. First, dephasing in the Fock basis after the channel gives exactly Δ, so the channel output and the fully dephased output are linked by a pinching. Second, Δ cannot create entanglement: it maps PPT-type and separable states to states of the same kind.

How the proof works

• A relative-entropy bound. For any input correlated with a reference system and with mean photon number at most E, the relative entropy between the channel output and the completely dephased output is at most the coherent information of the input’s photon-number distribution, with equality for pure inputs (Lemma 3.1).

• A chain rule. Combining that bound with a pinching identity for relative entropy gives an energy-constrained chain rule (Theorem 3.1): passing a state through the channel can increase its relative entropy to a dephased comparison state by at most that coherent information.

• Entanglement measures. Applied with PPT-type and separable comparison states, the chain rule bounds how much the Rains relative entropy (Theorem 3.2) and the relative entropy of entanglement (Theorem 3.4) can grow in one channel use, even when the input is entangled with the parties’ memories.

• Iterating over the protocol. LOCC steps cannot increase either measure. Summing the per-use increments, then using concavity of coherent information and the average energy constraint, bounds the entanglement of the final state by n times the unassisted capacity. Standard arguments then turn this into upper bounds on the assisted quantum capacity (Theorem 3.3) and the secret-key capacity (Theorem 3.5).

The authors also show that both chain rules are tight: they are attained by the canonical purification of any finite-energy Fock-diagonal input (Corollary 3.1). The analysis allows countably supported photon-number distributions and infinite-dimensional local memories and private-state shields, with the infinite-dimensional technicalities handled explicitly.

Why it matters

What the paper proves is a capacity statement: for energy-constrained bosonic dephasing channels, two-way classical communication does not raise the ultimate rate of quantum communication or key distribution. In practical terms, if the dominant noise on a link is pure phase noise and the input power is bounded, the best achievable rate is already captured by one-way coding, and the benchmark for any repeaterless protocol over such a link is the unassisted capacity. This contrasts with the pure-loss channel, where assistance changes the picture qualitatively.

The result also adds to a recent line of work on energy-constrained two-way capacities. The paper cites Pirandola’s result that, for the quantum-limited amplifier, the energy-constrained two-way capacities coincide with the unassisted ones, and a recent analysis of the pure-loss channel by Falco, Mele, Lami and Giovannetti.

Technical perspective (interpretation)

The following is my reading rather than a claim made in the paper. The proof works because the dephasing channel has a simple “classical skeleton”: photon number passes through perfectly, and all the noise lives in the phases. Measuring the output photon number turns any output into a state with no more entanglement than before, and the cost of skipping that measurement is exactly a coherent-information term. This is a structural reason why feedback cannot help: there is no erasure-like failure event that the parties could learn about and work around, which is what makes feedback useful for loss. It also suggests the technique is tied to channels that commute with photon-number dephasing, and would need new ideas for channels that change the photon number.

Limitations and open questions

• Scope of the result. It covers single-mode, pure bosonic dephasing channels with an average photon-number constraint. It says nothing directly about channels combining loss and dephasing, which the authors list as a natural next target.

• The formula still needs optimising. The capacity is expressed as an optimisation over photon-number distributions. The paper does not identify optimal distributions or give numerical capacity curves for specific phase-noise models; the authors flag this as open.

• Asymptotic statements. These are capacities, defined in the limit of many channel uses and vanishing error. Finite-blocklength rates, and whether assistance helps there, are not addressed.

• Purely theoretical. There is no experiment, simulation or code; the contribution is a set of proofs. The result is a preprint (v1) and has not yet been peer reviewed.

• AI assistance. The authors state that an AI system was used extensively as a research and writing assistant, including help developing the main solution and completing proofs, and that they reviewed and verified all AI-assisted content.

Paper information

• Title: No advantage from classical assistance for energy-constrained bosonic dephasing channels

• Authors: Amir Arqand and Graeme Smith (Institute for Quantum Computing, University of Waterloo)

• arXiv: 2610.13854 (v1, submitted 9 October 2026), quant-ph

• DOI: 10.48550/arXiv.2610.13854

• Code/data: none (theoretical paper)

Primary sources

• A. Arqand and G. Smith, arXiv:2610.13854 (HTML full text)

• L. Lami and M. Wilde, “Exact solution for the quantum and private capacities of bosonic dephasing channels,” Nature Photonics 17, 525–530 (2023)

• N. Davis, M. Shirokov and M. Wilde, “Energy-constrained two-way assisted private and quantum capacities of quantum channels,” Phys. Rev. A 97, 062310 (2018)

• A. Falco, F. Mele, L. Lami and V. Giovannetti, “Energy-constrained two-way capacities of the pure-loss channel,” arXiv:2610.12365

Over the past few years, a growing body of work has tried to give mixed quantum states — states that have been hit by noise, decoherence or measurement — the same kind of phase classification that ground states of gapped Hamiltonians enjoy. A central tool in that programme is the Markov length, which has been proposed as the mixed-state counterpart of the energy gap. In a new preprint, David C. Newsom and Michael Levin (University of Chicago) show that this quantity has a surprising weakness: even an arbitrarily weak layer of local noise, applied to the simplest possible state, can make the Markov length jump from zero to infinity.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth your time

The result is short (a 5-page main text plus 21 pages of appendices), explicit and checkable, and it goes straight at a conjectured stability property that several recent definitions of mixed-state phases rely on. If the Markov length is meant to play the role of a gap, one would like it to be stable: a state with a finite Markov length should keep a finite Markov length after a sufficiently weak finite-depth circuit of local channels. The paper shows that this fails in general, already for a pure product state, and then traces out what that means for proposed definitions of “same phase”.

What the paper does

The Markov length is defined through the conditional mutual information (CMI) I(A:C|B) between a region A and a distant region C, given a buffer B in between. A state has Markov length ξ if the CMI is bounded by a polynomial prefactor times e^{−dist(A,C)/ξ}; if no finite ξ works, the Markov length is infinite. Earlier work by Sang and Hsieh showed that if the Markov length stays bounded while a finite-depth channel circuit is applied, that circuit can be undone by another local channel circuit, one gate at a time. Follow-up work showed that states connected in this “locally reversible” way share long-distance properties such as topological degeneracy.

Newsom and Levin ask whether a finite Markov length survives weak local noise, and answer no in general. Their main results, all proved in the paper, are:

• A fermionic counterexample. Starting from the empty (vacuum) state of a one-dimensional chain of spinless fermions, a depth-two brickwork circuit of nearest-neighbour Gaussian channels produces a state whose CMI decays only algebraically with the buffer width — roughly as 1/n_B² for large regions. The Markov length is therefore zero at zero noise strength and infinite for every nonzero strength, no matter how small.

• Variants. The same behaviour appears for a time-independent local Lindbladian, for canonical bosons, and on an ordinary qubit chain, where the authors construct a local depth-two qubit channel that becomes arbitrarily weak.

• A general statement. The Markov length is unstable for any translation-invariant state with at least one rank-deficient reduced density operator on a finite region. The authors note that this class includes the toric-code ground state.

The key idea: a mode the noise cannot touch

Each two-site channel in the fermionic example works in three steps: bring in a fermionic ancilla in the maximally mixed state, couple it to the symmetric combination of the two neighbouring modes via a Gaussian unitary whose angle ε sets the noise strength, and trace the ancilla out. Because every channel couples only to symmetric combinations of neighbours, the staggered mode c_π = Σ_j(−1)^jc_j is orthogonal to all of them. This “dark mode” is never populated, so it stays exactly empty after the circuit.

That single exactly-empty mode is the whole story. In momentum space it shows up as a zero of the lower band of the state’s correlation matrix, which vanishes quadratically, λ₋(k) ≈ γk². The von Neumann entropy of a fermionic Gaussian state is a sum of h(x) = −x log x − (1−x) log(1−x) over correlation-matrix eigenvalues, and h is not analytic at x = 0. Feeding a quadratic zero into this nonanalytic function produces a logarithmic singularity in the second derivative of the entropy density in momentum space.

How it works

The technical route runs through Fourier analysis. For a ring of N unit cells, the entropy is a sum of the momentum-space function g(k) over N evenly spaced momenta. Smooth functions have rapidly decaying Fourier coefficients, but the logarithmic singularity makes g’s coefficients fall off only as 1/|m|³. As a result, the ring entropy picks up a correction proportional to ζ(3)/N² on top of the usual volume-law term.

For an interval of N unit cells, the authors show (heuristically in the main text, rigorously in an appendix using Toeplitz-matrix methods) that the entropy is a volume-law term, plus a constant from the endpoints, minus c/N² with c = γζ(3)/2. In the combination of entropies that defines the CMI, the volume and boundary terms cancel exactly, and the 1/N² terms do not. What remains is a CMI that decays as a power of the buffer width.

Two further observations sharpen the picture:

• The effect is fine-tuned. Changing the relative weights of the two sites in each channel, or starting from a finite-temperature product state instead of the vacuum, lifts the zero of λ₋. The CMI then decays exponentially again.

• Rényi entropies behave differently. For integer Rényi index n ≥ 2, the relevant entropy function is analytic at the endpoints, and the Rényi CMI decays exponentially even in the unstable state. For non-integer n, an algebraic tail reappears with exponent 2n. The n → 1 limit recovers the von Neumann result.

Why it matters

The authors spell out the consequences for two recent definitions of mixed-state phase equivalence: one requiring two-way connection by locally reversible circuits, and one requiring a one-way channel path along which the Markov length stays bounded. Under either definition, the noisy state they construct is not in the same phase as the product state it came from, for any nonzero noise strength. That conflicts with a requirement the authors regard as natural: the trivial phase should itself be stable, so a product state hit by sufficiently weak local noise should stay trivial. If one insists on this, the authors conclude, those definitions are too restrictive.

They also point out that the older definition based only on two-way channel connectivity avoids the problem, but at a cost: it puts the product state and the classical loop state in the same phase, even though the latter supports topological degeneracy and classical topological memory. Their suggested conclusion is that a good notion of mixed-state phase should sit between these extremes — coarser than the Markov-length-based criteria, finer than bare channel connectivity.

Technical perspective (interpretation)

The following is this article’s interpretation, not a claim made in the paper. The mechanism hinges on rank deficiency: an exactly pure “virtual” degree of freedom that weak noise cannot mix. Generic noise models tend to make reduced states full rank, which is why the paper’s examples need tuned channels or initial states. So the result does not suggest that Markov-length diagnostics fail in typical numerical studies of noisy topological codes. Its force is structural. Any definition of a phase that should hold for all weak local channels has to cope with these tuned cases. Pure or rank-deficient states — ground states of frustration-free models, for example — are exactly the starting points people care about.

A second practical point follows from the Rényi analysis. Because integer Rényi CMIs decay exponentially here while the von Neumann CMI does not, a study that diagnoses Markov length through a Rényi-2 proxy could miss this kind of instability entirely. The power-law tail is also slow, ~1/n_B², with a prefactor that vanishes as the noise strength goes to zero. In small-system numerics it could be hard to tell apart from a long but finite Markov length.

Limitations and open questions

• Initial states with full-rank reductions. The instability relies on the initial state having a rank-deficient reduced density matrix somewhere. The authors explicitly say they cannot rule out stability for initial states whose reductions are all full rank, such as the maximally mixed state or finite-temperature Gibbs states, and they cite partial stability results in that direction.

• Fine-tuning. The explicit examples require tuned channels and initial states. The general theorem is an existence statement: for any qualifying state, some arbitrarily weak circuit produces infinite Markov length. It does not say generic noise does.

• Is it intrinsically quantum? The authors leave open whether a classical analogue exists: whether weak local stochastic maps acting on a classical product distribution must always yield exponentially decaying CMI.

• What should replace the current definitions? The paper argues for an intermediate notion of phase equivalence but does not propose one.

Paper information

• Title: An Instability of the Quantum Markov Length

• Authors: David C. Newsom, Michael Levin (Leinweber Institute for Theoretical Physics, University of Chicago)

• arXiv: 2610.12929 (v1, submitted 9 October 2026), quant-ph; cross-listed to cond-mat.stat-mech

• DOI: 10.48550/arXiv.2610.12929

• Length: 5 + 21 pages, 3 figures. This is a theory paper; no code or data accompany it.

Primary sources

• D. C. Newsom and M. Levin, “An Instability of the Quantum Markov Length,” arXiv:2610.12929 (HTML full text).

• S. Sang and T. H. Hsieh, “Stability of mixed-state quantum phases via finite Markov length,” Phys. Rev. Lett. 134, 070403 (2025), arXiv:2404.07251 — where the Markov length and the stability question were introduced.

• S. Sang, L. A. Lessa, R. S. K. Mong, T. Grover, C. Wang, and T. H. Hsieh, “Mixed-state phases from local reversibility,” arXiv:2507.02292 — one of the definitions the paper challenges.

Most proposals for large fault-tolerant quantum computers spend the bulk of their hardware on one job: making magic states, the resource that turns cheap Clifford operations into a universal gate set. High-rate quantum LDPC (qLDPC) codes promise to store many logical qubits in far fewer physical qubits than the surface code, but they have lacked a native, high-throughput magic-state source that keeps their rate advantage. A new preprint from a Harvard–QuEra–Caltech–MIT collaboration proposes a complete factory built from qLDPC codes, and reports, in circuit-level simulations, CCZ magic states at roughly an order of magnitude lower space-time cost than magic state cultivation.

This article was drafted with Claude and fact-checked against the cited primary sources. In the interest of transparency: the paper’s acknowledgements state that the work was supported in part by Anthropic’s AI for Science program and that the authors used Claude models to assist with code search and simulation development.

What the paper does

In “Single-shot magic state factories for quantum LDPC codes” (arXiv:2610.10731), Varun Menon, Rohan Mehta and colleagues design an end-to-end protocol that produces encoded CCZ magic states directly inside high-rate qLDPC code blocks. The construction pairs two families of codes, each doing the job it is good at:

• Tricycle codes (three-dimensional balanced-product codes from recent work) support a transversal, constant-depth CCZ circuit, so they can generate several logical magic states in parallel. Their weakness is strongly asymmetric distances: in the pairs studied, each block encodes 3 logical qubits with a Z distance much smaller than its X distance, for example [[27,3,(6,3)]] or [[81,3,(15,5)]].

• Quadcycle codes, four-dimensional balanced-product codes found with an AI-assisted search, lack transversal non-Clifford gates but have larger, balanced distances (equal X and Z distance) and single-shot state preparation and error correction in both Pauli bases.

The magic is made in the tricycle code and then teleported, or in the authors’ word “escaped”, into the quadcycle code, where it can be stored and used.

The key idea: a depth-1 escape between related codes

A quadcycle code is defined by four commuting circulant matrices A, B, C, D over a finite abelian group; the first three are exactly the matrices that define its paired tricycle code, and D adds a fourth cyclic direction. The authors show that this shared algebra embeds every tricycle code into its quadcycle partner (formally, the quadcycle complex is a mapping cone of the tricycle complex). The practical consequence is a homomorphic CNOT between the two blocks that is a single transversal layer of physical CNOTs, and that couples all tricycle logical qubits to one half of the quadcycle’s logical qubits. All pairs used in the paper have twice as many quadcycle logical qubits as tricycle ones (k = 6 versus k = 3), which the authors prove is the maximum possible.

How the factory works

• Generate. Three tricycle blocks are prepared in |+⟩. A “fan-out” gadget, effectively concatenation with a distance-2 repetition code, turns the code’s depth-2 CCZ circuit into a strictly depth-1 transversal CCZ, which the authors show preserves the circuit-level distance. The result is a nine-qubit logical hypergraph magic state they call |det⟩, implementing the determinant of a 3×3 binary matrix.

• Escape. In parallel, three quadcycle blocks are prepared in |0⟩ with a single round of X-stabilizer extraction, possible because these codes are single-shot. The depth-1 homomorphic CNOT then teleports the logical state across.

• Postselect. The tricycle blocks are measured transversally in the X basis. Any run with a nontrivial detector is rejected; accepted runs receive Pauli-frame corrections. Because the measured tricycle blocks are small and short-lived, rejecting on every detector remains affordable, and it roughly doubles the number of faults needed for an undetected logical error. The fitted error exponents, 3.11 ± 0.04 for the tricycle-distance-3 factory and 3.91 ± 0.07 for distance 4, match the code distance rather than half of it.

• Use. Measuring one logical qubit of each quadcycle block converts |det⟩ into two disjoint CCZ states (the optimal yield), possibly dressed by CZ gates that are fixed using further transversal resource states. The paper also sketches injection by qLDPC code surgery.

What the simulations show

All results are numerical, under the standard circuit-level depolarizing model at physical error rate p = 10⁻³, with the physical CCZ gates assigned a noise channel of strength p or 2p, and decoding by a most-likely-error decoder. In the abstract, the authors report logical error rates as low as 10⁻⁹ per output logical qubit after postselection.

The headline comparison (the paper’s Table 1) is against magic state cultivation, using cultivation numbers estimated with mid-circuit postselection at matched CCZ-converted error rates. Expected space-time volume per CCZ state:

• At error rate 1.2×10⁻⁵ (fault distance 3): 4.3×10³ for this work, versus 80.4×10³ for surface-code cultivation and 162.8×10³ for color-code cultivation.

• At 1.2×10⁻⁶: 8.6×10³ versus 83.8×10³ for surface-code cultivation.

• At 1.6×10⁻⁸: 6.7×10⁴ versus 228.6×10⁴ for color-code cultivation.

These ratios are the source of the “10–40 times” figure. The authors also show that quadcycle codes such as [[72,6,8]] and [[162,6,14]] work as single-shot memories, with per-cycle logical error rates at p = 10⁻³ comparable to or below the error rate of the states the factory delivers, using a three-round sliding decoding window.

Finally, they compile the whole factory for reconfigurable neutral-atom arrays: every polynomial term becomes a uniform cyclic translation of atoms with acousto-optic deflectors, the transversal CCZ needs a single Rydberg pulse thanks to the fan-out gadget, and the full factory is bounded by 33 array-traversal times for the codes considered.

Why it matters

Recent qLDPC architecture proposals mostly solved storage and Clifford logic; non-Clifford gates were often delegated to surface-code machinery or left open. This work offers a qLDPC-native answer whose output is already encoded in a high-rate block, and whose depth does not grow with code distance because both code families are single-shot in the bases that matter.

Technical perspective (interpretation)

The conceptual move worth noticing is the division of labour: one code with transversal non-Clifford gates but poor distance, chained by a single transversal layer to a structurally related code with good distance and single-shot decoding. It resembles a dimension-jump code switch, but here the receiving code is chosen so that no growth, repetition or second distillation round is needed. My reading is that the approach is less a single code construction than a template, and its value will depend on whether matched code pairs with higher rates keep the same clean properties. The authors note that higher-rate tricycle codes exist but produce harder-to-use hypergraph states and deeper CCZ circuits.

Limitations and open questions

• Simulation only. No hardware demonstration is reported; all numbers come from circuit-level simulations.

• Accounting boundaries. Table 1 excludes the cost of extracting the two CCZ states and of injection for this work, the T-to-CCZ conversion for cultivation, and decoder latency for every scheme. Cultivation numbers are estimated from other studies, normalized by assuming four T states per CCZ.

• Noise modelling. Only one of the three tricycle–quadcycle pairs is simulated; the CCZ channel is reduced to its single-qubit marginal, and full-factory acceptance is taken as the cube of a single pair’s acceptance. The authors argue this is conservative, but it is an approximation.

• Decoder. The most-likely-error decoder is too slow for real-time use at scale; the authors point to machine-learning and hierarchical decoders as possible practical substitutes.

• Distances. Quadcycle distances are exact only up to n = 72; larger ones are estimates.

• Full-algorithm cost. How the savings translate into total qubit count and runtime for algorithms such as Shor’s is left to future work.

Paper information

• Title: Single-shot magic state factories for quantum LDPC codes

• Authors: Varun Menon, Rohan Mehta, Andi Gu, Andrei C. Diaconu, Daniel Bochen Tan, Xiao Xiao, Michael J. Gullans, Qian Xu, Hengyun Zhou, Mikhail D. Lukin, J. Pablo Bonilla Ataides

• Affiliations: Harvard University; QuEra Computing; Joint Center for Quantum Information and Computer Science, University of Maryland; Caltech (IQIM and Walter Burke Institute); MIT

• arXiv: 2610.10731v1 [quant-ph], submitted 7 October 2026

• DOI: 10.48550/arXiv.2610.10731

• Code and data: no code repository is linked; an atom-movement animation is provided as an ancillary file on arXiv.

Primary sources

• arXiv abstract page: arxiv.org/abs/2610.10731

• Full text (HTML): arxiv.org/html/2610.10731v1

• PDF: arxiv.org/pdf/2610.10731v1

Quantum LDPC codes promise to store many logical qubits in comparatively few physical ones. But storing information is only half of fault tolerance: a computer also has to measure chosen logical operators, and lattice surgery has become a leading way to do that. A short new paper by Nouédyn Baspin asks a blunt question about the price of flexibility: if you want to be able to measure any choice of logical operators on a sparse code, how large must your surgery ancilla be? The answer is a lower bound that grows quadratically with the number of logical qubits.

This article was drafted with Claude and fact-checked against the cited primary sources.

What the paper does

The paper, “A lower bound on the overhead of surgery on sparse stabiliser codes” (arXiv:2610.11097v1, submitted 8 October 2026), proves a no-go theorem. For a stabiliser code on n physical qubits with k logical qubits, any family of surgery ancillas that is sparse, and that can realise every measurement in a sufficiently rich set, must contain ancillas of size at least Ω̃(k²) in the worst case. The abstract summarises the consequence: for codes with large k, constant-overhead ancillas can only realise a small fraction of the possible measurements.

The paper is theoretical and short: two main results (Lemma 2 and Theorem 3) and two auxiliary counting lemmas. There are no simulations, experiments or code.

The key idea: addressability costs information

The central observation is a counting argument. Suppose a surgery scheme can measure every logical subspace in some set ℱ. Each measurement is carried out by attaching an ancilla complex and a “gluing” map to the code. If the ancilla has at most N^⋆ qubits-and-checks and all of its maps are sparse, then there simply are not many distinct sparse ancillas of that size. Since different measurements need different ancilla–map pairs, a large ℱ forces a large N^⋆.

Lemma 2 makes this quantitative: N^⋆ ≥ Ω(log|ℱ| / (ω log n)), where ω bounds the row and column weights of the relevant maps. In words, the space cost scales with the logarithm of the number of measurements you want access to. The author calls this property addressability: the ability to prescribe exactly which logical degrees of freedom are read out.

How the argument works

• Framework. The code is written as a “symplectic complex” and surgery with a CSS ancilla is expressed as a symplectic embedding, following a framework the paper cites as yuan2026noncss. In this language, the ancilla together with its chain map determines which logical subspace is measured (Definition 1).

• Counting sparse matrices. Lemma 4 shows there are at most (1+s)^ωt ω-sparse binary matrices of size s × t. Applying this to the ancilla’s boundary map and to the map gluing it to the code, and summing over the possible ancilla dimensions, bounds the number of distinct ancilla constructions by an expression of the form (1+N^⋆)²((1+N^⋆)(1+2n))^ωN⋆.

• Counting measurements. Theorem 3 fixes a basis splitting the logical operators into X-type and Z-type, and considers only the measurements of k/2-dimensional subspaces of the X-type logicals. These automatically commute, so all are valid. A standard bound (Lemma 5, cited as koetter2007coding) says there are at least 2^r(l−r) subspaces of dimension r in a space of dimension l; with r = k/2 and l = k this gives at least 2^k2/4 measurements.

• Result. Combining the two counts gives N^⋆ ≥ Ω(k² / (ω log n)).

Why it matters

The paper compares its bound with a known construction of parallel surgery (cited as cowtan2025parallel), which can measure any set of t commuting logicals on an n-qubit QLDPC code with at most Õ(tn) ancilla qubits. For constant-rate codes, where k grows proportionally to n, taking t ∝ n gives Ω̃(n²) ≤ N^⋆ ≤ Õ(n²). In that regime the upper bound is almost tight: fully addressable parallel surgery cannot be done with much less space than existing constructions use, as long as everything stays sparse.

The author also notes that the bound “seems to point towards” a space–time trade-off: to save space, a scheme must restrict how many different logicals can be measured in each surgery step, which in turn means more rounds of surgery. And it comments on a recent near-linear-overhead construction (cited as cowtan2026nearoptimal) that relies on suitable subcodes: by Theorem 3, such subcodes are in limited supply for codes with many logical qubits, so that approach does not generically give addressability.

The timing is notable. The same quant-ph listing also included “2 Fast 2 Surgery: Fast surgery on QLDPC codes with Õ(n(k + d)) space overhead” (arXiv:2610.11079). We have not reviewed that paper here, but its title alone shows how actively the space cost of surgery on QLDPC codes is being pushed down from above, which makes a lower bound from below especially useful.

Technical perspective (our interpretation)

The argument is information-theoretic rather than structural. It does not identify which measurements are expensive; it shows that a sparse ancilla of size N^⋆ can only “encode” roughly ωN^⋆ log n bits of choice, while selecting an arbitrary k/2-dimensional logical subspace needs on the order of k² bits. Put differently, a fully addressable surgery gadget has to be big enough to describe the measurement it performs.

This framing suggests where the bound bites and where it does not. Architectures that only ever need a small, fixed menu of logical measurements, or that compile computations into many rounds with limited parallelism, are not ruled out from having small ancillas. The bound targets the attractive but demanding goal of arbitrary, fully parallel logical measurements on high-rate codes. For architecture designers this reframes a design choice: rate, addressability and ancilla space cannot all be maximised at once under sparsity.

Limitations and open questions

• Model assumptions. The theorem applies to surgery in the paper’s symplectic-embedding formalism with a CSS ancilla, where both the ancilla’s boundary map and the gluing map are ω-sparse. Schemes outside this model, or with non-sparse ancillas, are not covered.

• Worst case, up to logs. The bound concerns the largest ancilla needed across a set of measurements and hides factors of ω and log n. It does not say that typical or most-used measurements are expensive.

• Space only. The result constrains ancilla size, not time. The suggested space–time trade-off is described by the author as an indication, not a proved statement.

• Tightness. Near-tightness is shown for constant-rate codes against the cited Õ(tn) construction. For other rate regimes the gap between upper and lower bounds is not settled in this paper.

• Status. This is a v1 preprint and has not been peer reviewed.

Paper information

• Title: A lower bound on the overhead of surgery on sparse stabiliser codes

• Author: Nouédyn Baspin (Iceberg Quantum, Sydney, Australia)

• arXiv: 2610.11097v1 [quant-ph], submitted 8 October 2026

• DOI: 10.48550/arXiv.2610.11097

• Code/data: none (theoretical paper)

Primary sources

• Paper (abstract page): arxiv.org/abs/2610.11097

• Full text (HTML): arxiv.org/html/2610.11097v1

• Same-day related listing: arXiv:2610.11079 (2 Fast 2 Surgery)

Entanglement distillation asks a deceptively simple question: given many copies of a noisy entangled state, how many near-perfect Bell pairs (ebits) can you extract per copy? For most mixed states nobody knows the answer, even if we relax the rules and allow the larger class of PPT operations instead of local operations and classical communication (LOCC). For PPT distillation, one natural candidate answer had been on the table for years: the regularised Rains bound. A new preprint by Ludovico Lami shows that this candidate is wrong, and gives a certified counterexample using a two-qutrit Werner state.

This article was drafted with Claude and fact-checked against the cited primary sources. One more disclosure belongs up front, because the paper makes it itself: in a note at the start of the introduction, the author states that the main results and techniques “have been derived almost entirely by ChatGPT Astra”, with the human author extending the initial findings and spending many hours validating and improving the proofs.

What the paper does

The paper studies PPT entanglement distillation in the standard quantum Shannon theory regime: the error must vanish asymptotically but may be non-zero for any finite number of copies. PPT channels are those that remain completely positive when conjugated by the partial transpose; they contain every LOCC protocol, so the PPT distillable entanglement E_d,PPT upper-bounds the LOCC distillable entanglement. The author lists three main contributions:

• A regularised formula (Theorem 1) expressing E_d,PPT exactly as the regularisation of a measurement-based, relative-entropy-like quantity.

• Two new converse bounds (Theorems 2 and 3): one built from quadratic forms on operator spaces, the other from Hirschman’s strengthening of the Hadamard three-line theorem. Both give exponential strong converses.

• A strict separation (Theorem 4): for the 3×3 Werner state with antisymmetric weight p = 25/26, the PPT distillable entanglement is at most 0.62107 ebits, while the regularised Rains bound equals (25/26) log₂5 − log₂3 ≈ 0.64766 ebits.

The last result answers in the negative the conjecture, stated explicitly in Regula et al. (New J. Phys. 21, 103017, 2019), that E_d,PPT always equals the regularised Rains bound.

The key idea

The Rains bound measures how far, in relative entropy, a state is from operators σ whose partial transpose has trace norm at most one. Its regularised version R^∞ was the tightest known upper bound on PPT distillation and, by a previous result cited in the paper, it is computable. If E_d,PPT had equalled R^∞, PPT distillation would have been “solved” in a strong sense.

The paper’s strategy is to look at a distillation protocol through the only test that matters at the end: the overlap of the output with a maximally entangled state. For PPT channels this overlap reduces to a semidefinite constraint on a test operator Q (0 ≤ Q ≤ 1, with the operator norm of its partial transpose bounded by 1/d). Pulling this test back to the input gives both directions of the new formula: the achievability side uses a fixed measurement plus classical typicality, and the converse side uses the two-outcome measurement obtained from the protocol’s Bell test.

How it works

The formula. Theorem 1 defines L(ρ) as a supremum over POVMs {E_j} of a sum of terms Tr[ρE_j] log(Tr[ρE_j] / ‖E_j^Γ‖_∞), and proves E_d,PPT(ρ) = lim_n L(ρ^⊗n)/n. Restricting to projective measurements recovers an older bound of Rains. Because any finite POVM gives a valid lower bound, this yields an increasing sequence of computable lower bounds; the author is careful to note that this lower semicomputability was already obtainable by other means and that no convergence speed is known.

A quantitative negativity bound. As a by-product, the paper proves E_d,PPT(ρ) ≥ 1 − h₂(1/2 + N(ρ)/(d+1)), where N is the negativity, h₂ the binary entropy and d the smaller local dimension. This turns the known qualitative fact (Eggeling et al., 2001) that every state with a non-positive partial transpose is PPT-distillable into an explicit positive rate.

Two converses. The quadratic-form converse E_Q controls how a distillation test interacts with a chosen positive super-operator, with an optional ancillary extension; choosing right multiplication recovers the Rains bound, and other choices can beat it. The analytic converse E_A embeds the input in an analytic family of operators on an annulus and averages two trace-norm bounds over its two boundary circles with Hirschman’s weights; quantum hypothesis testing then transfers the bound back to the actual state.

The Werner certificate. Werner symmetry shrinks everything to small, checkable problems. On the upper-bound side, a two-dimensional quadratic-form calculation already gives a value of about 0.63309, below R^∞; an explicit annulus family, with its boundary integral bounded using directed rounding, gives 0.62107. On the lower-bound side, an exactly feasible 48-copy, 49-outcome POVM certifies 0.5836 ebits. So for this state the true PPT rate lies in roughly [0.5836, 0.6211], strictly below 0.6477.

Why it matters

Demonstrated in the paper: the regularised Rains bound is not the PPT distillable entanglement, already for a highly symmetric two-qutrit state. Since every LOCC protocol is PPT, the new converses also join the list of upper bounds on LOCC distillation, which the paper summarises as E_d,LOCC ≤ min{R^∞, E_sq, E_Q, E_A}, with E_sq the squashed entanglement.

The author also notes a consequence for computability: had E_d,PPT equalled R^∞, known algorithms for R^∞ would have made it Turing-computable. The separation removes that route without ruling out computability by other means.

Technical perspective (interpretation)

This is my reading, not a claim made in the paper. The result fits a pattern seen across quantum resource theories: the “obvious” relative-entropy-style monotone, regularised, is often not the operational answer once errors are only required to vanish asymptotically. What stands out here is how concrete the counterexample is. The gap between 0.62107 and 0.64766 is small, about 0.027 ebits, but it is certified with rational witnesses and interval arithmetic rather than inferred from floating-point optimisation.

The authorship note is also worth taking seriously on its own terms. The paper is explicit that an AI system produced most of the mathematics and that the human author validated it. That makes independent checking of the certificates, which the paper says run with only the Python standard library, especially valuable.

Limitations and open questions

• No closed formula yet. Theorem 1 is a regularised expression; there is no single-letter formula and no guarantee on how fast the lower bounds converge.

• The Werner gap remains open. For p = 25/26 the rate is pinned only to the interval [0.5836, 0.6211]; Figure 1 shows a visible gap between achievable and converse curves across the whole range of non-PPT Werner states.

• Computability is still undecided. The paper states that a convergent computable family of upper bounds remains open.

• PPT, not LOCC. The separation concerns PPT distillation. It improves upper bounds on LOCC distillation but does not compute the LOCC rate.

• Verification status. This is a v1 preprint and has not been peer reviewed. The text describes a companion certificate supplement (README, manifest of SHA-256 hashes, and a verification script), but the v1 abstract page lists no ancillary files and the PDF gives no download link for it. The v1 text also has some rough edges, such as a duplicated figure caption with inconsistent equation references.

Paper information

• Title: On PPT entanglement distillation

• Author: Ludovico Lami (Scuola Normale Superiore, Pisa)

• arXiv: 2610.12454v1 [quant-ph], submitted 8 October 2026

• DOI: 10.48550/arXiv.2610.12454

• Length: 31 + 7 pages, 1 figure

• Code/data: a computational certificate supplement is described in Appendix F; no public link in v1

Primary sources

• Paper (abstract page): arxiv.org/abs/2610.12454

• Full text (PDF): arxiv.org/pdf/2610.12454v1

• Conjecture addressed: B. Regula et al., New J. Phys. 21, 103017 (2019)

• Background: E. M. Rains, “A semidefinite program for distillable entanglement”, IEEE Trans. Inf. Theory 47, 2921 (2001)

For years, Tsirelson’s problem was one of the cleanest open questions linking quantum information to operator algebras: can every correlation produced by commuting measurements on a single Hilbert space be approximated by measurements on finite-dimensional tensor products? The 2020 MIP*=RE result of Ji, Natarajan, Vidick, Wright and Yuen answered “no”. A new preprint by Minbo Gao, Tianshi Yu and Lihong Zhi does something different: it writes down a specific, finite nonlocal game that witnesses the separation, computes its classical value exactly, and checks the main claims in the Lean 4 proof assistant.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth reading

Knowing that a separating game exists is different from holding one. The authors construct a binary linear system game with 1,417,152 equations in 1,889,684 variables, each equation involving exactly three variables, and a right-hand side with a single nonzero entry. They prove that commuting-operator players can win it with probability 1, while every strategy in C_qa (the closure of finite-dimensional quantum correlations) succeeds with probability strictly less than 1. The complete system is specified in Lean 4, and the separation and the exact classical value are formalized using Mathlib.

What the paper does

The paper works with the standard correlation sets for a two-player game: C_q (finite-dimensional tensor-product strategies), its closure C_qa, and C_qc (commuting-operator strategies on one Hilbert space of arbitrary dimension). Tsirelson’s problem in its approximation form asks whether C_qa = C_qc; the paper notes that this is equivalent to Connes’ embedding conjecture.

The main results, as stated by the authors:

• A finite two-player game G with payoffs in {0,1} satisfying ω_q(G) = ω_qa(G) < 1 = ω_qc(G), so C_qa ≠ C_qc for its question and answer sets.

• The exact classical value: ω_c(G) = 1 − 1/4,251,456 (the game has 3m = 4,251,456 equally likely question pairs).

• Explicit bounds on the quantum gap: 2^(−2^50003) ≤ 1 − ω_q(G) ≤ 1/4,251,456, with the lower bound independent of the local dimension. This quantitative lower bound is proved in the Lean development (Remark 6.6).

The key idea

In a binary linear system game, Alice receives an equation and returns values for its three variables; Bob receives one variable and returns its value. They win if Alice’s values satisfy the parity constraint and agree with Bob’s. Earlier work by Cleve, Liu and Slofstra ties perfect commuting strategies to an algebraic object, the solution group of the system: a perfect commuting strategy exists exactly when a distinguished central involution J is nontrivial in that group. Slofstra and Vidick gave a matching criterion for the finite-dimensional side: the quantum value equals 1 only if there are approximate matrix representations of the solution group, with relation errors tending to zero, in which J stays a fixed distance from the identity.

So the task reduces to group theory: build a finitely presented solution group in which J is genuinely nontrivial, yet is forced towards the identity in every approximate unitary matrix representation, uniformly in the matrix dimension. The authors call this property uniform asymptotic triviality.

How the construction works

The paper assembles the group in stages, each with explicit generators and relations:

• A Kazhdan pair. A finitely presented group Q on 48 generators and a subgroup H generated by 24 specified elements, both with Kazhdan’s property (T), built from finitely presented Kazhdan covers of Ershov and Jaikin-Zapirain over the field with five elements. A shear element t compresses H strictly into itself (tHt⁻¹ is a proper subgroup of H); this is proved with a Laurent-polynomial matrix model.

• Normalization. Thom’s normalization theorem, made unconditional by a spectral gap theorem of Alekseev, Liu and Thom, implies that in any homomorphism into a tracial matrix ultraproduct, a specified commutator word w in the amalgamated double Q *_H Q is sent to the identity, even though w has infinite order in the group.

• A central involution. An HNN-type extension adds a central involution J and a generator z with zwz⁻¹ = wJ. J stays nontrivial in the group, but any representation that kills w must also kill J. The resulting group Λ has 74 generators.

• Linearization. Slofstra’s embedding techniques (involution substitution and “wagon wheel” constructions) embed Λ into the solution group of an explicit binary linear system, with J mapped to the game’s distinguished involution. That system is the 1,417,152 × 1,889,684 matrix in the title result.

The perfect commuting strategy is then concrete: the left and right regular representations of the solution group, restricted to the subspace where J acts as −1. The classical value is also simple to pin down: because the system is inconsistent, every deterministic strategy loses at least one question pair, and the authors exhibit a strategy that loses exactly one.

Why it matters

MIP*=RE settled the yes/no question. This paper offers a finite object that can be generated, stored and checked. The authors state that the Lean results “use no admitted proofs or unproved mathematical hypotheses”, and the repository includes an axiom audit permitting only Lean’s standard axioms (propext, Classical.choice, Quot.sound). For a result whose informal proof chains together property (T), ultraproducts, combinatorial group theory and nonlocal games, a machine-checked end-to-end statement is a substantial form of evidence.

Technical perspective (interpretation)

The following is my reading, not a claim made by the authors. The quantitative bounds show how far this is from anything physically testable: the gap 1 − ω_q is at least 2^(−2^50003) and at most about 2.4 × 10⁻⁷, and even the classical value is within 1/4,251,456 of perfect. The significance is mathematical and foundational: the separation becomes a certificate rather than an existence theorem. The paper also illustrates a route to C_qa ≠ C_qc through group-theoretic rigidity (Kazhdan groups and normalization) instead of the compression-of-games machinery behind MIP*=RE, and it sits alongside related work by Wang and Zhi that uses the same normalization mechanism for an explicit polynomial counterexample to Connes’ embedding conjecture. Whether the construction can be shrunk to something humanly inspectable is an open, interesting question.

Limitations and open questions

• The gap is tiny and not effective in practice. The proven lower bound 2^(−2^50003) is astronomically small; the game is a mathematical witness, not an experimental proposal.

• The formalization has a stated scope. Appendix B notes that some intermediate results are formalized only for the specific instance or only in the direction needed. For example, full injectivity of the map from Λ into the solution group is not formally proved (the authors explain why the weaker statements suffice), and only the needed implication of the Slofstra–Vidick criterion is formalized. The authors state that the correspondence between the formal definitions and the paper’s claims remains their responsibility.

• Recent ingredients. Several cited inputs, including the Alekseev–Liu–Thom spectral gap theorem and Thom’s normalization theorem, are recent arXiv preprints. The Lean development formalizes the analytic ingredients it uses, according to the paper’s concordance tables, but expert review of the whole argument is still to come.

• AI-assisted development. The paper’s AI-use declaration states that generative AI tools were used in mathematical exploration, the Lean code, and drafting; the authors state that they reviewed the proofs and the formalization and take full responsibility.

• Size. With about 1.4 million equations, the game is explicit but large. Smaller separating games remain open.

Paper information

• Title: An Explicit Counterexample to Tsirelson’s Problem via a Linear System Game

• Authors: Minbo Gao (Institute of Software, CAS; UCAS; Tencent Hunyuan), Tianshi Yu (Institute of Software, CAS), Lihong Zhi (Academy of Mathematics and Systems Science, CAS; UCAS)

• arXiv: 2610.10248v1, submitted 7 October 2026 (31 pages); quant-ph, cross-listed to math.FA and math.OA

• DOI: 10.48550/arXiv.2610.10248

• Code: Lean 4 / Mathlib formalization on GitHub

Primary sources

• Paper (abstract page): arxiv.org/abs/2610.10248

• Full text (HTML): arxiv.org/html/2610.10248v1

• Formalization repository: explicit-linear-system-game-formalization

• Background: Ji, Natarajan, Vidick, Wright, Yuen, “MIP* = RE”, arXiv:2001.04383; Slofstra and Vidick, arXiv:1711.10676

When an old black hole emits one more qubit of Hawking radiation, the information needed to recover that qubit’s entangled partner is, in principle, already sitting in the earlier radiation. Whether anyone could actually extract it in time has been a central question since the firewall debate. A new preprint by Ezekiel Cochran and Atul Mantri (Virginia Tech) gives a sharp answer in an idealised model: if the black hole’s dynamics is a Haar-random unitary that the decoder can query, recovering even a single qubit with any constant advantage over guessing requires a number of queries proportional to the Hilbert-space dimension of what remains of the black hole, and that count is tight.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth reading

The “computation versus firewalls” line of work, starting with Harlow and Hayden (2013), argued that the decoding task behind the firewall paradox of Almheiri, Marolf, Polchinski and Sully is likely too hard to finish before the black hole evaporates. Those arguments rest on complexity assumptions and give worst-case hardness. This paper instead proves an unconditional query lower bound in an explicit oracle model, matches it with an existing algorithm, and then turns the same hardness into cryptography: an EFI pair and quantum commitments built from a public Haar-random oracle.

What the paper does

The setup follows the Hayden–Preskill picture. A reference qubit B is maximally entangled with one of n input qubits; the other n−1 inputs start in |0⟩. A Haar-random unitary U acts on all n qubits, and the output is split into radiation R and the remaining black hole H. The decoder receives R (never B or H) and must output a qubit A that is entangled with B. It may query U, with arbitrary computation between queries.

Success is measured by the Haar-averaged squared Bell-state fidelity between B and A. Outputting a qubit that ignores R scores exactly 1/4, so the question is what it costs to beat 1/4 by any fixed margin δ.

The main results, stated for |R| ≥ |H| and for decoders whose circuit and initial auxiliary state are chosen independently of the sampled U, are:

• Forward-only access: Ω(2^|H|) queries are required.

• All four query types (U, U^†, U^*, U^T, including controlled versions and a coherent choice among them): Ω(min{2^|H|, 2^n/16}) queries are required. The two bounds coincide when |H| ≤ n/16.

• The same bounds hold for a fixed decoder that succeeds only on a constant fraction of Haar oracles.

• Matching upper bound: for |R| ≥ |H| + 1, specialising the Uhlmann-transformation algorithm of Utsumi, Nakata, Wang and Takagi gives a decoder using O(2^|H|) forward and inverse queries at fixed error, with Haar-averaged fidelity at least 1 − 2·2^{(|H|−|R|)/2} − ε.

So in the regime where the black hole retains at most one sixteenth of the qubits, the query complexity of radiation decoding is pinned down: Θ(2^|H|), for any fixed target fidelity between 1/4 and 1.

The key idea

Rather than analysing decoders directly, the authors study an easier distinguishing task. A distinguisher receives the joint state on BR and query access to U, and must tell whether that state came from the real experiment or is simply maximally mixed. Any good decoder yields a good distinguisher: run the decoder and test BA for the Bell state. In the real experiment this accepts with the decoder’s fidelity; in the mixed experiment it accepts with probability exactly 1/4. A decoding advantage of f − 1/4 therefore becomes a distinguishing advantage of (f − 1/4)/2 with the same queries.

The intuition for hardness is that the real BR state has low rank (it is purified by the hidden register H, so its rank is at most 2^|H|), yet the only handle a decoder has on the hidden part H is through queries to a random unitary that reveal almost nothing about it per call.

How the proof works

The technical engine is the path-recording oracle of Ma and Huang, extended to all four query types by Schuster et al. It replaces Haar queries with explicit maps that write a “record” of queried input–output pairs into hidden registers, with a provable approximation error. For forward-only queries that error is O(q²/2ⁿ); for all four types it is O(q²/2^n/8). The second figure is where the 2^n/16 cutoff in the main theorem comes from.

In the recording picture, the real and mixed experiments differ only in where one input–output pair, the “challenge pair” produced when U prepared the radiation, is stored: inside the oracle’s record (real) or in a separate untouched register (mixed). The authors introduce an insertion map J, following the merge-map method of Ananth et al., that moves the challenge pair into the record and exactly maps the mixed initial state onto the real one. Two error sources then have to be controlled:

• J is not an isometry. After insertion the record “forgets” which pair was the challenge, which can create interference between query histories. Because the algorithm never touches H, its weights cannot correlate with the hidden label, and the resulting error is bounded by counting at most q recorded pairs.

• J does not commute with queries. Inserting the challenge first can block or enable a coordinate that a creation or deletion step would otherwise use. The authors bound the commutator of J with each primitive creation and deletion map and sum the errors over the q queries in a hybrid argument.

Both errors scale with q/2^|H|, which gives the Ω(2^|H|) lower bound once the Haar-approximation errors are added back.

Why it matters

The paper gives three applications from the same comparison:

• EFI from a public Haar oracle. With |H| = λ, |R| = 2λ and n = 3λ, the real BR state and the maximally mixed state are efficiently preparable, have trace distance at least 1 − 2^−λ−1, and yet any algorithm with oracle-independent circuit and advice making polynomially many queries has expected absolute distinguishing gap O((q+1)²·2^−λ/16).

• Quantum commitments. Via the construction of Brakerski, Canetti and Qian, the EFI pair gives a computationally hiding, statistically binding bit commitment with perfect correctness. The Haar encoding also gives a direct one-qubit commitment: send R, later reveal H. The authors prove computational hiding and statistical swap binding (advantage at most 2·2^−λ/2), using one forward query to commit and one inverse query to verify.

• A tight Uhlmann lower bound. On a fixed-target family with |R| = 15|H|, any Uhlmann transformation achieving squared-fidelity error up to 1/8 needs Ω(r) preparation queries, where r = 2^1+|H| is the relevant rank, matching the known O(r) upper bound, even with all four query types.

Technical perspective (interpretation)

My reading is that the most useful contribution is less the black-hole framing than the clean, quantitative hardness of distinguishing low-rank radiation from noise under the strongest natural access model. The Kim–Tang–Preskill hypothesis that low-rank radiation is computationally indistinguishable from maximally mixed has been used as a working assumption; the paper describes its bounds as a quantitative analogue of that hypothesis in the Haar-random oracle model. Including U^* and U^T access matters: the efficient Yoshida–Kitaev decoder uses conjugate access (when it also holds a partner of the initial black hole), and conjugate queries are known to give exponential advantages in other tasks. Showing they do not help here is a substantive point.

It is also notable that the cryptography needs no secret key. The commitment uses only the public oracle and quantum communication, which speaks to a question raised by Schuster et al. about whether natural, publicly known scrambling dynamics can carry cryptographic properties.

Limitations and open questions

• It is an oracle result. The bounds are about query access to an ideal Haar-random unitary, not about real black-hole dynamics or efficiently implementable scramblers. The authors themselves note that complexity-based hardness is a worst-case statement rather than a statement about every physical black hole.

• Oracle-independent decoders. The lower bound assumes the decoder’s circuit and auxiliary state are chosen independently of the sampled U. Decoders with U-dependent advice are outside its scope.

• Regime. The results assume |R| ≥ |H|, and the all-four-query bound is tight only for |H| ≤ n/16; beyond that the 2^n/16 cutoff is an artefact of the Haar approximation used in the proof.

• Queries, not gates. The bounds count oracle queries and allow unbounded computation in between, so they say nothing additional about gate complexity.

• Cryptography is relative to the oracle. Security is stated as an expected gap over a public Haar oracle against oracle-independent algorithms. Instantiating it with a concrete family of unitaries would need further assumptions.

• Preprint status. This is a 67-page v1 preprint that has not yet been peer reviewed. The authors include an AI disclosure: they state that Claude and ChatGPT models helped draft and edit proofs, that they replaced the AI-generated drafts with simpler proofs of their own, and that they checked all proofs and take full responsibility.

Paper information

• Title: Black Hole Radiation Decoding in the Haar Random Oracle Model

• Authors: Ezekiel Cochran, Atul Mantri (Department of Computer Science, Virginia Tech)

• arXiv: 2610.07124v1 [quant-ph], also cs.CC and cs.CR; submitted 5 October 2026; 67 pages, 4 figures

• DOI: 10.48550/arXiv.2610.07124

• Code/data: none (theory paper)

Primary sources

• arXiv abstract page: arxiv.org/abs/2610.07124

• Full text (HTML): arxiv.org/html/2610.07124v1

• PDF: arxiv.org/pdf/2610.07124v1

The Eastin–Knill theorem is one of the first walls anyone designing a fault-tolerant quantum computer runs into: no quantum code that detects single-qubit errors can have a universal set of transversal logical gates. That is why practical architectures lean on extra machinery such as magic-state factories, lattice surgery or code switching. A new paper by Arpit Dua, Adam Holmes, Michael J. Gullans and Victor V. Albert points out that the theorem constrains one fixed partition of the qubits at a time, and builds a large catalogue of codes that exploit exactly that loophole.

This article was drafted with Claude and fact-checked against the cited primary sources.

What the paper does

The authors construct qubit CSS codes in which every generator of a universal logical gate set is a single depth-one layer of few-qubit gates, followed by ordinary error correction of the same stabilizer code. In their words, there is no magic-state distillation, code switching, gauge fixing or lattice surgery in the generating set. They call such codes depth-one universal.

A layer of disjoint gates that each touch at most ℓ qubits is called ℓ-fold transversal; the usual transversal gate is the case ℓ = 1, where only one partition exists. With ℓ = 2 or more, different layers can respect different partitions of the qubits. The paper notes that layers on any single partition (with parts smaller than the distance) generate only a finite logical group, but layers on several partitions together can generate a universal one. This does not contradict Eastin–Knill; it uses a case the theorem does not cover.

The concrete output is a catalogue of 110 codes, provided as an ancillary JSON file, with 12 to 1369 physical qubits, 1 to 210 logical qubits, distances from 3 to 49 and gate widths from 2 to 10. According to the abstract, 47 of them have depth-one generating sets that tolerate at least one faulty gate per layer, including a [[37,1,7]] and a [[59,1,9]] code with stabilizer checks of weight at most eight.

The key idea: turn seed qubits into parities

The non-Clifford gate is the hard part, and the paper explains where it comes from with a seed–kernel construction. Start with a small “seed” code that already has a non-Clifford logical gate that is diagonal in the computational basis — for example, transversal T on the 15-qubit quantum Reed–Muller code. Add a second “kernel” code (often just qubits in |+⟩ or a few GHZ states) and couple the two with a CNOT circuit.

The CNOTs write each seed qubit’s bit into the parity of a small set of physical qubits. Because a diagonal gate only multiplies basis states by phases that depend on those bits, the same gate evaluated on the parities has exactly the same logical action. A seed’s single-qubit T gates therefore become small multi-qubit gates acting on parities, still in one depth-one layer, while the kernel raises the code distance.

How it works in practice

Two small examples anchor the construction. The 16-qubit tesseract code, a [[16,6,4]] code, gets a universal set from four two-qubit layers on four different partitions: three Clifford layers plus a non-Clifford layer that implements a logical CCZ. The authors show it inherits that layer from the [[8,3,2]] “cube” color code via exactly this parity mechanism. The [[12,2,4]] Carbon code arises from a distance-two seed coupled to a four-qubit kernel; its non-Clifford layer becomes a set of three-qubit gates implementing a logical controlled-S (up to Clifford gates). Both codes only detect a faulty native gate, so they need post-selection.

The construction comes with exact limits. The code distance is at most the gate width times the Z distance of the seed, so the 15-qubit seed with width-three gates caps out at distance 9 — which the [[59,1,9]] codes reach. More importantly for fault tolerance, the partition distance of the parity layer (how many faulty gates it takes to cause a logical error) can never exceed the seed’s Z distance, however large the overall code distance becomes. A distance-three seed thus gives a non-Clifford layer that can correct at most one faulty gate.

The flagship example is a [[37,1,7]] code built from the 15-qubit Reed–Muller seed and a 22-qubit kernel of four GHZ triples and ten |+⟩ qubits. Its generators are a T† parity layer (seven three-qubit and eight two-qubit gates), an S† layer, an X-rotation layer on seven disjoint triples, and a bitwise CNOT between two code blocks. The authors give a flagged syndrome-extraction round on 88 qubits with 192 CNOTs in 12 layers and prove it preserves the circuit distance of 7.

They then simulate this code with Stim and the Tesseract decoder under a neutral-atom-style circuit noise model at two-qubit error rate p = 10⁻³, with coherence times T₁ = 30 s and T₂ = 10 s. Reported failure rates are about 3.1 × 10⁻⁷ per memory round, 1.0 × 10⁻⁶ per CNOT cycle, 3.1 × 10⁻⁶ for the X-rotation layer, 2.6 × 10⁻⁵ for S† and 2.5 × 10⁻⁴ for T†. The single-block S† and T† layers fail roughly 80 and 800 times as often as a memory round, which the authors attribute to their partition distance of only three.

Why it matters

If a computation’s logical gates are each one physical layer plus a syndrome round on a fixed code, the overhead of computing begins to look like the overhead of storing data. That is the long-standing appeal of transversal gates, and this paper shows it is achievable for a universal gate set on concrete, reasonably small codes, with full generating circuits published for reproduction. The paper also offers an intermediate path: if the direct non-Clifford layer is too noisy, the same code can prepare magic states by post-selection. For the [[37,1,7]] code at p = 10⁻³, about half of the attempts are accepted, and an accepted state is estimated to fail with probability 5.8 × 10⁻¹². The authors stress that this estimate includes fault sets of up to four faults and is not a like-for-like comparison with magic-state cultivation.

Technical perspective (interpretation)

My reading is that the most durable contribution is the bookkeeping, not any single code. The parity picture makes clear why the non-Clifford layer and the code distance can be pulled apart: the kernel buys distance for memory and transversal CNOT, while the seed’s Z distance alone limits the non-Clifford layer. The simulations show exactly this pattern, with memory and CNOT improving markedly from the 37- to the 59-qubit code while the S† and T† layers stay within a factor of three. To make the direct non-Clifford layer competitive, one would therefore need seeds with larger Z distance and low-weight checks at the same time, which is a cleaner target for future searches than “find a better code”.

Limitations and open questions

• The direct non-Clifford layer of the 37-qubit code fails at about 2.5 × 10⁻⁴ per cycle in simulation, far above its memory error. Any distance-three seed limits the layer to correcting one faulty gate.

• The noise model is optimistic by the authors’ own account: three-qubit gates are assumed to fail as often as CNOTs, and the assumed coherence times exceed those measured in the cited experiment. Atom loss, heating during moves, crosstalk, leakage and correlated readout errors are not modelled.

• The T† layer requires a classical controller to decode before each layer and apply corrections; in the simulations it misjudges at least one set in about one layer in ten, which dominates the remaining failure.

• The [[59,1,9]] results are labelled preliminary. The six codes whose every layer corrects two faulty gates have checks of weight 36 to 96 and have not yet been simulated under circuit-level noise.

• All codes with 35 or more logical qubits have checks of weight 32 or more. Whether high-rate, low-weight (qLDPC) depth-one universal families exist is left open.

Paper information

• Title: Qubit CSS codes with Universal Transversal Gates

• Authors: Arpit Dua (QuEra Computing), Adam Holmes (NVIDIA), Michael J. Gullans (QuEra Computing), Victor V. Albert (Joint Center for Quantum Information and Computer Science, NIST/University of Maryland)

• arXiv: 2610.06730v1 [quant-ph], submitted 5 October 2026

• DOI: 10.48550/arXiv.2610.06730

• Length: 25 pages, 5 figures, 6 tables; ancillary JSON listing all 110 codes with stabilizers, logical operators, depth-one generators, seed and kernel codes, and coupling circuits

Primary sources

• Abstract page: arxiv.org/abs/2610.06730

• Full text (HTML): arxiv.org/html/2610.06730v1

• Ancillary code catalogue: depth_one_universal_codes.json

Sparse Hamiltonians are the default input model for a large part of quantum simulation theory: an oracle tells you where the non-zero entries of each row are and what they are. In that model, standard block-encoding constructions lead to a cost that grows linearly with the sparsity s, the maximum number of non-zero entries per row. A new paper by Dominic W. Berry, Abhishek Rawat, Sophia Simon and Guang Hao Low gives algorithms whose leading cost grows only as √s, without the very large subpolynomial factors that accompanied the only previous general result of this kind, and backs them with lower bounds that nearly match.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is arXiv:2610.02939 (v1, submitted 2 October 2026, 67 pages).

Why it is worth reading

The question of square-root sparsity scaling has a long history. The paper recalls that Berry and Childs proposed √s methods in 2012 but could prove that scaling only under an extra condition on how the Hamiltonian’s norm behaves when it is split into parts, a condition that adversarial examples can violate. In 2019 Low established square-root dependence for general sparse Hamiltonians up to subpolynomial factors, which the authors describe as very large in practice. The new paper claims to remove those factors from the leading sparsity and time dependence, and it extends the same idea to linear differential equations and linear systems.

What the paper does

The main result (Theorem 4.1) concerns a Hermitian matrix H with at most s non-zero entries per row and column, where every row and column has Euclidean norm at most a known η. Writing τ = η|t| and ℓ = log(1/ε), the evolution e^−itH is simulated to operator-norm error ε using O(√s·τ + √(sτℓ) + ℓ) queries to the sparse oracles. The authors state that the same bound holds for time-dependent Hamiltonians, given coherent time-indexed access and a certified time discretisation.

The paper then reports three further results:

• Lower bound. A joint lower bound (Theorem 5.1) matches the leading √s·τ term and is within a factor log(e + ℓ/τ) on the mixed term. It also rules out a purely additive bound of the form O(√s·τ + ℓ).

• Dissipative linear ODEs. Combining the simulator with linear combination of Hamiltonian simulations (LCHS), the matrix-query cost is O(ḡ[√s(τ + √τ) + 1]·log(Cḡ/ε)), where ḡ bounds the ratio of input-plus-source norm to final-solution norm.

• Linear systems. For ‖A‖ ≤ 1 and ‖A⁻¹‖ ≤ κ, a “Cayley walk” plus a Chebyshev filter gives O(κ√s·log(1/ε)) queries, which matches a known joint lower bound in the stated parameter range.

As a corollary, any N×N unitary can be implemented at constant precision with O(√N) queries to its entries, matching the search lower bound. The authors note that Bravo-Prieto, Harrow and Kothari obtained this bound, and the same linear-system scaling, in independent concurrent work.

The key idea

Standard sparse block encodings have normalisation s·‖H‖_max, treating every entry as if it were as large as the largest one. The new construction uses the row and column Euclidean norms instead. It lifts the matrix to an “edge space” with two orientations for each non-zero entry, and builds an auxiliary operator whose compression back to the system reproduces H/(η√s). Crucially, the second moment of that operator is bounded on the subspace that couples to the system, even though its full norm can be as large as √s.

Rather than evolving under this operator, the authors apply the Cayley transform, which maps a real eigenvalue λ to (λ + i)/(λ − i) on the unit circle. Because the operator acts as a 2×2 block on each edge, the resulting unitary costs a constant number of sparse queries: query an entry, apply a known two-dimensional rotation, uncompute.

How it works

The Cayley unitary alone does not produce evolution under H. To get there, the paper uses the transducer framework of Belovs, Jeffery and Yolcu, following its recent use for time-dependent simulation by Chen, Gao, Wang and Zhou. A transducer is a unitary on public and private spaces that acts as a target unitary on the public part while returning a private “catalyst” amplitude unchanged. Here the public action is a Cayley time step (I − iΔtH/2)(I + iΔtH/2)⁻¹, which approximates e^−iΔtH with cubic local error.

Many time steps are composed with one private sector per time slot; a single coherent application of the Cayley unitary serves all of them, so refining the time mesh does not increase the query count. The circuit never prepares the catalyst. Instead, repeated reuse and averaging, implemented as a linear combination of unitaries followed by one round of oblivious amplitude amplification, filter out the mismatch. The cost is governed by two quantities: W, which bounds the catalyst’s squared norm, and Q, which controls how close the auxiliary spectrum can come to 1. Tuning a scaling parameter γ trades one against the other, and balancing them gives the stated bound. The simpler, unscaled version already gives O(√s(τ + ℓ)).

Why it matters

Sparse access is how many structured matrices, from lattice Hamiltonians to discretised differential operators, are presented to quantum algorithms. When rows have many entries but bounded Euclidean norm, replacing s by √s in the leading term changes the asymptotic cost, and the paper gives that improvement with clean, nearly tight bounds rather than through large hidden factors. The constructions also come with gate-efficient implementations for time-independent simulation and the dissipative ODE solver, with polylogarithmic overhead under stated assumptions about entry decoding and arithmetic.

A notable feature is formal verification. The time-independent simulation theorem, the constant-coefficient dissipative ODE result and the constant-error unitary-implementation bound are formalised in Lean 4 with Mathlib, in a public sparse-quantum-lean repository; the paper reports that the project compiles with 588 axiom-audit assertions that use only Lean’s standard foundational axioms.

Technical perspective (interpretation)

My reading is that the conceptual move is to separate “cheap unitary access” from “physical evolution”. The Cayley transform supplies the first at constant query cost with favourable moment bounds; the transducer turns those bounds into a simulation, without needing the auxiliary operator’s full norm to be small. It is also interesting that the time-dependent case incurs no extra query overhead in this model. Whether the √s advantage materialises for a specific application depends on how the row Euclidean norm η compares with s·‖H‖_max, which is problem-dependent and not quantified for applications in the paper.

Limitations and open questions

• The results are query complexities in a specific native sparse-access model, including in-place row and column locators with supplied inverses; the authors stress that a general out-of-place locator without inverse access is not substituted.

• The Hamiltonian bounds are not fully tight: the upper and lower bounds differ by a factor log(e + ℓ/τ) on the mixed √(sτℓ) term.

• For dissipative ODEs the authors identify the largest remaining gap; their lower bounds do not show that ḡ, √s·τ and the full precision logarithm must appear multiplicatively.

• Gate-complexity bounds rely on separately stated assumptions, and gate bounds for the general non-dissipative ODE and linear-system algorithms are listed as future work.

• The Lean formalisation does not cover the time-dependent extension, the linear-system algorithm, the lower bounds or the gate analyses.

• There are no numerical resource estimates for concrete applications. The acknowledgements state that derivations were developed with an AI system and further checked with another.

Paper information

• Title: Root-sparsity scaling for Hamiltonian simulation, differential equations and linear-system solvers

• Authors: Dominic W. Berry (Macquarie University; University of Queensland), Abhishek Rawat (Macquarie University), Sophia Simon (University of Toronto; University of Queensland), Guang Hao Low (Google Quantum AI)

• arXiv: 2610.02939v1 [quant-ph], submitted 2 October 2026

• DOI: 10.48550/arXiv.2610.02939

• Formal proofs: github.com/DominicWB/sparse-quantum-lean (version 0.1.0-rc5)

Primary sources

• Paper (abstract page): https://arxiv.org/abs/2610.02939

• Full text (HTML): https://arxiv.org/html/2610.02939v1

• Lean formalisation: https://github.com/DominicWB/sparse-quantum-lean

Ask a quantum information theorist whether pre-shared entanglement can make communication dramatically cheaper, and the honest answer for a long time has been “sometimes, in special settings.” Superdense coding saves a factor of two. Bigger gaps were known only for relational tasks, or for partial functions in the simultaneous-message model, and those gaps tend to disappear once the two parties are allowed to talk to each other directly. A new paper by Ryan Anselm, Srijita Kundu, Olivier Lalonde and Ashwin Nayak closes one version of this question: for a total Boolean function and one-way communication, prior entanglement can make the message exponentially shorter.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is a theory preprint (arXiv v1, 1 October 2026) and has not yet been peer reviewed.

Why this question matters

The no-communication theorem says entanglement alone cannot carry a message. But once some communication is allowed, entanglement is a resource that might replace a lot of it. Buhrman and de Wolf, and Brassard, asked early on how large that saving can be. Two standard models frame the comparison:

• Unassisted quantum communication (Yao’s model): Alice and Bob may send qubits, but share no entanglement at the start.

• Entanglement-assisted classical communication (Cleve–Buhrman model): Alice and Bob may share any input-independent entangled state, but send only classical bits.

Teleportation means the second model can simulate the first at twice the cost, so the interesting direction is whether the entanglement-assisted model can be much cheaper. A recurring obstacle, the authors note, is that most quantum communication lower-bound techniques apply equally to protocols with and without entanglement, so they cannot detect such a gap.

What the paper shows

The main result (Theorem 1.1) exhibits a family of total Boolean functions f_n on n-bit inputs for Alice and Bob such that:

• with prior entanglement, a one-way classical protocol from Alice to Bob computes f_n with O(log n) bits and worst-case error at most 1/3, using Θ(n) shared EPR pairs;

• without shared entanglement, the one-way quantum communication complexity, and also the one-way randomized complexity, is Θ(n^1/3).

Because the function is total, there is no promise on the inputs: every pair of inputs must be answered correctly. The authors describe this as the first asymptotic separation between these two models for any functional problem, answering the Buhrman–de Wolf and Brassard question in the one-way setting. They also point out consequences: it rules out a direct shared-entanglement analogue of Newman’s theorem (which removes shared randomness at small cost), and, combined with a simulation result of Shi and Zhu, it shows the O(log n) protocol is asymptotically optimal and that an exponential blow-up in simulating entanglement-assisted protocols classically is unavoidable even for total functions.

The key idea: subgroup membership, sent as a mixed state

The function is a special case of subgroup membership, a problem introduced by Watrous and brought to one-way communication by Aaronson, Le Gall, Russell and Tani. Alice holds a subgroup H of a finite group G, Bob holds an element g, and they must decide whether g ∈ H. In the known quantum protocol, Alice sends the uniform superposition over H, and Bob runs a Hadamard test with “multiply by g”: the test always passes if g ∈ H and passes with probability 1/2 otherwise. That costs O(log |G|) qubits.

The new protocol uses a variant the authors call bounded-order subgroup membership, where |H| is at most some k. Instead of sending a pure state, Alice uses remote state preparation (which, unlike teleportation, exploits the fact that the sender knows a classical description of the state) to give Bob the uniform mixture of all coset states of H. Any coset state works for Bob’s test, and this mixed state has high rank, which is exactly what makes remote preparation cheap: O(log |H|) classical bits plus O(log |G|) EPR pairs. When |H| is tiny compared with G, the message becomes exponentially shorter than the unassisted quantum protocol.

How the lower bound works

The hard part is proving that, without entanglement, no short quantum message suffices. The authors reduce a new “shifted equality” problem to bounded-order subgroup membership. In it, Alice holds two arrays g₁, g₂ of group elements indexed by the r-bit strings, Bob holds an array h and a shift s, and they must decide whether g₁(x) g₂(x+s) = h(x) for every x. The structure mirrors the Boolean Hidden Matching problem, with XOR replaced by a group operation and, crucially, no promise on the no-instances.

The argument then proceeds in steps:

• For unassisted one-way protocols, the best success probability under an input distribution is an expected operator norm of Bob’s averaged measurement operators (Lemma 3.2). With entanglement, Bob’s measurement also acts on an arbitrarily large shared state, so this characterization no longer applies. That asymmetry is what lets the bound separate the two models.

• The hard distribution multiplies Bob’s array by a central group element ζ of order 3, chosen with probabilities 1/2, 1/4, 1/4.

• The operator norm is bounded through Schatten-p moments, after approximating the dependent sum by one with independent random “rotations,” where a matrix concentration bound applies.

• The approximation error reduces, via Fourier analysis on G, to 1/D, where D is the smallest dimension of an irreducible representation that acts nontrivially on ζ.

The final ingredient is a group where D is huge: the generalized Heisenberg group over 𝔽₃, where D equals 3^m. In the instantiation, the input length is Θ(2^3r), the entanglement-assisted cost is Θ(r) bits, and the unassisted cost is Θ(2^r), which gives the log n versus n^1/3 separation.

Why it matters

Demonstrated: an exponential gap, for a total function, between entanglement-assisted classical and unassisted quantum one-way communication. Also demonstrated, as a side result (Section 3.3), are sharper classical simulations of entanglement-assisted protocols. The result settles a question that had remained open despite progress in nearby settings (SMP separations by Gavinsky–Kempe–Regev–de Wolf and Arunachalam–Girish, and a relational separation by Hasegawa–Le Gall–Modanese).

Technical perspective (interpretation)

My reading is that the conceptual lever is small and transferable: when the receiver only needs some member of a family of states, sending a high-rank mixture instead of one pure state can make remote state preparation far cheaper than teleportation. The lower-bound technique matters just as much, because it targets a feature unassisted protocols have and assisted ones lack. Whether it extends beyond one-way communication is unclear, and the authors themselves expect their approach not to.

The paper also contains an unusually explicit AI disclosure. The authors write that large language models (including GPT and Claude models) were used extensively, that they discovered the bounded-order problem and its upper bounds themselves, and that after many rounds of prompting GPT-6 Astra produced the shifted-equality instantiation and the corresponding quantum lower bound, which they then independently verified, developed and simplified. They state that they wrote the paper and take responsibility for its content. Readers should weigh that as the authors present it; independent refereeing has not yet happened.

Limitations and open questions

• One-way only. The separation is against one-way unassisted protocols. Bounded-order subgroup membership has an efficient two-way classical protocol, so this function is not expected to give a gap against two-way communication.

• Polynomial, not exponential, in n. The unassisted cost is Θ(n^1/3), so the gap is exponential relative to O(log n), not an “n versus log n” gap.

• Lots of entanglement. The protocol uses Θ(n) EPR pairs, while the lower bound only forces Ω(n^1/3). How much entanglement is truly needed is open.

• A complicated function. The construction relies on Heisenberg groups over 𝔽₃; the authors ask for simpler functions and groups.

• Other models remain open. Open: separations against SMP-assisted protocols, two-way versions, and whether any asymptotic quantum–classical one-way separation exists for a total function without entanglement.

• This is a pure-theory result with no experiment, code or data.

Paper information

• Title: An exponential separation between entanglement-assisted and unassisted one-way quantum communication

• Authors: Ryan Anselm (University of Texas at Austin), Srijita Kundu (Hon Hai (Foxconn) Research Institute), Olivier Lalonde (University of Waterloo, School of Computer Science and Institute for Quantum Computing), Ashwin Nayak (University of Waterloo, Department of Combinatorics and Optimization and Institute for Quantum Computing)

• arXiv: 2610.02099v1 [quant-ph], submitted 1 October 2026

• DOI: 10.48550/arXiv.2610.02099

• Code/data: none (theory paper)

Primary sources

• arXiv abstract page: 2610.02099

• Full text (arXiv HTML, v1)

• PDF (v1)

How long can a noisy quantum computer run before a laptop can imitate it? For devices built from local gates on a chip or an array, with noise striking every qubit at every step and no fresh qubits or mid-circuit resets, a new paper gives a sharp answer: not very long. After a depth that depends only on the noise rate, and not on the number of qubits, the output can be sampled efficiently on a classical computer.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is “A polynomial-time classical sampler for noisy quantum circuits from statistical mechanics” by Jon Nelson, Joel Rajakumar, Chao Yin, Yifan F. Zhang and Michael J. Gullans (arXiv:2610.00548, submitted 30 September 2026).

Why this paper is worth reading

The standard argument for why noise eventually kills quantum advantage is global: under local depolarizing noise, the whole output distribution drifts toward uniform, and once the circuit depth grows faster than logarithmically in the number of qubits n, sampling becomes classically easy. That argument leaves a large window open. Circuits of constant or slowly growing depth are exactly where many proposed near-term advantage experiments live, and previous classical algorithms for that window only handled specific cases, such as random circuits, restricted gate sets, or estimating expectation values rather than sampling.

The authors close much of this window for a general class of circuits. They prove that noise does not need to wash out the global state; it is enough for it to accumulate locally.

What the paper does

The setting is precise. Qubits sit on a D-dimensional lattice with D constant. Each of d layers applies two-qubit unital operations (unitaries, or more generally unital channels) to nearest-neighbour pairs, and after every layer each qubit suffers single-qubit depolarizing noise of strength p. The input is the all-zero state and every qubit is measured in the computational basis at the end.

The main theorem states that when the depth exceeds a critical value d_crit = O(p⁻¹ log p⁻¹) (with dimension-dependent constants), a deterministic classical algorithm computes the logarithm of every marginal probability of the output distribution to additive error ε in time polynomial in n/ε. Through a standard reduction, this yields a sampler whose output probabilities are each within a multiplicative (1 ± ε) factor of the true ones, which also implies closeness in total variation distance.

The relative-error guarantee matters. Relative-error sampling is the task whose classical hardness is known under the assumption that the polynomial hierarchy does not collapse. The authors point out that prior work shows relative-error sampling remains hard for noisy geometrically local circuits below a depth of order p⁻¹. Their easiness threshold of order p⁻¹ log p⁻¹ is therefore tight up to a logarithmic factor for this task.

The key idea: entropy piles up locally

The physical intuition is a volume-versus-boundary argument. In every layer, noise injects entropy into a region in proportion to its volume, roughly p per qubit. Local gates can only move that entropy out through the region’s boundary, which grows more slowly than the volume. So entropy accumulates locally, and after enough layers every region looks like a high-temperature system. High-temperature systems are typically easy to simulate classically, and the paper turns this heuristic into a proof.

The authors stress that geometric locality is essential. With all-to-all connectivity, a circuit can shuttle noise away from a protected subsystem faster than it accumulates, which is why the earlier, general results needed depth growing with n.

How the algorithm works

• Coarse-graining. The lattice is divided into blocks of side length 2d. This size guarantees that any two non-adjacent blocks have disjoint backward light cones, so observables on them evolve independently in the Heisenberg picture.

• Polymer model. Each marginal probability is expanded in Pauli Z operators, and the terms are grouped by which connected clusters of blocks they touch. The authors show that the marginal (up to a known factor) is exactly the partition function of an abstract polymer model from statistical mechanics, where polymers are connected sets of blocks and two polymers interact only if they touch.

• Cluster expansion. The logarithm of such a partition function can be written as a sum over clusters of polymers. This expansion converges when polymer weights decay exponentially with size, and truncating it to clusters spanning O(log n) blocks gives an additive approximation of the log-marginal.

• Weight decay from noise. The core technical step proves that a polymer’s weight shrinks exponentially with the number of blocks it covers once d exceeds the threshold. The proof chains hypercontractivity of the depolarizing channel with an ℓ₂-norm contraction bound, using locality to collect an independent decay factor from each block.

• Computing the terms. Small polymer weights can be computed by brute force on a portion of the circuit. To keep the runtime polynomial even when d grows with n, an appendix replaces brute force with truncated Pauli-path enumeration combined with tensor networks.

Why it matters

The result sharpens a question the authors put directly: when do quantum advantages break down if devices are scaled in size and runtime without also scaling non-unital or non-local resources? Fault-tolerance schemes rely on non-unital operations such as mid-circuit measurement with feedback and qubit reset. The paper gives a rigorous reason to believe that, without them, a local noisy device cannot sustain computations whose depth scales with system size. The authors also note that their bounds may apply to future fault-tolerant devices that run logical unitary gates with depolarizing-like logical noise and some form of geometric locality.

Methodologically, the paper connects two toolkits that are usually used separately: Pauli-path methods from circuit simulation and cluster expansions from rigorous statistical mechanics. The authors suggest hypercontractivity may find broader use in classical simulation.

Technical perspective (interpretation)

The following is my reading, not a claim made in the paper. The result is asymptotic, and its constants are large. The explicit sufficient condition in the paper’s weight-decay lemma includes a term proportional to 3ᴰ/p. By my rough arithmetic, plugging in p = 10⁻³ and D = 2 gives a threshold on the order of 10⁵ layers. The polynomial runtime also has a degree that grows with the inverse noise rate, roughly like p⁻⁽ᴰ⁺¹⁾ in one of the two bounds. So the theorem does not directly threaten current advantage experiments. It instead marks a structural boundary: noisy, local, unital computation has an intrinsic depth ceiling set by the noise rate, and only non-unital resources such as reset and measurement lift it.

It is also worth noting the paper’s AI-usage acknowledgement: the authors state that generative AI tools were used to obtain specific steps of the proof, namely the weight-decay argument and the tensor-network steps, while the main idea and technique were developed by the authors. Readers checking the proof may want to look closely at those sections.

Limitations and open questions

• Noise model. The theorem covers single-qubit depolarizing noise applied after every layer, with unital gates. Non-unital noise, such as amplitude damping, is not covered; the authors suggest the expansion might be developed around other fixed points.

• Geometric locality is required. Constant-depth hardness for noisy circuits with all-to-all connectivity remains open.

• Additive-error hardness is open. The tightness statement concerns relative-error sampling. Whether noisy local circuits at constant depth can be hard to sample to small total variation distance, under standard average-case conjectures, is left open.

• Random circuits. The techniques are worst-case. Extending them to prove simulability of noisy random circuits at all depths, as some numerical work suggests, would require exploiting disorder.

• A conjectured picture. The authors suspect the output state of a noisy local circuit is approximately a thermal state of a local Hamiltonian whose temperature grows with d and p, which would give a more direct proof.

• Status. This is a v1 preprint and has not yet been peer reviewed. It is a theory paper with no code or data release.

Paper information

• Title: A polynomial-time classical sampler for noisy quantum circuits from statistical mechanics

• Authors: Jon Nelson, Joel Rajakumar, Chao Yin, Yifan F. Zhang, Michael J. Gullans (Nelson and Rajakumar contributed equally)

• Affiliations listed: University of Maryland, College Park; University of California, Los Angeles; QuEra Computing Inc.; Princeton University; Stanford University

• arXiv: 2610.00548v1 [quant-ph], submitted 30 September 2026

• DOI: 10.48550/arXiv.2610.00548

Primary sources

• Abstract page: arxiv.org/abs/2610.00548

• Full text (HTML): arxiv.org/html/2610.00548v1

• PDF: arxiv.org/pdf/2610.00548v1

Graph states are one of the workhorse resources of quantum information: they underlie measurement-based quantum computation, many quantum error-correcting codes and several quantum-repeater designs. A basic question about them sounds almost too simple to be hard: given two graph states on the same labelled qubits, can one be turned into the other by independent single-qubit unitaries? A new single-author preprint by Yuxuan Zhang (EPFL and Princeton) gives a deterministic polynomial-time algorithm that answers it, and constructs the unitaries when the answer is yes. The author describes the polynomial-time question as having been open for over a decade.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth reading

For the restricted case of local Clifford (LC) operations, the problem has long been solved: two graph states are LC-equivalent exactly when their graphs are related by local complementations, and Bouchet’s algorithm decides this in polynomial time. For years it was conjectured (the “LU–LC conjecture”) that local-unitary (LU) equivalence always coincides with LC equivalence, which would have made the Clifford test enough. Ji, Chen, Wei and Ying disproved this with a 27-qubit counterexample, and Claudet later proved that 27 qubits are necessary. Since then the complexity of recognising full LU equivalence was unclear. Claudet and Perdrix recently gave a quasipolynomial algorithm, running in time n^{log₂ n + O(1)}. The new paper closes the gap to polynomial time.

What the paper does

The main theorem (Theorem 1.1) states that a deterministic classical algorithm decides LU equivalence of two graph states on n labelled vertices in Õ(n^6.38) bit operations, and, if they are equivalent, returns single-qubit unitaries realising the map with an exact symbolic description of O(n log n) bits. Vertex labels are fixed; permutations of qubits are not allowed.

Several further results come out of the same machinery:

• Counting Clifford classes. Inside the LU class of any graph state, the number of distinct LC classes is a power of two, 2^κ, and κ is computable within the same time bound. When κ > 0 the algorithm outputs an explicit graph that is LU- but not LC-equivalent to the input, with the connecting unitary (Theorem 5.1).

• Least non-Clifford level. It computes the smallest level r of a dyadic gate hierarchy needed for an equivalence (Corollary 4.5).

• Stabilizer states and codes. It decides SLOCC equivalence of pure stabilizer states given by Pauli generators, and LU equivalence of stabilizer codes encoding one logical qubit (Corollaries 4.6 and 4.7).

• Counting graphs is hard. Combined with prior hardness results, counting the labelled graphs in an LU class is #P-complete (Corollary 5.3).

The key idea

The paper builds directly on the Claudet–Perdrix reduction, and is explicit about what is inherited. Claudet and Perdrix showed that for graphs with at most 2^r+3−1 vertices, LU equivalence coincides with equivalence under a gate set LC_r generated by Hadamards and phase gates diag(1, e^iπ/2r). Level one is ordinary Clifford; level two adds the T gate. So r only needs to grow logarithmically with n. After putting both graphs in a common “standard form”, the vertices split into three types (X, Z and a mixed type), and the only non-Clifford freedom left is a single “generalised local complementation” on the X vertices, which can toggle edges only among the Z vertices.

Which generalised complementations are allowed is governed by divisibility conditions modulo 2^r on common-neighbour counts, one condition for every subset of up to r+1 vertices. Listing all those subsets is what made the previous algorithm quasipolynomial. Zhang’s observation is that the higher-order conditions are generated from the pair and triple conditions by a simple linear map: multiplying a constraint row coordinatewise by twice the neighbourhood vector of one more vertex produces the next-order row. Because these maps are linear, one can apply them to a small generating set, reduce with modular elimination after each round, and never store more than |X| generators. The paper proves that O(r) rounds suffice.

How the algorithm works

The full procedure (Algorithm 2) has these steps:

• Check that the labelled connected components agree, then work component by component.

• Compute common standard forms with the inherited Claudet–Perdrix procedure, and reject if vertex types or X-neighbourhoods differ.

• Run the new incidence compression to describe all valid multiplicities as the kernel of a small matrix over ℤ/2^rℤ, and extract a binary basis of all admissible edge changes, keeping a multiplicity vector that realises each one.

• Solve one affine linear system over the binary field that simultaneously chooses an edge change and the remaining local Clifford operations. A determinant identity (Lemma 4.1) shows that, for a connected target, every solution of the linear Clifford equations automatically satisfies the per-vertex invertibility conditions once one vertex is fixed, which is what removes the apparent nonlinearity.

• Assemble the witness: each qubit gets a unitary of the form Clifford · Z(kπ/q) · Clifford.

The new algebraic steps cost Õ(n⁵) bit operations. The overall Õ(n^6.38) bound is set by the inherited standard-form preprocessing, which uses fast binary matrix rank; with classical cubic rank computation, the paper states the bound becomes Õ(n⁷).

What was checked

The results are established by proof. In addition, Appendix B reports finite computational checks of the algebraic stages: for example, the incidence compressor was compared with the original constraints on 1,536 binary incidence systems, and 91 end-to-end constructions on four to eight qubits produced local unitaries matching the target state with Euclidean error below 10⁻¹⁰. On the published 27-vertex LU-but-not-LC pair of Tsimakuridze and Gühne, the constructive algorithm rejects level one, accepts level two, and recovers multiplicities realising the extra clique.

Why it matters

As the paper notes, when arbitrary single-qubit measurement bases are available, local basis changes in a resource state can be absorbed into the measurements in measurement-based computation. That makes LU equivalence the natural notion of “the same resource”. An efficient, constructive test lets one compare resources produced by different compilation routes, detect duplicates in a catalogue, or check whether an easier-to-prepare graph state is LU-equivalent to a desired one. The LC-class count also makes the failure of LU = LC checkable on individual inputs, rather than only through special counterexamples.

Technical perspective (interpretation)

My reading is that the contribution is a clean piece of algebra applied at exactly the right bottleneck. The deep structural work, including the standard form, the reduction to one generalised complementation and the logarithmic level bound, is due to Claudet and Perdrix, and the paper says so plainly. What changes is that an exponentially large family of congruences turns out to be a module generated by a polynomial-size seed under a few linear maps. Combined with the determinant identity, the remaining problem becomes linear algebra over 𝔽₂. The power-of-two count of LC classes inside an LU class is, in my view, the most conceptually interesting by-product: it says the LU/LC gap has a vector-space structure for every graph state.

Limitations and open questions

• Preprint status. This is a v1 arXiv preprint and has not been peer reviewed. The proofs are long and should be checked by the community.

• AI-assisted research. The acknowledgements state that the work is part of the author’s experimental series on agentic scientific research: the author set directions and supervised, while OpenAI models developed candidate arguments and derivations, searched the literature, wrote and ran computational checks, and drafted the manuscript. Readers may want to weigh independent verification accordingly.

• No end-to-end implementation yet. The paper states that the full minimal-local-set cover and standardisation procedures are not implemented or benchmarked, and that the checks do not give end-to-end timings. No code link is provided on the arXiv page.

• Polynomial, but high degree. The Õ(n^6.38) exponent comes from the inherited preprocessing; improving that step would lower the bound.

• Exact, not approximate. The algorithm addresses ideal states. A noise-tolerant version would need an approximation criterion and a description of imperfect inputs.

• Other objectives remain open. The least dyadic level does not minimise the number of non-Clifford gates or circuit length, and extending the code result to codes with several logical qubits faces a separate obstruction identified by the author.

Paper information

• Title: Polynomial-time local-unitary equivalence of graph states

• Author: Yuxuan Zhang (Institute of Physics, EPFL, Lausanne; Department of Physics, Princeton University)

• arXiv: 2610.00527v1 [quant-ph], submitted 30 September 2026

• DOI: 10.48550/arXiv.2610.00527

• Code/data: none linked

Primary sources

• Paper (abstract page): arxiv.org/abs/2610.00527

• Full text (HTML): arxiv.org/html/2610.00527v1

• Claudet and Perdrix’s quasipolynomial algorithm, as cited in the paper: arXiv:2502.06566

Every textbook proof that a quantum computer can implement any unitary comes with a sobering footnote: a generic n-qubit unitary needs about 2^O(n) one- and two-qubit gates, and counting arguments show that exponential gate count cannot be avoided. A quieter question has stayed open: does a generic unitary also need exponential depth, or could those gates be run in parallel if you had enough spare qubits? A new preprint by Barak Nehoran and Henry Yuen (Columbia University) answers it, and the answer is the one many people would not have bet on.

This article was drafted with Claude and fact-checked against the cited primary sources.

Why this paper is worth your time

Classical computation has long known that depth can be traded for size: every Boolean function can be computed by a depth-three circuit of exponentially many AND, OR and NOT gates with unbounded fan-in and fan-out. Whether something similar holds for quantum circuits was unclear, because a quantum circuit must act correctly on superpositions, preserving amplitudes and relative phases, not just on each basis input. Nehoran and Yuen show that the quantum analogue does hold, provided you are willing to pay in ancilla qubits. Along the way they settle a long-standing question about unitary synthesis with classical oracles, by connecting it to locally decodable codes and private information retrieval.

What the paper does

The headline result (Theorem 1.1, made precise as Theorem 5.1) is stated by the authors as follows:

• Every n-qubit unitary can be approximated to operator-norm error ε by a circuit of one- and two-qubit gates of depth poly(n, log 1/ε), using 2^O(n) ancilla qubits. In the paper’s notation, with N = 2ⁿ, the depth is O(log N + log log(N/ε)).

• If unbounded fan-out gates are allowed, the same unitaries can be implemented in constant depth.

The engine behind this is a second result (Theorem 1.2): a fixed quantum algorithm that makes only three queries to a diagonal phase oracle (equivalently six queries to a classical Boolean oracle) and, for every N-dimensional unitary U, implements U to error ε when the oracle is chosen to depend on U. The oracle acts on O(N log log(N/ε)) qubits. The paper describes this as the first constant-query algorithm for this “unitary synthesis” task relative to an oracle of roughly N size. Previously, the best known approaches needed either about N queries or a classical oracle on N² bits, as summarized in the paper.

The key idea: reading a unitary off a quadratic phase

The unitary synthesis problem, posed by Aaronson and Kuperberg, asks whether implementing an arbitrary unitary can be reduced to querying some cleverly chosen classical function. The authors observe that a known “folklore” two-query construction can be viewed as a coherent version of a two-server private-information-retrieval scheme: the oracle hides the matrix entries of U in a linear function, and each query is a query to a locally decodable code.

Their new move is to hide U in a quadratic function instead. After a reduction (Lemma 2.1) showing that it is enough to handle real, symmetric, traceless involutions S, the oracle applies the phase exp(i·v^TSv/2) to a register holding a vector v, a “chirp” in signal-processing language. A quadratic polynomial can be locally decoded from three points on a line, in the spirit of Reed–Muller codes: for example, 4f((u+v)/2) − f(u) − f(v) = 2u^TSv. The three queries play exactly those three roles.

How the construction works

The algorithm has seven steps: encode, query, Fourier transform, query, Fourier transform, query, decode.

• Encoding. The input state on N dimensions is mapped into the single-excitation sector of an N-mode harmonic oscillator, a “generalized one-hot encoding” in which each mode holds either a Gaussian or the first excited state.

• The middle sandwich. A query surrounded by two Fourier transforms acts like a query at the midpoint of two points with weight −4. Together with the first and last queries, this realizes the quadratic decoding identity. In the continuous setting the authors prove the exact identity S = i·E^†Q_SFQ_SFQ_SE (Theorem 3.1).

• Discretization. To make it finite, each mode is sampled on a grid of K = Θ(log(N/ε)) points. Using Poisson summation, the authors bound the operator-norm error by O(N^3/2K^3/4e^−πK/8) (Theorem 4.1).

• Shallow implementation. Each step is then compiled into constant depth with fan-out: the one-hot encoding uses fan-out and exact constant-depth AND gates; the quadratic phase splits into N² pairwise phases computed in parallel and applied as single-qubit Z rotations; and the Fourier transform over Z_K is implemented exactly in constant depth using earlier fan-out techniques. Replacing each fan-out gate by a binary tree of CNOTs gives the logarithmic-in-N depth with only one- and two-qubit gates.

Why it matters

As the authors put it, the result is “perhaps surprising from a physics point of view.” Intuitions such as the No Fast-Forwarding Theorem, or the expectation that scrambling systems like the SYK model generate complexity at a maximal rate, suggest that time evolution cannot in general be compressed. The paper explains why there is no contradiction: those intuitions concern circuits with few or no ancillas, or count oracle queries rather than whether they can be parallelized. What the result shows is a clean statement that, for general unitaries, depth can be traded for space.

For complexity theory, the three-query algorithm is significant on its own: it gives a constant-query reduction from implementing any unitary to querying a classical oracle of about N bits. For comparison, the lower bound the paper cites (Lombardi, Ma and Wright) shows only that a reduction to a function on o(N) bits needs more than one query.

Technical perspective (interpretation)

The following is our reading, not a claim made in the paper. The construction makes a quantum analogue of the classical “write out the whole truth table in parallel” trick work, and the price is exactly where one would expect: exponentially many ancillas, plus a classical description of U compiled into the rotation angles. It suggests that lower bounds on depth for general unitaries must use restrictions on space or gate types, not depth alone. The link between unitary synthesis and locally decodable codes also looks like a productive bridge: if better codes or PIR schemes translate into better synthesis algorithms, techniques from coding theory and cryptography may keep feeding into quantum circuit complexity.

Limitations and open questions

• Exponential resources remain. The construction uses 2^O(n) ancillas (Theorem 5.1 gives width Õ(N²log(N/ε)⁴)), and the total gate count is still exponential. This is a statement about depth, not a practical compilation method.

• Constant depth needs fan-out. The constant-depth version assumes fan-out gates acting on roughly N qubits at once. With ordinary two-qubit gates, the depth is O(log N + log log(N/ε)), which is polynomial in n.

• Approximate, U-dependent circuits. The implementation is approximate in operator norm, and the circuit for each U encodes U’s matrix entries in its rotation angles.

• Preprint status. This is version 1 of a 35-page preprint and has not yet been peer reviewed.

• AI-assistance disclosure. The authors state that ChatGPT and Claude suggested the specific quadratic form that simplified the analysis, and that ChatGPT helped with the Poisson summation argument and the constant-depth Fourier transform; they write that every suggestion was vetted and that they take full responsibility for correctness.

• Open questions (our framing): how few ancillas suffice for polynomial depth; whether fewer than three phase queries are possible with an oracle of about N bits; and what this implies for models of complexity growth that allow ancillas.

Paper information

• Title: All Unitaries Have Constant Depth Quantum Circuits

• Authors: Barak Nehoran, Henry Yuen (Department of Computer Science, Columbia University)

• arXiv: 2609.40351v1 [quant-ph], submitted 30 September 2026

• DOI: 10.48550/arXiv.2609.40351

• Length: 35 pages; theory paper, no code or data

Primary sources

• arXiv abstract page: arxiv.org/abs/2609.40351

• Full text (HTML): arxiv.org/html/2609.40351v1

• PDF: arxiv.org/pdf/2609.40351v1

How much genuinely quantum structure survives in a system at thermal equilibrium? For one-dimensional spin chains, a new preprint by Saúl Pilatowsky-Cameo, Georgios Styliaris, Ainesh Bakshi and Daniel Malz gives an unusually clean answer: at any fixed temperature, the Gibbs state of any local spin chain is exactly a classical mixture of states that factorize into blocks of bounded size. The immediate consequence is that such thermal states can be prepared by quantum circuits whose depth does not grow with the length of the chain.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is a theory preprint (arXiv:2609.35973v1, submitted 28 September 2026) and has not yet been peer reviewed; everything below that goes beyond restating its theorems is labelled as interpretation.

Why this paper is worth reading

Preparing thermal (Gibbs) states is a standard subroutine in quantum simulation, and it is also a way of asking a structural question: how complex can a state at thermal equilibrium be? In one dimension, correlations in Gibbs states were already known to decay exponentially, and recent work had bounded the total bipartite entanglement and shown that entanglement between distant regions vanishes after tracing out the middle. On the algorithmic side, the paper notes that the best provable 1D Gibbs samplers currently guarantee a mixing time linear in system size, and that the best known circuit depth (from an adiabatic algorithm) scales polylogarithmically with the system size. This paper removes the size dependence of the depth entirely, and does so through an exact structural decomposition rather than an approximation.

What the paper proves

The setting is a ring of N qubits with a geometrically local Hamiltonian: a sum of terms, each acting on r adjacent qubits with operator norm at most 1. The main results, as stated by the authors, are:

• Block separability (Theorem 1). For any constant inverse temperature β, the Gibbs state is exactly a mixture of product states over partitions of the ring into contiguous blocks. Each block contains at most a constant number C_β = exp(exp(c_r·max(1, β))) of qubits, with c_r = exp(16r), and each block state is a matrix product state with bond dimension at most C_β.

• Efficient classical sampling (Theorem 2). A classical algorithm running in time poly(N, 1/ε) samples the blocks and their states, reproducing the Gibbs state to trace-norm error ε.

• Constant depth (Corollary 1). The Gibbs state is a mixture of states prepared from |0…0⟩ by nearest-neighbour circuits of depth exp(exp(O(β))), independent of N.

• Bounded multipartite entanglement (Corollary 2). Entanglement depth and entanglement width are both bounded by C_β.

• Sudden death of localizable entanglement (Corollary 3). If two regions are farther apart than C_β, no entanglement can be concentrated between them even with local measurements and classical communication on the sites in between.

• Fermions (Theorem 3). Gibbs states of 1D local fermionic Hamiltonians are exact mixtures of fermionic Gaussian states acted on by constant-depth, parity-preserving local fermionic circuits on bounded blocks.

The key idea: cut the chain, but only where it is safe

A Gibbs state is not a product state, so the question is where it can be cut without losing anything. The authors’ answer is that it can always be cut somewhere inside every sufficiently long stretch of chain, with the cut positions themselves being random. Each term of the mixture has its own set of cuts, and summed over all terms the mixture reproduces the exact thermal state. Because no term has entanglement crossing its cuts, each term is a product of states on bounded blocks, and each of those can be prepared in constant depth.

How the proof works

The argument builds on an “entanglement bulk decomposition” from earlier work, which the authors generalise so that any site of a ring can be removed. It writes the unnormalised Gibbs operator as e^−βH = M e^−βH∖k X, where H∖k drops every interaction touching site k, M is an operator acting on m = exp(O(β)) sites around k (carrying the quantum correlations), and X is a “quasilocal perturbation of the identity” whose terms decay exponentially with their size (carrying only classical correlations).

Applying this at inverse temperature β/2 at sites spaced m apart splits the ring into elementary blocks joined by local operators M_j, surrounding a middle operator built from a staircase of these identity perturbations. Adapting earlier pinning arguments, the authors show that when the decay is fast enough (they take a decay constant of 1/112) the staircase is separable across blocks.

The remaining step is to find cuts that none of the M_j cross. Each block factor is split into a positive piece that already factorises across the block’s midpoint plus a positive remainder that is at most a fraction (1 − η) of the whole. Grouping L consecutive blocks into a “superblock”, every term in the expansion except one contains a factorised piece and hence a cut. The one exception is suppressed by (1 − η)^L, and for L = exp(9m) the authors show it can be absorbed while keeping separability. The result is at least one cut per superblock, so each block in the final decomposition has at most 2mL ≤ C_β qubits.

The sampling algorithm follows the same steps: sample a term of the separable staircase, then sample the cut positions (which form a nearest-neighbour classical distribution on a ring and can be drawn exactly with a forward–backward transfer-matrix sweep in O(N) time), then sample pure states on the resulting blocks.

Why it matters

The paper states three kinds of consequences. For state preparation, Corollary 1 gives circuit depth independent of N using strictly local gates; the authors state that all previous Gibbs-state preparation algorithms in this regime either had depth growing with system size or required quasilocal gates. The decomposition also separates the quantum work (constant-depth circuits) from the classical work (polynomial-time sampling), which the authors note matters in practice because classical computation may be much cheaper.

For entanglement, Corollary 3 strengthens a recent result that distant regions become separable after the middle is traced out: tracing out can hide entanglement that measurements could still localise (a GHZ state is the standard example), and the new result rules that out for 1D Gibbs states beyond a constant distance. The authors contrast this with a recent 2D commuting-Hamiltonian example where long-distance localizable entanglement does survive at finite temperature.

For dynamics, Corollary 4 uses the decomposition, together with prior results, to prove thermalization for translation-invariant chains with nondegenerate spectral gaps: typical states from maximally entropic, low-complexity ensembles at any constant effective temperature become locally indistinguishable from the Gibbs state under unitary evolution, with finite-size fluctuations O(N^−1/2+δ) for any δ > 0.

Technical perspective (interpretation)

My reading is that the most durable contribution is conceptual: “thermal states in 1D are short-range entangled” is turned from a heuristic into an exact, constructive statement with explicit block sizes. The constant-depth result should be read in that light. The constants are enormous (doubly exponential in β, with c_r itself exponential in the interaction range), so the result says nothing directly about practical circuit depths at low temperature. Its practical value is more likely as a structural guarantee, and possibly as a template: the authors point out that for a specific model the required block size can be estimated numerically, which could give far smaller circuits than the universal bound.

Limitations and open questions

• Temperature scaling. The depth bound is doubly exponential in β. The authors ask whether this is optimal, i.e. whether some family of Hamiltonians requires depth matching exp(exp(O(β))).

• Exact versus approximate. The decomposition is exact; allowing approximation may improve the β dependence. The authors cite prior work with subexponential-in-β bond dimension, at the cost of quasi-linear scaling in N when compiled into circuits.

• Beyond qubit chains. Qudits are expected to follow by a straightforward adaptation (stated, not proved here); bosonic systems with infinite local dimension are left open.

• Two dimensions. Whether 2D Gibbs states are similarly mixtures of short-range entangled states is open. A positive answer would rule out finite-temperature topological order in 2D, which is currently proven only for commuting Hamiltonians.

• Thermalization assumptions. Corollary 4 requires translation invariance and nondegenerate spectral gaps, and concerns ensembles satisfying specific complexity and maximal-entropy conditions.

• Status. This is a v1 preprint with no experiments, numerics or code; the results are mathematical proofs that have not yet been peer reviewed.

Paper information

• Title: One-dimensional quantum Gibbs states in constant circuit depth

• Authors: Saúl Pilatowsky-Cameo (MIT Center for Theoretical Physics), Georgios Styliaris (Max Planck Institute of Quantum Optics), Ainesh Bakshi (New York University), Daniel Malz (University of Basel)

• arXiv: 2609.35973v1 [quant-ph], submitted 28 September 2026; 5 + 13 pages, 1 figure

• DOI: 10.48550/arXiv.2609.35973

• Code/data: none (theoretical work)

Primary sources

• Paper (abstract page): arxiv.org/abs/2609.35973

• Full text (HTML): arxiv.org/html/2609.35973v1

• PDF: arxiv.org/pdf/2609.35973v1

Of the gates a fault-tolerant quantum computer needs, the T gate is the expensive one. Clifford gates are comparatively easy to protect, but they are not universal on their own, and the standard ways of supplying T, such as magic-state distillation or code switching, cost qubits and time. A code on which T can be applied transversally, one physical qubit at a time, is therefore valuable. A code on which T can be aimed at any single chosen logical qubit, while the code keeps constant rate and linear distance, has been an open construction target.

A new preprint by Tongyin Lin, Bujiao Wu and Bin Cheng, “Asymptotically Good Quantum Codes with Addressable Transversal T Gates” (arXiv:2609.35129v1), gives an explicit construction of such a family. This article was drafted with Claude and fact-checked against the cited primary sources.

What the paper does

The authors define fully addressable transversal T gates: for a fixed encoding of K logical qubits, every tensor product of logical powers of T (each exponent taken mod 8) must be implemented by a tensor product of single-qubit physical unitaries. Choosing the exponent vector to be a unit vector applies T to one logical qubit and the identity to all others. In their construction the physical gates are themselves powers of T, and no Clifford correction is needed afterwards.

The main result (Theorem 4.5, stated informally as Theorem 1.2) is an explicit family of binary CSS codes with parameters [[N, K = Θ(N), D = Θ(N)]] that has this property. The physical exponents depend linearly, over the integers mod 8, on the requested logical exponents.

The context matters. The Eastin–Knill theorem rules out a code with a universal set of transversal gates, so transversal T is a building block rather than a complete solution. Earlier work cited by the authors obtained asymptotically good binary codes with transversal CCZ (Golowich and Guruswami; Nguyen), addressable CCZ (He et al.), and asymptotically good CSS-T codes on which physical transversal T acts as the logical identity or as logical S^†. Constructions that do realise logical T either had vanishing rate (Hastings and Haah; Haah) or constant rate with growing but not linear distance (Wills). The paper also cites independent, concurrent work by San-José that obtains asymptotically good codes with transversal diagonal rotations at every level of the Clifford hierarchy from the third upward, with addressable rotations via a hierarchy-lowering argument; Lin, Wu and Cheng take a more direct route to addressable T.

The key idea: divisibility as a phase dial

Applying T^b_j to physical qubit j multiplies a computational basis state |w⟩ by e^iπ/4 raised to the weighted weight Σ_j b_jw_j, taken mod 8. So if, for every codeword in a coset, that weighted weight equals the phase the logical T pattern should produce, the physical layer acts exactly as the desired logical gate.

The paper packages this as weighted 8-divisibility: the set of coefficient vectors a in (ℤ₈)ⁿ for which every codeword of a binary code has a-weighted weight divisible by 8. Haah studied this with odd coefficient vectors; the new ingredient is allowing even and zero coefficients too, so that each logical qubit’s phase can be prescribed independently. Lemma 3.1 shows that if such coefficient vectors exist for every information coordinate, then shortening and puncturing the classical code on those coordinates (a Krishna–Tillich style construction) produces a CSS code with fully addressable transversal T.

How the construction works

• Parity lifting (Lemmas 4.1–4.2). If a binary code has the 4-multiplication property (the component-wise product of any five codewords has even weight), a coefficient vector known only mod 2 can be lifted to mod 4 and then mod 8 by solving two binary linear systems. Inverting a matrix over ℤ₈ then yields the prescribed per-qubit coefficients. All of this is polynomial time.

• Algebraic-geometry codes (Lemma 4.3). From an optimal Garcia–Stichtenoth function-field tower over the field with 1024 elements, the authors build AG codes with the 15-multiplication property (products of sixteen codewords sum to zero). Their rate tends to 17/496, with relative distance at least 463/496 and dual relative distance at least 1/496.

• Binary embedding (Lemma 4.4). A fixed linear map σ from the 1024-element field into L bits, built from a trace of a product over odd-sized subsets of five inputs, turns the sixteenfold field identity into vanishing fivefold binary overlaps, i.e. the binary 4-multiplication property. The generic bound is L ≤ 637.

• Selecting logical coordinates (Theorem 4.5). K field coordinates are restricted to a one-dimensional binary subspace generated by a trace-one element and compressed to single bits, with K = ⌊n/992⌋. The resulting CSS codes satisfy K/N → 1/(991L), relative X-distance at least 925/(991L), and relative Z-distance at least 1/(991L).

• Shorter embeddings (Section 5, Appendix D). The minimum embedding length is recast as a minimum-weight problem in a binary affine space. The triangular construction gives length 353; a randomized local search found a length-244 embedding whose image is a binary [244, 10, 100] code. Plugging this in (Corollary D.1) gives rate tending to 1/241804, relative Z-distance at least 1/241804, and relative X-distance at least 92500/241804.

Why it matters

What is demonstrated here is a proof, not an experiment: an explicit family of binary codes that is simultaneously asymptotically good and supports T on any chosen subset of logical qubits, implemented only by single-qubit physical T powers on a fixed encoding. The authors point to magic-state distillation and code switching as settings where codes with transversal T are used, and pose the space-time overhead of universal computation with such codes as an open question.

Technical perspective (interpretation)

The following is my interpretation, not a claim from the paper. The appealing move is treating divisibility coefficients as a programmable dial: once the 4-multiplication property holds, choosing which logical qubits get which T power becomes linear algebra over ℤ₈. That separates the hard part (building codes with strong multiplication structure) from the addressability part.

The constants make clear that this is an existence-and-explicitness result rather than a hardware proposal. A rate of 1/241804 means roughly a quarter of a million physical qubits per logical qubit in the limit, and the guaranteed relative distance is of the same order; the bounds are also only asserted for sufficiently large tower levels. AG-code-based CSS codes are not low-density parity-check codes, so their checks are high weight. Those gaps are exactly where follow-up work on better constants, LDPC versions and decoders would have to land before the idea could shape an architecture.

Limitations and open questions

• The paper is purely theoretical (27 pages, no figures): no noise model, decoder, threshold or circuit-level simulation is given.

• The explicit constants are very small, and the stabilizers are not bounded-weight.

• Transversal T alone is not universal (Eastin–Knill); complementary gates are still required.

• The authors list open questions: general structural principles for fully addressable transversal non-Clifford gates; whether asymptotically good quantum LDPC codes can have fully addressable transversal T; and the optimal space-time tradeoff once noisy syndrome extraction, ancilla preparation, complementary gates and classical processing are included.

• The paper includes a statement that AI models were used to assist with brainstorming, exploring proof strategies, writing proofs and preparing the manuscript, with the authors taking full responsibility for its claims. It is a v1 preprint and has not been peer reviewed.

Paper information

• Title: Asymptotically Good Quantum Codes with Addressable Transversal T Gates

• Authors: Tongyin Lin, Bujiao Wu (International Quantum Academy, Shenzhen); Bin Cheng (Centre for Quantum Technologies, National University of Singapore)

• arXiv: 2609.35129v1 [quant-ph], submitted 28 September 2026

• DOI: 10.48550/arXiv.2609.35129

• Code/data: none listed (theory paper); the explicit length-244 embedding is given in hexadecimal in Appendix D.

Primary sources

• arXiv abstract page (2609.35129)

• Full text (arXiv HTML, v1)

• PDF (v1)

Fault-tolerant quantum computing rests on a simple premise: we know what every gate is supposed to do, so we can check whether it did it. Quantum learning and sensing break that premise. There, the device interacts with an external system whose behaviour is exactly what we are trying to find out, and the interface to that system is corrupted by noise like everything else. A new preprint by Ruohan Shen and Soonwon Choi (MIT) asks whether error correction can still protect that interface, and gives a positive answer for a broad and important class of cases.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is “Oracle Distillation” (arXiv:2609.31596v1), a theory paper submitted on 25 September 2026. All results described below are mathematical results proved in the paper; there is no experiment.

What the paper does

The authors model the interface between a quantum device and an unknown system as an oracle: an unknown unitary drawn from a known family. Every query calls the same oracle, but each query actually applies a noisy version of it. They then define oracle distillation (OD): a procedure that consumes many noisy queries and outputs a single distilled oracle that is ε-close to the ideal one in diamond norm, the strictest standard distance between channels. Because the distilled oracle is close in diamond norm, it can be dropped into any downstream quantum algorithm as if it were the real thing, with the total error adding up at most linearly in the number of calls.

The main contributions are:

• An explicit OD protocol for every Boolean oracle, working both under adversarial bounded-weight noise on the index register and under i.i.d. single-qubit depolarizing noise on all qubits.

• A lower bound showing the protocol is near-optimal in the low-noise regime among protocols whose pre-query states satisfy the Knill–Laflamme error-correction conditions.

• A threshold theorem: any Boolean oracle problem whose quantum query advantage is polynomial in the domain size N keeps an advantage when the per-qubit depolarizing rate is below a constant threshold.

• Extensions to fractional and continuous-time oracles, where noise may also strike before and during each query.

The key idea: the weak query

The paper identifies three requirements that pull against each other. An efficient protocol must not learn the oracle’s label (that would cost far more queries than necessary), it must detect and correct errors, and its output must still be a working oracle that responds correctly to every input. Error correction wants the states sent into the oracle to be indistinguishable to the noise, yet the oracle must respond to the specific input requested.

The resolution is what the authors call a weak query. Instead of querying on the bare bitstring |x⟩, the protocol queries on a carefully designed “query state” that looks locally random to low-weight Z errors but retains a fraction η of its population on |x⟩. The oracle’s response to x is therefore only weakly imprinted in each query. Many such weak responses are then aggregated coherently into one full-strength response.

How the protocol works

For the adversarial model, the protocol has two stages. Stage 1 encodes each index qubit in a length-3 repetition code, which removes X-type errors at no extra query cost and leaves only phase (Z) noise. Stage 2 then runs five steps on L “query blocks” plus a data block that stores the input:

• Encoding the input into the query blocks.

• Weak query: one oracle call on each query block.

• Response aggregation: count how many blocks responded; if the count reaches a threshold, apply the response to the data block.

• Uncomputation: query each block again. Because a Boolean oracle is its own inverse, the two queries cancel and the blocks return to a codespace that does not depend on the unknown function.

• Recovery: a fixed, label-independent error-correction channel removes the accumulated phase noise.

The noise commutes with both the oracle and the aggregator, so errors from the two queries on each block merge into one correctable error just before recovery. The only remaining error is the chance that the aggregator miscounts, which falls exponentially in ηL. That gives a query count of 2⌈(2/η) ln(4/ε)⌉ (Theorem 1a).

Why it matters

The headline consequence is the threshold theorem. Under i.i.d. depolarizing noise, almost every query is corrupted somewhere, since a query is error-free only with probability (1−p)ⁿ⁺¹ for a single-bit response. Yet the paper proves that problems with a large enough advantage budget, the ratio of classical to quantum query counts, retain a quantum advantage below a constant per-qubit error rate p*. The paper’s Table 3 gives thresholds achieved by its protocol, including:

• Grover search: p* = 5.1 × 10⁻⁴. As p → 0, the noisy query count approaches the noiseless √N scaling.

• Simon’s problem and 2-forrelation: p* = 3.4 × 10⁻².

• k-forrelation: the threshold grows toward 3/4 as k → ∞.

• Element distinctness: 7.1 × 10⁻⁷; the collision problem: 5.6 × 10⁻⁸.

This may look like it contradicts earlier no-go results showing that noisy oracles destroy Grover’s speedup. The authors explain the difference: those works model noise correlated across the whole query register, whereas here each qubit is hit independently, so a typical error touches only a fraction p of the qubits. In their words, the robustness of the advantage depends on the structure of the noise rather than only its magnitude.

For Simon’s problem, the trade-off is instructive. With OD, the exponential query separation becomes a polynomial one, but the classical post-processing stays polynomial in n, whereas plugging the noisy oracle directly into Simon’s algorithm leads to a learning-parity-with-noise problem whose post-processing grows exponentially in n.

Technical perspective (interpretation)

The following is our reading, not a claim made in the paper. The conceptual move is that error correction does not need to know the operation it protects; it needs structure that separates signal from noise. For Boolean oracles, that structure is that the oracle’s phase depends on the entire input string while the noise is local, plus the fact that the oracle can be undone by querying it again. The authors themselves flag that last property as essential: without the ability to invert an unknown oracle, designing a label-agnostic recovery “might become substantially more challenging.” The natural next question is which other oracle families have exploitable structure of this kind.

The paper also points to two possible applications, both framed by the authors as directions rather than results: computational quantum sensing, where an oracle is synthesized from continuous sensor dynamics and only needs to be “distillable” rather than perfect, and quantum random access memory, where OD could offer an alternative route to fault-tolerant access.

Limitations and open questions

• Idealized device. The analysis assumes a universal quantum computer with ideal gates and unlimited quantum memory; the oracle is the only source of noise. Fault-tolerant integration of the physical interaction with logical gates is listed as future work.

• Noise model. The guarantees are for bounded-weight noise on the index register or i.i.d. depolarizing noise. Whether a real sensing or QRAM interface produces a distillable noise model (”noise shaping”) is explicitly an open problem.

• Thresholds are small for some problems. For Grover the threshold is 5.1 × 10⁻⁴, and for element distinctness and collision it is below 10⁻⁶. These are the thresholds of this protocol, not proven limits of the problems.

• Overheads. Advantages shrink under noise: Simon’s problem drops from an exponential to a polynomial separation, and gate counts can be large for the parameter choices that attain the best thresholds.

• Optimality gap. Whether better query states can close the remaining gap between upper and lower bounds is left open, as is a general criterion for when efficient OD is possible.

• Not yet peer reviewed. This is a v1 preprint.

Paper information

• Title: Oracle Distillation

• Authors: Ruohan Shen, Soonwon Choi (MIT Center for Theoretical Physics – a Leinweber Institute, Massachusetts Institute of Technology)

• arXiv: 2609.31596v1 [quant-ph], submitted 25 September 2026; preprint number MIT-CTP/6118

• DOI: 10.48550/arXiv.2609.31596

• Type: theory; no code or data repository is linked from the arXiv page.

• The authors’ acknowledgements state that they used AI assistants to improve presentation and assist with calculations, and that all calculations were independently verified by the authors.

Primary sources

• arXiv abstract page: https://arxiv.org/abs/2609.31596

• Full text (HTML): https://arxiv.org/html/2609.31596v1

• PDF: https://arxiv.org/pdf/2609.31596v1

For a noisy quantum channel, the most basic question you can ask is how many classical bits per use it can carry. For most channels we still cannot answer it, because the formula for the classical capacity involves an optimization over entangled inputs spread across arbitrarily many channel uses. A new preprint, “Classical Capacity and Entanglement Cost of the Amplitude Damping Channel” by Ziao Tang, Chengkai Zhu, Ge Bai and Xin Wang, claims to close that gap for the qubit amplitude-damping channel, the textbook model of energy relaxation, and for a whole class of qubit channels around it.

This article was drafted with Claude and fact-checked against the cited primary sources. The paper is a v1 preprint and has not yet been peer reviewed; below I separate what the paper proves from my own interpretation, which is labelled as such.

Why this paper is worth your attention

The Holevo–Schumacher–Westmoreland theorem expresses the classical capacity C of a channel N as a limit: C(N) = lim (1/n) χ(N^⊗n), where χ is the Holevo information. Using product inputs gets you χ(N) per use; the question is whether entangling codewords across uses can ever do better. Hastings showed in 2009 that for some channels it can, so additivity cannot be assumed. Proving it for a specific channel requires a structural reason.

Amplitude damping is the obvious test case. Its quantum capacity and entanglement-assisted capacity have long had single-letter formulas, and its single-use Holevo information was worked out by Bennett, Shor, Smolin and Thapliyal (2002) and by Giovannetti and Fazio (2005). As the authors note, additivity results for entanglement-breaking channels and for unital qubit channels do not cover the nontrivial regime 0 < p < 1. Whether that known single-use rate is the true capacity has remained open. This paper says it is.

What the paper claims

The authors state three main results:

• A class of additive qubit channels. For every qubit-to-qubit channel that admits a pure output (some pure input is mapped to a pure output state), the classical capacity equals the single-use Holevo information, C(N) = χ(N), and the parallel entanglement cost of simulating the channel equals the entanglement of formation of its normalized Choi state. Holevo information, channel entanglement of formation and parallel entanglement cost are all additive with any finite-dimensional partner channel. This class contains every qubit channel with at most two Kraus operators.

• The classical capacity of amplitude damping. For damping probability p, C(A_p) equals the known one-parameter maximization over the input excitation probability q, and it is achieved by an equiprobable pair of pure states √(1−q*)|0⟩ ± √q*|1⟩ used as product codewords with collective decoding.

• The entanglement cost of amplitude damping. Under parallel simulation by local operations and classical communication (LOCC), the cost is h₂((1+√p)/2) ebits per channel use, where h₂ is the binary entropy.

The authors are explicit that the single-use formula and optimal ensemble are not new. What is new is the matching many-use converse that turns them into capacities.

The key idea

Both results reduce to one inequality about entanglement of formation, E_F. Fix a distinguished vector in each of two local systems A and B. If a state ρ_AB has no support on the sector where both systems are orthogonal to their distinguished vectors, the paper proves (Theorem 4.1) that ρ is strongly superadditive: for any global state Ω whose AB marginal is ρ, however it is correlated with auxiliary systems A′B′, E_F(Ω) ≥ E_F(ρ) + E_F(σ_A′B′). In particular E_F is additive on ρ and its entanglement cost equals E_F(ρ).

Amplitude damping satisfies this constraint naturally. In its Stinespring dilation, an excitation either stays in the output or leaks into the environment, never both, so the joint output–environment state has no weight on |1⟩_B|1⟩_E. That single missing sector is what the whole argument runs on.

How it works

The proof of Theorem 4.1 has two ingredients:

• A triangular block entropy inequality (Theorem 4.2). For a pure extension, the missing sector makes the coefficient matrix block-triangular. The authors show its entanglement entropy is at least a “scalar” term, fixed by the weights of the allowed sectors, plus weighted entropies of the individual blocks.

• A decomposition that preserves two expectation values (Lemma 4.3). Any state can be written as a mixture of pure states within its support that each have the same expectation values of two chosen Hermitian operators. Choosing the two sector projectors bounds E_F(ρ) by the scalar term, while local monotonicity and convexity bound E_F(σ) by the block terms.

Notably, the argument never needs to evaluate either mixed-state convex roof; it only needs upper bounds on the two marginals.

For communication, the Matsumoto–Shimono–Winter correspondence converts this into strong superadditivity of the minimum output entropy at a fixed input, and hence strong additivity of Holevo information (Corollary 5.1). For simulation, the same theorem is applied to the Choi state: a qubit channel admits a pure output exactly when its Choi state has a product vector in its kernel, which makes the known lower and upper bounds on parallel entanglement cost coincide.

For amplitude damping specifically, the paper also derives an exact finite-block identity (Proposition 5.6) splitting the gap between nC(A_p) and the Holevo information of any n-use input into three nonnegative terms. It follows that for p < 1 the unique optimal average input at every block length is the n-fold product of the optimal single-use input.

Why it matters

At p = 1/2 the paper’s numerical evaluation gives a classical capacity of about 0.47173 bits per use, an entanglement cost of about 0.60088 ebits per use, a quantum capacity of zero, and an entanglement-assisted classical capacity of exactly 1. I reproduced the first two numbers independently from the paper’s formulas. In the high-damping limit p → 1, the authors derive that the entanglement-assisted capacity exceeds the unassisted one by a factor approaching 4, a ratio first obtained by Bennett et al. that the new theorem now attaches to the true capacity.

Beyond amplitude damping, the pure-output class gives a clean, checkable criterion for which qubit channels have additive classical capacity. The paper includes an explicit Kraus-rank-three example to show that the class is strictly larger than the Kraus-rank-two case.

Technical perspective (interpretation)

This section is my reading rather than the paper’s claims. What I find most useful here is that the argument is structural: a support condition, not a channel-specific calculation, drives both the capacity and the simulation results. That makes it a template. The authors themselves suggest looking for “excluded sectors” in other channels. The obvious next target is generalized amplitude damping at finite temperature, which the paper notes does not in general satisfy the hypothesis. A robust version of Theorem 4.1, with a penalty proportional to the weight in the excluded sector, would be a natural way to get approximate additivity there.

The paper is also a notable instance of AI-assisted mathematics. The authors disclose that frontier large language models were used for the proofs of Theorems 4.1 and 4.2, that they verified the statements and proofs themselves, and that a Lean 4 formalization accompanies the paper. If that formalization covers the key steps, it substantially raises confidence in an argument that has not yet been through peer review.

Limitations and open questions

• Not yet peer reviewed. This is a v1 preprint. The claimed Lean formalization is referenced as a GitHub repository, but when I checked on 27 September 2026 that link returned “page not found”, so I could not inspect it. I have not verified the proofs independently.

• AI-assisted proofs. Per the paper’s disclosure, language models were used for the two central proofs, and ChatGPT was used to help with the writing; the authors state that they take full responsibility for all mathematical claims.

• Scope of the operational claims. The results concern vanishing-error classical communication and parallel LOCC simulation. Strong-converse thresholds, reliability functions and simulation against adaptive tests are left open.

• Zero temperature only. The support condition is sufficient, not necessary. Generalized amplitude damping and most higher-dimensional channels are not covered.

• Different resource models. The authors caution that comparisons between capacities and simulation costs use different free resources. That the quantum capacity vanishes for p ≥ 1/2 while the entanglement cost stays positive does not by itself imply irreversibility.

Paper information

• Title: Classical Capacity and Entanglement Cost of the Amplitude Damping Channel

• Authors: Ziao Tang, Ge Bai, Xin Wang (The Hong Kong University of Science and Technology (Guangzhou)); Chengkai Zhu (QudeLeap Research, Shanghai)

• arXiv: 2609.28592v1 [quant-ph], submitted 23 September 2026, listed 25 September 2026

• DOI: 10.48550/arXiv.2609.28592

• Length: 21 + 8 pages, 1 figure

• Lean formalization (as cited in the paper): github.com/QuAIR/Classical-Capacity-Qubit-Amplitude-Damping (not publicly reachable as of 27 September 2026)

Primary sources

• Z. Tang, C. Zhu, G. Bai, X. Wang, Classical Capacity and Entanglement Cost of the Amplitude Damping Channel, arXiv:2609.28592 (HTML full text)

• C. H. Bennett, P. W. Shor, J. A. Smolin, A. V. Thapliyal, Entanglement-assisted capacity of a quantum channel and the reverse Shannon theorem, IEEE Trans. Inf. Theory 48, 2637 (2002)

• V. Giovannetti, R. Fazio, Information-capacity description of spin-chain correlations, Phys. Rev. A 71, 032314 (2005)

• K. Matsumoto, T. Shimono, A. Winter, Remarks on additivity of the Holevo channel capacity and of the entanglement of formation, Commun. Math. Phys. 246, 427 (2004)

• M. B. Hastings, Superadditivity of communication capacity using entangled inputs, Nature Physics 5, 255 (2009)