Distributed Gates via Teleportation

To make many small quantum processors behave as one large machine, you need two-qubit gates between qubits that live on different chips. You cannot route a wire between them — but if the two nodes share a Bell pair, you can execute a remote entangling gate by consuming that pair and exchanging a few classical bits. This is the building block of modular and distributed quantum computing.

The goal: a nonlocal CNOT

We want a CNOT whose control is data qubit $q_0$ on node $A$ and whose target is data qubit $q_3$ on node $B$ , without moving either data qubit. The resource is one shared Bell pair on ancilla qubits $q_1$ (held by $A$ ) and $q_2$ (held by $B$ ):

|\psi\rangle_{q_0}\otimes |0\rangle_{q_3}\otimes |\Phi^+\rangle_{q_1 q_2} \;\xrightarrow{\text{local ops + classical bits}}\; \mathrm{CNOT}_{q_0\to q_3}\,\big(|\psi\rangle_{q_0}\otimes |0\rangle_{q_3}\big).

Notice the cost: one Bell pair and two classical bits realise one nonlocal CNOT. Entanglement is the fuel; classical communication carries the corrections.

How the protocol works

The construction (Eisert–Jozsa–Plenio) threads the control's information into the target through the shared pair in four moves:

Couple the control in. $A$ applies $\mathrm{CNOT}_{q_0\to q_1}$ , writing the control's value into its half of the Bell pair. Because the pair is entangled, this parity is now shared with $B$ .
Couple the target in. $B$ applies $\mathrm{CNOT}_{q_2\to q_3}$ , transferring the shared parity onto the target qubit — this is the actual conditional flip.
Measure and correct the target. $A$ measures $q_1$ in the $Z$ basis and sends the bit; $B$ applies $X^{m}$ to $q_3$ . (Deferred form: $\mathrm{CNOT}_{q_1\to q_3}$ .)
Measure and correct the control. $B$ measures $q_2$ in the $X$ basis and sends the bit; $A$ applies $Z^{m}$ to $q_0$ to remove a residual phase. (Deferred form: $H$ on $q_2$ then $\mathrm{CZ}_{q_2\to q_0}$ .)

After step 4 the ancillas are discarded, and $q_0, q_3$ are left in exactly the state a local CNOT would have produced. The data qubits never left their nodes.

Counting the resources

The bookkeeping is exact and worth memorising:

| Resource | Amount per nonlocal CNOT | |----------|--------------------------| | Shared Bell pairs | 1 | | Classical bits ( $A\to B$ ) | 1 | | Classical bits ( $B\to A$ ) | 1 | | Local two-qubit gates | 2 |

Because each remote gate burns one Bell pair, a distributed algorithm's communication cost is just the number of cross-node gates it needs — which is why compilers for modular hardware work hard to keep partitions weakly coupled.

Try it

Implement the nonlocal CNOT. The test prepares control $= |1\rangle$ and target $= |0\rangle$ , so a correct remote CNOT must flip the target to $|1\rangle$ while leaving the control at $|1\rangle$ . The grader asserts the two marginals: $P(q_0 = 1) = 1$ and $P(q_3 = 1) = 1$ .

Run your code to see the quantum state.

The ancilla qubits come out random (they were measured), but the two data qubits are deterministic — the remote CNOT has fired exactly as a local one would.