Routing Quantum Information: SWAP, iSWAP, and Moving Qubit States

Introduction

Quantum computers face a unique challenge in moving quantum information between qubits. Unlike classical bits that can be shuttled freely along wires, qubits cannot be arbitrarily copied or moved due to the no-cloning theorem.

To route a qubit’s state from one location to another, one must use quantum operations that effectively reposition the state without making a separate copy. This is especially critical in architectures like superconducting qubits, where each qubit typically interacts only with a few neighbors (limited connectivity). In such systems, implementing an algorithm often requires moving qubit states around so that the right qubits can interact.

The Challenge of Moving Qubit States

Most quantum hardware has a fixed connectivity graph – qubits only directly interact with specific neighbors. If an algorithm needs two qubits to interact but they are not directly connected, their quantum states must be brought together via intermediate operations. The straightforward way to do this is by using a sequence of SWAP gates: each SWAP exchanges the states of two adjacent qubits, effectively “hopping” a qubit’s state along a chain until it reaches the target qubit. In other words, “the SWAP gate allows a two-qubit operation between two distant qubits to be performed by repeatedly swapping the states within a chain of qubits, until the desired qubit states come adjacent to one another“. This is analogous to swapping two items in an array by repeatedly exchanging neighboring elements until the items’ positions are swapped.

Why is this challenging? Each SWAP operation is itself a multi-qubit gate (usually decomposed into several primitive gates), which adds circuit depth and incurs error. As IBM’s documentation notes, when a circuit is mapped onto hardware with limited connectivity, “SWAP gates [each implemented as three CX gates] may need to be inserted to move the quantum information around,” but “each inserted SWAP… will cause a lot of errors on current devices”.

Thus, reducing the number of SWAPs (or finding alternative ways to route qubits) is crucial for scaling up quantum computations. Some platforms naturally mitigate this – for example, ion traps or photonic systems can have near-global connectivity – but superconducting qubit chips often have only nearest-neighbor couplings on a 2D grid, making routing a major concern.

In the following sections, we explore the main tools for moving qubit states: the SWAP gate and its variants like iSWAP, and how they are implemented across different quantum computing modalities.

The SWAP Gate: Exchanging Qubit States

The SWAP gate is the canonical operation for exchanging two qubits’ states. Acting on qubits $$q_1$$ and $$q_2$$, SWAP simply swaps the two states: if $$q_1$$ is in state $$|a\rangle$$ and $$q_2$$ in $$|b\rangle$$ (for $$a,b\in{0,1}$$), then after SWAP, $$q_1$$ is in $$|b\rangle$$ and $$q_2$$ in $$|a\rangle$$. In the two-qubit computational basis $${|00\rangle,|01\rangle,|10\rangle,|11\rangle}$$, the SWAP gate is represented by the 4×4 unitary matrix:

$$$U_{\text{SWAP}} \;=\; \begin{pmatrix} 1 & 0 & 0 & 0\\[6pt] 0 & 0 & 1 & 0\\[6pt] 0 & 1 & 0 & 0\\[6pt] 0 & 0 & 0 & 1 \end{pmatrix}$$$,

which indeed swaps the amplitudes of $$|01\rangle$$ and $$|10\rangle$$ while leaving $$|00\rangle$$ and $$|11\rangle$$ unchanged. A SWAP gate does not create entanglement – it’s essentially a permutation of basis states (in fact, SWAP can be viewed as a classical operation on the computational basis). Any two-qubit product state remains unentangled after a SWAP (it just permutes which qubit has which state). Because of this, SWAP is considered a Clifford (and even permutation) operation, not by itself useful for generating entanglement or quantum phase. Nonetheless, SWAP is vital for routing: “it doesn’t create entanglement by itself…but it’s used to move qubit states around”, especially in hardware with limited connectivity.

Circuit Decomposition

The SWAP gate can be decomposed into three CNOT (controlled-NOT) gates. A common decomposition is:

$$$\text{SWAP}(q_1,q_2) = \text{CNOT}(q_1,q_2)\; \text{CNOT}(q_2,q_1)\; \text{CNOT}(q_1,q_2)$$$,

which indeed yields the swap of $$q_1$$ and $$q_2$$’s states. Intuitively, the first CNOT uses $$q_1$$ to flip $$q_2$$ if $$q_1$$ is 1 (xoring the bits), the second uses the new $$q_2$$ state to flip $$q_1$$, and the third uses the original $$q_1$$ (now in $$q_2$$) to flip back $$q_2$$ if needed – resulting in exchanged states. This 3-CNOT sequence is a standard way compilers insert SWAPs using a device’s native CNOT (or CZ) gates. However, three two-qubit gates per SWAP is costly. If many swaps are needed to bring distant qubits together, the gate count and error probability grow quickly. That’s why researchers explore more direct or efficient implementations of SWAP, which we will discuss for specific platforms.

