But you’ll have to click on the paper for the (very short) proof that this new lower depth is probably optimal.

Paper is here: scirate.com/arxiv/2509.0...

But honestly you can get most of the gist from the figure I posted, or by opening the circuits in Crumble:

algassert.com/crumble#circ...

algassert.com/crumble#circ...

(I think it’s likely that being able to do a controlled_(C_XYZ) between surface codes would violate the BPT bound on transversal gates in 2D, because that operation is non-Clifford. There’s a bit of an asterisk there, since I’m allowing both transversal and fold-transversal operations, but still)

I can do a controlled_(C_XYZ) between a cat state control and a surface code target, which is enough for measuring C_XYZ fault-tolerantly. Unfortunately, I don't know how to do a controlled_(C_XYZ) between two surface codes, which I think is what you're proposing here?

Anyway, if you happen to figure this out, please let me know. Until then, my little observation is more of a curiosity than a discovery.

The thing that would make this observation useful is a way to (even probabilistically) transform these magic states into a normal magic state we actually use. Something like |T> or |CCZ>. Or inside the Clifford hierarchy, at least!

The problem is, these states are a nightmare to use. You can't use them to directly teleport gates. Bravyi/Kitaev demonstrate how to probabilistically use them to teleport e^{i pi Z/12} gates, but half the time you get a e^{-i pi Z/12} gate instead, which is hard to correct!

To measure this operator, you just control the C_XYZ operators with some cat ancilla. So, it is basically certain that you can cultivate this magic state on the surface code MUCH EASIER than T magic states--with lower circuit depth, and likely higher fidelity and success rate!

However, there is another (less loved) magic state that Bravyi/Kitaev originally proposed: The eigenstate of the (X+Y+Z) operator. Interestingly, this operator is almost transversal on the surface code: algassert.com/crumble#circ...

Cultivation works by measuring the (X+Y) operator, because the |T> state is the +1 eigenstate of (X+Y). (X+Y) is easy to measure on color codes (it's transversal), but not on surface codes. That's why my paper had to use a code deformation, and why the others used 3-qubit gates.

One point that I make in my paper that I want to highlight: surface code cultivation is not restricted to odd distances. Color codes only exist at odd distances, but surface codes can have any distance. Because we are postselecting, even distance codes are meaningful to consider!

My paper is here: scirate.com/arxiv/2509.0...

Also out today:

* Similar work from
@ShrutiPuri11
's group, using 3-qubit gates rather than code deformation, scirate.com/arxiv/2509.0...

* A majorly updated paper on the same topic from researchers at AWS, scirate.com/arxiv/2502.0...

To end, a few random things about the dynamic circuit:
* The spatial distance is reduced ❌
* The timelike distance is larger by a factor of 4/3 ✅
* Unlike the standard circuit, this circuit cannot be "pipelined." However, we can reduce the measurement depth by adding qubits 🤷

Our dynamic circuit:
* Has an increased threshold compared to the standard circuit (.29% vs .21%) ✅
* Automatically removes leakage, because every data qubit is measured after every four gates ✅
* Has a teraquop footprint nearly 3x smaller than the standard circuit ✅

However, something interesting happens for the case of the Floquet code: we CAN measure all the two-qubit operators in a layer simultaneously, because they don't overlap! This suggests that dynamic circuits might be uniquely suited for the Floquet code.

In general, dynamic circuits offer limited improvements. They eliminate ancilla qubits, but may also decrease the spatial distance. In addition, you can't measure all the stabilizers simultaneously with a morphing circuit--if some stabilizers shrink, others will grow!

However, there is another method for measuring operators without using ancilla qubits, "dynamic" or "morphing" circuits (arXiv:2302.02192). We apply a unitary to the data qubits to shrink a stabilizer to a single-qubit operator, then measure that qubit. E.g., in the surface code:

The Floquet code is an error correcting code which only requires measuring two-qubit operators (arXiv:2107.02194). Previously, people measured those operators the way you'd expect: Use an ancilla qubit for each operator you want to measure (arXiv:2108.10457,arXiv:2202.11845).