Coupling Qubits Together

Why coupling has to be switchable

A single qubit, no matter how good, can only do single-qubit operations. To run a real algorithm you need two-qubit gates — moments when two qubits exchange information. For that, the qubits must be *coupled*: a path must exist for energy or phase to flow from one to the other.

Here is the catch. You want that coupling to be strong for the few tens of nanoseconds the gate takes, and then gone afterward. A coupling that is always on keeps nudging the two qubits even when you are trying to leave them alone, slowly corrupting the program. So the design goal is not 'couple the qubits' — it is 'couple them *only when asked*.'

The most common way to get this on/off behaviour on superconducting chips is a tunable coupler: a small extra circuit sitting between two qubits whose own frequency you can shift with a control signal. Move it one way and the two qubits talk; move it another way and their interaction cancels out to nearly zero.

Two qubits and a coupler, drawn out

The standard layout is three circuits in a row: qubit, coupler, qubit. The two qubits are not wired straight to each other. Instead, each one couples to the middle element, and the middle element's frequency sets how much they end up feeling each other.

      g1                 g2
  Q1 -----[  COUPLER  ]----- Q2
 (qubit)   (tunable      (qubit)
            frequency)
            |
            | flux/control line
            v
  set coupler freq  ->  effective Q1<->Q2 coupling J_eff

  J_eff(on)  : large   -> two-qubit gate runs
  J_eff(off) : ~0      -> qubits left alone

  g1, g2  = fixed couplings from each qubit to the coupler
  J_eff   = net coupling the two qubits actually feel

The reason a middle element can switch the coupling off is interference. The qubits actually couple along two paths at once: directly (a weak fixed leak between them) and indirectly (through the coupler). When you tune the coupler's frequency to the right spot, those two paths cancel. The net coupling J_eff — the only thing the qubits truly feel — passes through zero.

The enemies: always-on ZZ and crosstalk

Even with the coupler nominally 'off', a residual interaction usually survives. The most troublesome flavour is called ZZ coupling: the frequency of one qubit shifts slightly depending on whether its neighbour is a 0 or a 1. It is small, but it never sleeps — every idle qubit slowly accumulates an unwanted, neighbour-dependent phase, and that shows up as gate error.

  idle ZZ error, intuitively:

     phase picked up  ~  (residual ZZ rate) x (idle time)

     residual ZZ rate : how much a qubit's frequency
                        shifts per the state of its neighbour
                        (units: cycles per second)
     idle time        : how long the qubit waits between gates

  smaller residual ZZ  -> less junk phase per microsecond
  a tunable coupler is tuned to push residual ZZ toward 0

The second enemy is signal crosstalk: a control pulse aimed at one qubit also reaches its neighbours. On a crowded chip the wiring and the qubits themselves are physically close, so a microwave drive 'leaks' sideways. The qubit you meant to address moves correctly; the ones you meant to leave alone get a small, unintended kick.

Connectivity: who can talk to whom

Couplers are expensive in chip area, wiring, and added crosstalk, so a chip does not connect every qubit to every other qubit. Instead each qubit is wired to just a few neighbours. The map of which qubits share a coupler is the chip's connectivity, and it is fixed in the silicon the day the chip is fabricated.

One popular layout is the heavy-hexagon lattice: each qubit touches only two or three neighbours, on purpose. Sparser connections mean fewer couplers crowding each qubit, which keeps ZZ and crosstalk down — but it also means most pairs of qubits are *not* directly connected.

When an algorithm needs two qubits to interact but they are not neighbours, the compiler inserts SWAP operations: it shuffles a qubit's state hop by hop across the chip until it sits next to its partner. Each SWAP is itself made of two-qubit gates, so it costs time and adds error. Limited connectivity does not make a program impossible — it makes it longer.

1. The compiler reads which two qubits a gate needs and checks the chip's connectivity map.
2. If they are already neighbours, it runs the two-qubit gate directly.
3. If not, it inserts SWAPs to walk one state across the lattice toward the other — each hop costing extra gates and time.
4. After the gate, it may SWAP the qubits back, or leave them moved and re-plan from there.