Properties and Use Cases

As noted, SWAP by itself is not entangling (it’s essentially a permutation gate). However, it’s uniquely capable of reordering qubits. The “SWAP-like” family of gates is actually the only set of two-qubit gates that can take any separable input state to any other separable state (up to single-qubit transforms).

In practical terms, SWAP is indispensable whenever qubit connectivity is a limiting factor. If a quantum algorithm needs qubit A (holding some data) to interact with qubit Z, but A and Z aren’t directly connected, the solution is to perform a series of SWAPs along a path between A and Z. Each SWAP hops the quantum state to an adjacent qubit until finally the state originally in A resides in some qubit next to Z, enabling the desired two-qubit gate. In systems “without long-range connectivity,” the SWAP gate is “useful” precisely for this reason.

Quantum compilers automate this process during circuit routing: an abstract algorithm with arbitrary two-qubit gates is transformed into one respecting the hardware’s coupling graph by inserting SWAPs.

One important point is that not all architectures support a native SWAP operation. As we’ll see, some qubit technologies have interactions that naturally enact SWAP (or partial swaps), while others realize SWAP only through composing other gates. We will examine these differences across platforms. First, let’s introduce a closely related gate that often appears: the iSWAP.

The iSWAP Gate and Partial Swaps

The iSWAP gate is a variant of the swap operation that introduces a quantum phase. Specifically, iSWAP swaps the $$|01\rangle$$ and $$|10\rangle$$ amplitudes and multiplies them by a phase of $$i$$ (the imaginary unit). In matrix form (basis $${|00\rangle,|01\rangle,|10\rangle,|11\rangle}$$):

$$$U_{\text{iSWAP}} \;=\; \begin{pmatrix} 1 & 0 & 0 & 0\\[6pt] 0 & 0 & i & 0\\[6pt] 0 & i & 0 & 0\\[6pt] 0 & 0 & 0 & 1 \end{pmatrix}$$$.

This means $$|01\rangle \to i|10\rangle$$ and $$|10\rangle \to i|01\rangle$$, while $$|00\rangle$$ and $$|11\rangle$$ remain unchanged. Essentially, it’s a SWAP with an extra 90° phase on the two off-diagonal elements. The inverse of iSWAP is iSWAP$$^\dagger$$ which would have $$-i$$ in those positions (since $$i \times -i = 1$$, undoing the phase).

The iSWAP is entangling (unlike SWAP) because of that phase factor. In fact, iSWAP belongs to a family of entangling gates often parameterized as $$f\text{Sim}(\theta,\phi)$$ in literature – which includes the √SWAP and √iSWAP gates as special cases. Notably, a √SWAP (square-root-of-SWAP) is a gate that performs “halfway” of a swap, creating a superposition of swapped and unswapped states. √SWAP has the matrix that is the square root of the SWAP matrix; it entangles qubits by mixing their states (after two √SWAPs, a full SWAP is achieved). Likewise, √iSWAP is a half-angle version of iSWAP – and indeed two √iSWAP gates in sequence produce a full iSWAP.

These partial swap gates are important because many physical systems naturally implement a continuous exchange interaction, where letting the interaction run for different durations yields different swap angles (from no swap, to partial, to full swap). Such interactions can generate entanglement at intermediate times (e.g. √iSWAP is entangling).

Use Cases of iSWAP

In terms of routing information, an iSWAP still swaps the qubits’ states (just with an added phase that one must track or correct). If our goal is purely to move a qubit’s state, a full SWAP (with no extra phase) is usually desired.

However, iSWAP is extremely relevant because many hardware implementations find it easier to enact than a true SWAP. Some physical interactions naturally implement iSWAP. For example, in superconducting qubits with a capacitive coupling (an exchange interaction), the two qubits essentially swap excitations back and forth coherently – which is an iSWAP oscillation.

Similarly, in quantum dot spin qubits, the exchange interaction between two electron spins yields a continuous SWAP (in fact an iSWAP when turned on for a specific duration). Thus, iSWAP-type gates are often “native” two-qubit operations in those platforms, whereas a SWAP might require combining multiple operations.

