TeleGate Operation in Fault-Tolerant Teleportation

• TeleGate operation is a 1-ebit multi-gate teleportation primitive that compresses n same-control remote gates into one non-local crossing with local fan-out, reducing the entanglement cost.
• It employs a non-local CNOT and subsequent local fan-out CNOTs, creating a correlated weight-n error mode that challenges decoder designs.
• Design rules ensure fault tolerance by limiting packet size relative to code distance, optimizing performance especially in high network-noise regimes.

TeleGate operation, in the sense developed for fault-tolerant multi-gate teleportation, is a 1-ebit multi-gate teleportation primitive that replaces a sequence of $n$ remote same-control gates by a single non-local crossing plus a local fan-out circuit. In the formulation of "Design rules for fault-tolerant multi-gate teleportation" (Rennela, 1 Jul 2026), it packages $n$ remote gates “behind” one network use, reducing entanglement cost from $n$ ebits to $1$ ebit while introducing a distinctive correlated failure mode: a single network fault can generate a weight-$n$ Pauli error aligned with a logical operator.

1. Operational structure

TeleGate operation targets a run of remote gates sharing the same control qubit. Instead of teleporting each remote CNOT separately, one first performs a single non-local CNOT from the source control qubit $q$ to a designated bridge or first target qubit $t_1$, and then locally fans that action out from $t_1$ to the remaining targets $t_2,\dots,t_n$ using only local CNOTs. The paper describes the resulting object as a same-control MGT packet: “a single non-local CNOT$(q \to t_1)$, preceded and followed by local fan-out CNOTs for $n$0” (Rennela, 1 Jul 2026).

In the EJPP implementation used for the quantitative claims, the non-local CNOT consumes one ebit and two rounds of classical communication. The full packet of $n$1 remote gates is therefore implemented using one entangled pair, independent of $n$2. This differs from sequential gate teleportation, where each of the $n$3 remote CNOTs is teleported independently, consuming $n$4 separate ebits and incurring $n$5 independent network uses. The explicit tradeoff is central: TeleGate saves $n$6 ebits, but it introduces $n$7 extra local fan-out CNOTs and a qualitatively different error model (Rennela, 1 Jul 2026).

The paper emphasizes that this behavior is not EJPP-specific. The correlated fault mechanism is “forced by the 1-ebit fan-out bottleneck,” so any scheme that compresses $n$8 remote gates into one non-local crossing inherits the same structural behavior. A plausible implication is that TeleGate is best understood not as a protocol detail of one remote-gate construction, but as a packetisation pattern for distributed controlled operations.

2. Correlated error propagation

The defining hazard of TeleGate operation is Pauli propagation through the fan-out circuit. For the same-control packet, the dangerous event is an $n$9-type fault entering at the network crossing or on the bridge qubit before fan-out. Through the non-local CNOT$n$0, the paper states

$n$1

and each subsequent local fan-out CNOT$n$2 copies $n$3 onto $n$4. A single $n$5 fault before the crossing therefore becomes

$n$6

which, restricted to the target register, is a contiguous weight-$n$7 $n$8 string (Rennela, 1 Jul 2026).

The same target-only weight-$n$9 string also arises from an $1$0 fault on $1$1 between the non-local step and the fan-out. By contrast, faults on downstream targets $1$2 with $1$3 remain localized. TeleGate therefore does not transform one network failure into $1$4 independent single-qubit errors; it produces an all-or-nothing correlated event.

Under depolarizing network noise, both $1$5 and $1$6 are dangerous because the $1$7 component of $1$8 propagates in the same way. The effective rate for producing the weight-$1$9 target $n$0-string is

$n$1

rather than $n$2. $n$3-type faults are asymmetric and much less dangerous in this same-control configuration: a $n$4 on $n$5 stays localized, while a $n$6 on a downstream target propagates only to a localized weight-2 error $n$7. No $n$8 fault produces a weight-$n$9 string in the same-control case. The dual same-target configuration swaps the roles, so the dangerous correlated object becomes a weight-$q$0 $q$1 string on the controls (Rennela, 1 Jul 2026).