To convert an iSWAP to a true SWAP, one can add phase correction gates. In fact, a SWAP can be decomposed into an iSWAP followed by a CZ (controlled-Z) gate (and some single-qubit rotations). The iSWAP does the actual exchange of state, but it introduces unwanted phase ($$i$$ on $$|01\rangle$$ and $$|10\rangle$$) – a subsequent CZ gate can correct those conditional phases. A recent experiment demonstrated exactly this: a composite SWAP gate made of one iSWAP + one CZ on a superconducting processor, achieving SWAP with fewer gates than the usual three CNOTs or three iSWAPs. Because CZ and iSWAP commute, one could even apply them simultaneously to speed up the operation. This highlights how iSWAP serves as a convenient stepping stone to SWAP in platforms where iSWAP is more native.

To summarize, SWAP vs. iSWAP: both exchange the qubit states, but iSWAP adds a 90° phase to the exchanged components. SWAP is non-entangling and mainly used for routing, whereas iSWAP (and partial swaps) are entangling and often emerge naturally from exchange couplings.

In the next sections, we discuss how these gates (or similar mechanisms) are realized in different quantum computing platforms, and how qubit routing is accomplished beyond just logical SWAP gates.

Moving Qubits in Superconducting Processors

Superconducting qubit chips (such as transmon qubits on a 2D lattice) typically have only nearest-neighbor couplings. A qubit might connect to 2-3 others, forming a fixed graph (for example, IBM’s “heavy-hex” lattice or Google’s Sycamore grid). Thus, superconducting architectures lack long-range connectivity, and SWAP gates are needed to route information across the chip. Ironically, the SWAP gate itself is usually not native in these systems – the native two-qubit interactions are often of CZ (Ising-like) or iSWAP (exchange-like) type. Consequently, moving a qubit’s state may require multiple operations.

Native Gates and SWAP Composition

In many superconducting qubit designs, the basic two-qubit gate is a controlled-phase (like CZ) or cross-resonance CNOT, which does not swap qubits but rather entangles them via Z-Z or X-Y interactions. A SWAP can be constructed, but requires 3 CNOT/CZ gates. This is why typical transpiled circuits on IBM devices show triples of CX gates whenever a SWAP is inserted.

However, newer approaches use tunable couplers to achieve different interactions on demand. For instance, by modulating a coupler or applying parametric microwave drives, one can implement an XX+YY exchange interaction between two transmon qubits, which directly realizes an iSWAP gate. An iSWAP swaps the qubits’ excitations with a phase, as discussed. Using such a native iSWAP, a full SWAP can be done with just one iSWAP + one CZ (instead of three gates). Chalmers University researchers in 2024 demonstrated exactly this on a fixed-frequency transmon chip with a tunable bus coupler: they implemented a SWAP by sequential iSWAP and CZ, and showed it is more efficient than the standard three-gate decomposition. In their device, the parametrically driven coupler could mediate both iSWAP-type and CZ-type interactions, enabling a flexible gate set (CZ, iSWAP, and hence SWAP). This extensible gate set is powerful – having direct access to CZ-, iSWAP-, and SWAP-family gates means any two-qubit Clifford operation can be done with at most one gate from each family, simplifying compilation.

Notably, SWAP is “not native to most quantum processors” (except a few like quantum dots). But recent breakthroughs show it’s possible to make SWAP native by clever engineering. MIT researchers (Sung et al., 2021) used a tunable coupler to achieve a “ZZ-free iSWAP” gate at high fidelity ~99.87%, alongside a high-fidelity CZ. By removing unwanted coupling (like residual ZZ interactions) during the iSWAP, they improved gate fidelity. This suggests that with tunable interactions, one can dynamically switch between gate types (CZ vs iSWAP) as needed. Another work demonstrated a direct iSWAP between non-neighboring superconducting qubits via a microwave cavity bus (though that particular result was with spin qubits coupled by a superconducting resonator, showing the principle of cavity-mediated swap).

In general, superconducting platforms are exploring coupler elements to dynamically control two-qubit interactions, which allows turning connectivity on and off and even coupling distant qubits. For example, a bus resonator or tunable coupler can connect qubits that are not always directly connected, effecting an on-demand swap of states (or an entangling operation).

Despite these advances, the common scenario today is that a SWAP is achieved via multiple gates on superconducting chips. Therefore, qubit routing on such hardware relies heavily on inserting those SWAP gate sequences. Each SWAP (3 CX gates) carries the risk of errors. Recent experiments underscore this: a composite SWAP (iSWAP+CZ) gate of ~640 ns plus overhead was implemented with an error such that the upper bound fidelity was ~97.4% in their setup. While 97% is decent, it’s lower than typical single two-qubit gate fidelities (~99%), purely due to the longer duration and complexity of the SWAP sequence. Researchers project that optimizing pulse shapes and perhaps simultaneously running the iSWAP and CZ (since they commute) could halve the SWAP time and push errors below 0.1% – an encouraging outlook for the future.

In summary for superconducting qubits: because physical qubits are fixed on a chip, we cannot literally move the qubit itself; instead, we move its state through a relay of SWAP operations. The SWAP can be constructed from native gates (with overhead), or more directly with tunable coupling hardware that implements exchange interactions. As devices scale up, this routing overhead is a major consideration – which is why adding long-range couplers or using alternative methods (like teleportation, discussed later) are of high interest.

Moving Qubits in Trapped-Ion Systems

Trapped-ion quantum computers present a very different scenario: here qubits are individual ions held in an electromagnetic trap, and in many designs all ions share collective motional modes that enable long-range interactions. In fact, a hallmark of ion traps is all-to-all connectivity (in a single trap zone, any ion’s spin can be entangled with any other via applying global laser pulses). This drastically reduces the need for SWAP gates – one can perform gates between arbitrary pairs without moving the ions.

However, as the number of ions grows, using a single trap becomes slow or impractical; thus, advanced ion trap architectures use multiple trapping zones and shuttling of ions between zones. In those cases, we reintroduce the need to move qubit states, but now one has a choice: do it logically (via SWAP gates) or physically (by moving ions).

One of the advantages of ions is that you can literally transport the qubit itself. Ions can be shuttled by electrostatic potentials, or two ions’ positions can be swapped by moving them around each other in the trap. This physical swapping is effectively a SWAP gate on their quantum states, but achieved through motion rather than multi-qubit logic gates. A 2017 experiment by Kaufmann et al. demonstrated a high-fidelity ion swap by fast transport: they used a segmented ion trap to physically exchange two ions’ positions and achieved a SWAP gate with 99.5% mean process fidelity. Importantly, they integrated this with other operations (initialization, single-qubit gates, readout) and even performed a three-ion reordering: they reversed the order of a chain of 3 ions, which is a more complex permutation, and verified a 99.96% fidelity for that reordering in the logical basis.

These results show that “the swap operation [via physical motion]” can be done with extremely high fidelity in ion traps, leveraging the precise control over ion transport.

Physical shuttling has some overhead (time needed to move ions, and potential motional excitation). But modern ion traps use techniques like junctions to move ions around corners and split/merge operations to reorder ions efficiently. Because a physically swapped ion retains its quantum state (coherence) if done adiabatically or with careful control, this approach can outperform a sequence of multi-qubit gates in fidelity when swapping distant ions. Indeed, in many designs, instead of using 3 entangling gates to swap two ions’ qubit states, it may be easier to just rotate their positions.

Even without physically moving, trapped ions enjoy flexible connectivity: through Mølmer-Sørensen interactions or other multi-qubit gate schemes, any ion can be entangled with any other by appropriate laser beam targeting. This means a compiler doesn’t need to insert SWAPs for connectivity as often – the hardware is almost fully connected. However, for very large systems spanning multiple trap zones or modular ion trap setups, one might physically move ions carrying entangled states between zones (a process sometimes called a “quantum CCD” architecture).

In summary, ion trap qubit routing can often be achieved by physical reordering. The ability to transport qubits directly is a huge strength of trapped ions. They can minimize logical SWAP gates, instead using a “conveyor belt” to bring qubits together. The challenge shifts to engineering traps that can shuttle ions quickly without decoherence. So far, demonstrations show high success rates.

Moving Qubits in Spin Qubits (Quantum Dots and Silicon)

Spin qubits (such as electron spins in quantum dot arrays, or donor spins in silicon) often reside in a solid-state lattice with only nearest-neighbor interactions (similar to superconductors in that sense). The natural two-qubit interaction for spins in adjacent quantum dots is the exchange interaction – which, in essence, swaps the spin states depending on the exchange coupling strength and duration. In fact, an isotropic Heisenberg exchange between two spins directly implements a SWAP (with some phase nuances): it can continuously evolve the two-spin state from $|01\rangle$ to $|10\rangle$ and back (oscillating populations), which corresponds to an iSWAP-type exchange. This means that, “notably, the SWAP gate is native to quantum-dot-based processors” using this exchange coupling. For example, in a double quantum dot with two electrons (one in each dot), turning on the exchange interaction for a full period will swap the spin states of the two electrons (this is essentially the √SWAP entangling gate at half interaction time, and full SWAP at full interaction time). Because of this, some quantum dot qubit implementations treat √SWAP or SWAP as part of their native gate set. It’s Clifford in the full SWAP case and can be used for routing, and √SWAP (entangling) for logic.