In the worst-case placement, all $q$2 targets lie contiguously along a minimum-weight logical operator of the code. The packet fault is then exactly the kind of structured correlated error that can mimic “a logical error chain on the logical $q$3 operator.”

3. Correctability bounds and decoder behavior

For rotated surface codes of odd distance $q$4, the paper derives two packet-size bounds. The decoder-independent correctability condition is the standard one: $q$5 Hence any packet with

$q$6

is safe regardless of decoder details or geometry. The algebraic argument is that if two packet errors $q$7 both have weight $q$8, then $q$9 has weight at most $t_1$0, so it cannot be a nontrivial logical operator (Rennela, 1 Jul 2026).

The sharper design rule depends on whether the decoder represents the packet fault as one correlated event or as $t_1$1 independent elementary edges: $t_1$2 With a naive decoder built from a base detector error model (DEM), the packet fault is misinterpreted as independent local edges. At

$t_1$3

a contiguous packet error $t_1$4 on a minimum-weight logical string has the same syndrome as its lower-weight complement $t_1$5, and minimum-weight decoding chooses the complement, leaving the logical operator as residual error. This yields the naive bound (Rennela, 1 Jul 2026).

A correlation-aware decoder changes the matching weights. In the packet DEM, the packet fault appears as a single CORRELATED_ERROR edge with matching weight

$t_1$6

rather than $t_1$7 separate edges of total weight $t_1$8. At $t_1$9, the complement path has weight $t_1$0. The paper argues that whenever $t_1$1, the single packet edge is cheaper, so MWPM selects the true correlated packet event rather than its complement. This is the sole reason the correlation-aware rule extends by one qubit. For

$t_1$2

both decoders fail in the worst case, because the error weight itself exceeds what can be disambiguated by the code (Rennela, 1 Jul 2026).

A recurrent misconception is that correlation awareness requires a bespoke decoding algorithm. The paper rejects that reading explicitly: standard MWPM in PyMatching is already sufficient if it is built from the packet circuit’s own detector error model. The correlation is carried by the circuit-level DEM; no custom decoder is required.

4. Performance regimes and resource tradeoffs

The simulations use a simplified circuit-level depolarizing model with gate noise only,

$t_1$3

and define the network-to-local noise ratio as

$t_1$4

The comparison baseline is physically honest sequential teleportation with $t_1$5 independent network faults, each at the same per-link rate. The principal conclusion is regime-dependent: packetisation is most useful when the network is the bottleneck, i.e. $t_1$6 (Rennela, 1 Jul 2026).

With a naive DEM/decoder, packet logical error rate worsens significantly as $t_1$7 increases, because the decoder misreads the correlated packet fault. With the packet DEM, standard MWPM becomes correlation-aware through the model and packet LER drops to the gate-noise floor, becoming almost $t_1$8-independent over the tested range. Relative to sequential teleportation, packetisation is slightly worse around $t_1$9, because the $t_2,\dots,t_n$0 extra local fan-out CNOTs add gate noise while the one-network-use advantage is not yet decisive. At moderate-to-high $t_2,\dots,t_n$1, packetisation becomes favorable, and the advantage grows with both $t_2,\dots,t_n$2 and $t_2,\dots,t_n$3 (Rennela, 1 Jul 2026).