The challenge for spin qubits is not swapping between neighbors – that’s relatively straightforward via exchange – but rather connecting qubits that are far apart on a chip. Local exchange typically only works for nearest neighbors (coupled by tunnel barriers or direct interaction within ~100 nm distance). How do you move a spin qubit’s state across, say, a large quantum dot array or from one region of a chip to another? Several approaches are being pursued:

• Chains of swaps: One can perform successive exchange gates hopping an electron spin state along a chain of quantum dots (similar to swapping along a superconducting qubit line). This is the straightforward but potentially slow approach – every hop costs gate operations and time, during which decoherence can happen.
• Shuttling the electron: Instead of swapping the spin state from dot to dot, one can physically move the electron (which carries the spin) through an array by modulating gate voltages. This is akin to how trapped ions are moved, but here moving a charged particle through a semiconductor channel. Experiments have demonstrated moving electrons across tens of quantum dots, and even using surface acoustic waves (SAWs) to propel electrons between distant locations. Shuttling is attractive because it literally transports the qubit, but it requires sub-nanosecond control to preserve the spin phase and avoid losing the electron. As noted in a recent review, “electrically controlled shuttling is promising but relatively slow, and the distance is constrained by coherence times”. In other words, you can only shuttle as far as the spin can remain coherent during transit, unless you refresh or rebalance the quantum state.
• Long-range couplers: A particularly promising method is using a mediator like a superconducting resonator or a third intermediate quantum dot to connect distant spins. In 2024, a team led by Vandersypen demonstrated cavity-mediated iSWAP oscillations between spin qubits 250 µm apart – a huge distance (orders of magnitude larger than normal). They coupled two distant silicon spin qubits via a high-impedance superconducting resonator. By detuning the qubits from the resonator (dispersive regime), they realized an effective spin-spin coupling through “virtual photons” in the resonator. The result was a measurable oscillation of the two spins’ excitation exchange (one spin’s $$|↑〉$$ state swapping to the other and back), consistent with an iSWAP interaction. They reported that this could enable an entangling iSWAP gate in as fast as ~10 ns – comparable to local exchange speeds, which is remarkable given the qubit separation. This approach essentially creates an on-chip quantum bus for spins, allowing distant modules to swap states. Similarly, other groups have tried capacitive coupling between spin qubits a few micrometers apart and using intermediate quantum dots as relay qubits. These methods are still limited to relatively short distances (sub-micron to a few microns) unless a resonator is used.

In spin qubit platforms like silicon quantum dots, the SWAP (exchange) gate is naturally high-speed and potentially high-fidelity (since it’s an exchange oscillation). Indeed, native support for the SWAP family is rare in other platforms but has been shown in quantum-dot platforms. The key is controlling the exchange coupling precisely. A recent study in silicon spin qubits achieved 99% fidelities for two-qubit gates by optimizing flux and coupling in a tunable coupler device – which included “fSim-type” gates (a family that includes iSWAP and SWAP as special cases).

Another concept is the “swap network” for spins: by sequentially swapping, say, an electron through a network of dots, one can effectively permute the register. But the overhead in solid-state is similar to superconductors – each SWAP via exchange might be fast (ns scale) but many of them could accumulate errors and decay.

In summary, spin qubit routing involves either physical transport of the carrier (shuttling electrons) or using intermediate couplers (quantum dots or resonators) to perform swaps over a distance, or, simply doing nearest-neighbor swap chains. The community is actively researching the first two to avoid the third (which is slow). The 2025 Nature Physics result shows that modular coupling via resonators can connect spins across a chip, hinting at scalable networks of quantum dot modules. And ongoing work in shuttling aims to transfer electron spins across large arrays (some experiments have sent spins over 4 mm distances using SAW!), although maintaining coherence remains challenging.

Moving Qubits in Neutral-Atom and Photonic Systems

Neutral Atoms (Rydberg and Optical Lattice Qubits)

Neutral atom quantum processors trap atoms in optical tweezers or lattices. Typically, these systems have flexible geometry – one can arrange atoms in 1D, 2D, or even 3D arrays, and move the optical traps as needed. Many neutral-atom setups already use atom rearrangement to prepare defect-free arrays: extra atoms are moved around to fill vacancies before computation. This rearrangement can be done with moving optical tweezers, effectively swapping atoms’ positions to order them in a grid.

During computation, one could in principle also move atoms to bring certain qubits together for interaction (e.g. to bring two qubits into each other’s Rydberg interaction range). Unlike ions, atoms are not connected by a common mode, so moving them physically is a primary way to change connectivity if needed beyond nearest neighbors. Researchers have demonstrated extremely agile control: using holographic optical tweezers, atoms can be repositioned in parallel to form any pattern from a jumbled initial load, with sub-millisecond total operation time. Additionally, in 2023 a team showed a more dramatic form of movement – literally throwing and catching single atoms between traps. Ahn et al. used one optical tweezer to toss a laser-cooled atom a few micrometers, turning off the trap so the atom traveled ballistically, and then catching it in another trap a short distance away. This is the first demonstration of free-flying atoms being caught, with a reported 87% success rate that is improving. The motivation is to enable “flying qubits” within an array. Researchers demonstrated how flying atoms might someday enable dynamic quantum calculations. The technique might also prove useful in rearranging atoms within an array. In other words, rather than guiding an atom slowly, they “toss” it to quickly change its position or swap two atoms.

In neutral atom arrays, the need for swaps is somewhat mitigated by the fact that many platforms allow medium-range interactions (Rydberg states of atoms can interact over several micrometers, and with 2D arrangements one atom has many neighbors). Still, for atoms that are far apart in a large array, one might either move them or use intermediate atoms to hop an excitation. Because atoms of the same species are identical, one could conceive physically swapping two atoms’ positions – since they’re indistinguishable, this amounts to swapping their qubit states. This is analogous to the ion case, though technically trickier because neutral atoms aren’t held by charged electrodes but by laser traps. Nevertheless, as mentioned, optical conveyor belts and moving tweezers have achieved swapping and rearranging operations. For example, a “blinking optical tweezers” method allowed 50+ atom arrays to be dynamically reconfigured with high success.

Photonic Qubits

In photonic quantum computing (e.g. using single photons as qubits, either in dual-rail or time-bin encodings), moving qubits is essentially free – photons are always traveling at the speed of light through optical fiber or waveguides. The concept of a SWAP gate in photonics corresponds to swapping two optical modes. For instance, if two photons approach a junction and we want to swap their paths, one could use beam-splitter networks to achieve a permutation of modes. But since photons do not interact easily, a SWAP of two photonic qubits typically would be implemented by a linear optical network (which can route modes arbitrarily but without entangling them) or by using additional resources (like entangled ancilla and measurement). More commonly, rather than a logical SWAP gate, photonic circuits just physically reroute the paths via waveguide crossings or switches. Because photons can be delayed or moved in loops, one can change their order or destination on the fly, which is analogous to routing in a classical network. In integrated photonic quantum chips, thermo-optic or electro-optic switches can dynamically reroute photonic qubits, effectively swapping channels. The bottom line is that photonics doesn’t suffer from geometric constraints the same way solid-state qubits do – a photonic qubit is by nature a “flying qubit.” The challenge is instead synchronization: getting the right photons to interfere or interact (via measurement-induced gates) at the right time. That said, one could consider quantum teleportation as a primary method to swap states of photonic qubits as well (since interference and measurement can teleport states between photons).

Summary for Neutral Atoms and Photonics

Neutral atoms offer reconfigurable qubit layouts – they can literally rearrange qubit positions mid-computation, which is a form of “moving qubits around” that classical systems obviously cannot do with silicon chips. This flexibility can reduce the need for multi-hop SWAP gates: if two atoms need to interact, just move them closer. Demonstrations of high-fidelity atom transport and even free-space throwing indicate this approach is promising. Photonic qubits, on the other hand, are always moving; routing is achieved by optical elements (mirrors, beamsplitters, switches) rather than multi-qubit logic gates. In effect, one might not talk about SWAP gates in photonics at all – it’s simply wiring. The common thread in both is that physical motion (of atoms or photons) replaces logical SWAP gates, thus avoiding additional quantum gate error overhead (though introducing its own technical challenges in precise control).

Teleportation and Entanglement-Assisted Qubit Routing