The reported numerical examples are consistent with that pattern. At $t_2,\dots,t_n$4, packet/sequential is slightly worse at $t_2,\dots,t_n$5 and $t_2,\dots,t_n$6 with ratios $t_2,\dots,t_n$7 and $t_2,\dots,t_n$8, but better by $t_2,\dots,t_n$9 and clearly better by $(q \to t_1)$0 with ratio $(q \to t_1)$1. At $(q \to t_1)$2, the packet is very slightly worse at $(q \to t_1)$3 with ratio $(q \to t_1)$4, approximately equal by $(q \to t_1)$5, and clearly better for $(q \to t_1)$6 with ratios $(q \to t_1)$7. At $(q \to t_1)$8, packetisation already wins at $(q \to t_1)$9 with ratio $n$00. The paper summarizes the trend as packetisation “matches or surpasses the per-link sequential baseline at moderate-to-high $n$01, with the advantage growing with both $n$02 and $n$03” (Rennela, 1 Jul 2026).

The operational point is narrow but important: entanglement savings alone do not make TeleGate uniformly preferable. When local and network noise are comparable, the extra local fan-out can offset the one-ebit advantage.

5. Design rules for compilers and architecture

The compiler-facing guidance is explicit. When entanglement generation is expensive or noisy, TeleGate should be preferred, but only within a packet size that preserves fault tolerance: $n$04 provided the decoder is built from the packet circuit DEM. If one cannot model the correlation correctly, the stricter rule is

$n$05

At $n$06, packetisation may not help; at $n$07, and especially for larger $n$08, it is typically advantageous. The paper further notes that recent distributed architectures often lie in $n$09, “squarely in the regime where packetisation outperforms sequential teleportation” (Rennela, 1 Jul 2026).

Practically, TeleGate operation means identifying a run of same-control remote controlled-Clifford gates between modules, performing one non-local gate using one shared Bell pair, and then applying local fan-out CNOTs to distribute the effect to all $n$10 targets. Teleportation byproducts are tracked in the usual Pauli frame, while the packet-specific risk remains the correlated weight-$n$11 fault. This suggests a concrete compiler heuristic: package aggressively only when the packet size remains within the code-distance bound and the DEM supplied to decoding preserves the packet correlation.

If a larger packet is required, the paper proposes a hybrid $n$12-ary fan-out tree using $n$13 ebits, which reduces the worst-case correlated error weight from $n$14 to approximately $n$15, with

$n$16

This interpolates between fully packetised 1-ebit TeleGate $n$17 and fully sequential teleportation $n$18 (Rennela, 1 Jul 2026).

6. Position within the gate-teleportation literature

In related distributed-quantum-computing literature, telegate often denotes a remote two-qubit gate executed by consuming shared entanglement and using only local operations, measurements, and classical feedforward. One line of work uses one Bell pair to implement a remote CNOT between modules or separated qubits (Gupta et al., 10 Oct 2025); a trapped-ion realization demonstrated a deterministic teleported CNOT between spatially separated ions using one shared entangled pair, local mixed-species gates, measurements, and real-time conditional operations (Wan et al., 2019). More general network simulations have extended gate teleportation to arbitrary two-qubit Clifford gates and the Toffoli gate in multi-node settings, again using Bell pairs, Bell measurements, and conditional corrections (Uotila, 2024).

Other work has treated telegate as a systems primitive rather than only a circuit identity. Asynchronous telegate reorganizes measurement and classical communication so that some remote-gate latency is hidden behind local unitary work, while preserving the same Bell-pair and classical-bit requirements (Peckham et al., 2024). Routing-oriented work uses teleported gates as virtual long-range edges on limited-connectivity hardware, selectively replacing SWAP-heavy realizations of CNOT or controlled-$n$19 gates to reduce temporal depth (Babu et al., 6 Feb 2025).

Against that background, the distinctive feature of TeleGate operation in fault-tolerant multi-gate teleportation is not merely that it teleports a remote gate. It packages multiple same-control remote gates into a single non-local crossing plus a local fan-out tree, reducing entanglement cost from $n$20 ebits to $n$21 ebit while introducing a specific correlated weight-$n$22 failure mode and code-distance-dependent packet-size rules (Rennela, 1 Jul 2026). This places TeleGate at the intersection of remote-gate execution, decoder modeling, and distributed circuit compilation rather than at the level of a single remote CNOT primitive alone.