No discussion of moving quantum information would be complete without mentioning quantum teleportation. Quantum teleportation is a protocol that transfers a quantum state from one qubit (sender) to another qubit (receiver) at a distance, without moving the physical carrier of the state. It uses a pre-shared entangled pair and classical communication of two bits. The sender (traditionally “Alice”) performs a joint Bell-state measurement on her qubit (the one with the state to be sent) and her half of the entangled pair. This measurement yields two classical bits, which are sent to the receiver (“Bob”). Depending on those bits, Bob applies one of four possible Pauli rotations to his half of the entangled pair, which then becomes the state that Alice’s qubit originally had. The original qubit’s state is destroyed in the process (due to measurement), but it reappears on Bob’s qubit – effectively the qubit state has been teleported.

Teleportation is a powerful concept because it sidesteps the direct interaction or motion between the source and destination qubits. As long as an entangled pair is available linking two locations, any state can be transferred with only local operations and classical communication. In the context of routing on a quantum processor, one could imagine using entanglement to “swap” qubits that are far apart, faster or with fewer operations than a chain of SWAP gates would require. Indeed, researchers have investigated entanglement-assisted routing protocols. A 2024 study by Devulapalli et al. showed that using teleportation can accelerate the implementation of permutations of qubits on certain graphs. In particular, they demonstrated cases where distributing entangled pairs across a network and then performing teleportation-based swaps yields a logarithmic speedup in worst-case routing time compared to only swap-gate-based routing. The intuition is that teleportation can cover “long distances” in one go, whereas SWAP gates have to crawl step by step. Their work also set theoretical bounds on how much teleportation can speed up routing – it can offer significant improvements, though it doesn’t trivialize the problem entirely.

In practice, to use teleportation on a quantum chip, one needs the capability to generate entangled pairs between distant qubits (which could be done via intermediate operations or a dedicated entanglement link) and the ability to perform fast feed-forward of the classical bits (to apply the correct Pauli frame). Some quantum processors have indeed demonstrated on-chip teleportation of qubit states. For example, IBM in 2015 teleported a qubit state between distant superconducting qubits on a chip using an entangled bus resonator; ion trap networks have teleported states between separate trap modules via photonic links; and photonic experiments routinely teleport states between photons across labs and even between satellites. These are often cited as stepping stones to distributed quantum computing. While teleportation is not yet a routine part of quantum circuit compilation (it requires extra qubits and entanglement generation), it’s a tantalizing approach for the future of qubit routing. Especially in modular quantum architectures – say you have multiple smaller processors connected by entanglement links – teleportation is the primary way to move quantum states from one module to another (since you can’t physically carry the qubit between cryostats, for example). Quantum repeaters and networked quantum computing rely on teleportation to relocate qubits over long distances.

To illustrate teleportation’s role in routing, imagine a line of superconducting qubits where qubit 1 and qubit 5 need to swap states. The usual way: apply SWAP gates between (1,2), (2,3), (3,4), (4,5) – four SWAPs (12 CNOTs), quite slow. A teleportation-based way: if one can prepare an entangled pair between qubit 1 and qubit 5 (e.g. via some chain of interactions that need not be coherent the whole way, or via a long-range coupler), then perform a Bell measurement on qubit 1 and an input qubit whose state we want to move to 5, and then apply the correction on 5. This could effectively transfer the state in one go, consuming the entanglement. The cost moved from many sequential CNOTs to one entangled pair preparation (which might be done in parallel or via a single multi-qubit operation) plus some single-qubit gates for the teleportation. If error rates are low enough or if error correction is used, teleportation can be significantly more efficient.

It’s worth noting that teleportation requires the two bits of classical communication to complete (which introduces a sub-nanosecond delay on a chip, negligible, but in long distance quantum networks it limits speed to speed-of-light). On a local processor, feed-forward latency is very small compared to gate times, so teleportation’s “latency” is not an issue.

In summary, quantum teleportation provides an alternative route for qubit routing that doesn’t depend on physically neighboring gates. It is already a proven method in experiments for transferring quantum states. As quantum processors evolve, we may see hybrid strategies: where possible, do direct SWAP or physical movement; where that is too slow or error-prone, consume an entangled pair to teleport the state. This hybrid approach could minimize the overall routing cost in a large quantum computer.

Outlook and Conclusion

Routing quantum information – moving qubit states around – remains a critical challenge on the road to large-scale quantum computers. We have reviewed the main strategies across various leading platforms:

• SWAP gates (and sequences of SWAPs) are the workhorse for repositioning qubit states on devices with limited connectivity (like superconducting and spin qubit chips). They are simple conceptually, but expensive in practice (each SWAP = 3 two-qubit gates in many architectures). Thus, reducing the number of SWAPs through smart compilers or hardware improvements is a major focus. For example, compilers use heuristic or optimal qubit routing algorithms to insert the minimal SWAPs needed, and there is active research in algorithms to do this optimally or even use heuristic like A* search or SAT solvers for routing problems.
• iSWAP and partial swaps often come “for free” from native interactions (like exchange couplings). Harnessing these can make moving states more efficient. We saw that a SWAP can be implemented by an iSWAP + phase correction, and experiments have confirmed faster SWAPs using this approach. In general, having a tunable interaction that can be turned into either a CZ or an iSWAP is extremely useful – it means the hardware can either entangle or swap as needed. Superconducting qubit designers are increasingly adopting tunable bus couplers to get this flexibility. Likewise, spin qubits inherently have tunable exchange which gives them native swap ability. We expect future devices to include gate sets where SWAP-like operations are as native as CNOT.
• Physical transport of qubits (moving ions, shuttling electrons, shifting atoms) is an elegant solution when it’s available. It leverages motional degrees of freedom to do what a SWAP gate would do logically. The upside is that one can, in principle, rearrange qubits without using multi-qubit gate operations – this can be faster and lower error if done right. The downside is that it requires a very advanced control infrastructure (for example, trapping zones, precise voltage sequences, or movable laser tweezers) and could introduce decoherence if the move is too slow or noisy. The progress in ion traps (with ~99.5% fidelity swapping by motion) and neutral atoms (dynamic tweezer rearrangements) suggests that “quantum conveyor belts” will be a key feature of some quantum computers. This is especially relevant in modular architectures, where qubits may need to be shuffled between different registers or memory zones.
• Long-range couplers and network links provide another physical solution: rather than moving the qubit, provide a channel (like a resonator or a photonic link) so that qubits can interact at a distance. The demonstration of two spin qubits swapping state over 250 μm via a superconducting resonator bus is a striking example – it essentially extends the connectivity of the chip without requiring intermediate SWAPs. In superconductors, proposals for cross-chip couplers or even microwave photon links between fridges are being explored. These approaches, if realized, mean a qubit doesn’t have to hop through many neighbors; it can either teleport or directly couple to a far qubit.
• Quantum teleportation and entanglement swapping will likely move from purely theoretical or niche demonstrations into the toolkit of quantum computing in the coming years. Teleportation has already been used in quantum communication networks and in basic experiments on chips. Its ability to break the locality barrier (with the help of entanglement) means it could dramatically reduce routing overhead in a large processor. The trade-off is that generating and managing entanglement resources is itself non-trivial and consumes qubits (acting as “communication qubits”). But as hardware grows, dedicating some qubits to be communication links (creating Bell pairs between regions of a chip) might be worthwhile to speed up computations.

Looking ahead, the optimal strategy for moving qubits might involve a combination of methods. For near neighbors, a direct SWAP (or iSWAP) through the coupler might be simplest. For mid-range, maybe one physically shuttles one of the qubits to the vicinity of the other (if possible). For long-range, perhaps teleportation or use of an intermediary bus will be best. Each modality of qubit has its strengths: superconductors switch fast gates but limited range; ions move freely but with slower cycle times; photonics connect arbitrarily but are measurement-heavy; spins are tiny and could be networked on-chip with resonators. A future modular quantum computer might have zones of high connectivity (clusters fully connected internally) linked by photonic or microwave teleportation channels – qubit states might “teleport” between modules rather than hop gate-by-gate. This is analogous to how classical supercomputers use both fast local interconnects and slower long-range links.

Conclusion

In conclusion, routing quantum information is one of the key technical challenges in scaling quantum computers, and it is stimulating a rich variety of solutions. From the fundamental SWAP gate taught in textbooks, to exotic ideas of flying atoms and teleportation, we see a spectrum of techniques to move qubit states. Each approach must respect quantum coherence and the no-cloning rule, making the problem non-trivial.

However, steady progress – like efficient SWAP gate compilations in superconductors, physical ion swaps with >99% fidelity, and long-distance resonator swaps for spins – suggests that this challenge is being met. As hardware advances, we expect qubit routing will become more efficient, combining innovative hardware design with clever use of quantum protocols.

The continued refinement of SWAP and iSWAP gates, and the integration of new methods like teleportation, will help ensure that no qubit is ever too far away to entangle with another – even in a processor with millions of qubits spread across myriad modules. In the end, solving the “traveling qubit problem” is integral to fulfilling the promise of quantum computing.