Physical Qubit Implementations

A physical qubit is any two-level (or effectively two-level) quantum system that can be initialized, coherently manipulated, coupled to at least one neighbor, and measured with tolerable error. The three dominant platforms differ in what the two levels are and how they are controlled. In superconducting circuits, the qubit is the two lowest energy levels of a nonlinear LC oscillator called a transmon, built from a capacitor shunting a Josephson junction; control is via microwave pulses routed on-chip. In trapped-ion systems, the qubit is a pair of long-lived internal states of an ion (a hyperfine or optical transition) held in a vacuum by electromagnetic fields; control is via laser pulses. In photonic systems, the qubit is typically encoded in a photon's polarization, path, or time-bin degree of freedom; control is via linear optics (beamsplitters, phase shifters) plus measurement-induced nonlinearity. Four metrics let us compare platforms on equal footing. Coherence time ($T_1$ for energy relaxation, $T_2$ for dephasing) measures how long quantum information survives before environmental noise randomizes it — the subject of Decoherence and Quantum Noise. Connectivity describes which pairs of qubits can be entangled directly with a native two-qubit gate; a 2D nearest-neighbor grid (superconducting) is very different from all-to-all coupling (trapped ions in a shared trap). Gate speed is the duration of a single- or two-qubit operation; faster gates mean more operations fit inside a fixed coherence window. Scalability captures how the engineering difficulty (wiring, control lines, calibration, cross-talk) grows as qubit count increases — often the true bottleneck, distinct from any single qubit's intrinsic quality. The single most useful composite quantity is the coherence-to-gate-time ratio, sometimes reported as the number of gate operations achievable within $T_2$. This ratio, not $T_2$ alone, predicts how many logical operations a device can support before noise accumulates past the error-correction threshold used in the surface code. A platform with long coherence but very slow gates can have a worse effective budget than a platform with short coherence but very fast gates.

Superconducting qubits (transmons)

A transmon is a small superconducting island connected to ground through a Josephson junction (a thin insulating barrier between two superconductors) and shunted by a large capacitor. The junction provides nonlinear inductance, which makes the energy levels of the resulting oscillator unevenly spaced — this anharmonicity is what lets microwave pulses address only the lowest two levels $|0\rangle, |1\rangle$ without leaking into $|2\rangle$. Single-qubit gates are implemented by applying resonant microwave pulses through capacitively coupled control lines; a pulse of the right amplitude, phase, and duration rotates the qubit state on the Bloch sphere. Two-qubit gates (e.g., the cross-resonance gate or tunable coupler schemes) entangle physically adjacent qubits by briefly bringing their transition frequencies into resonance or driving one qubit at the frequency of its neighbor. Readout uses a dispersively coupled resonator: the qubit's state shifts the resonator's frequency, and a probe microwave tone reflects with a state-dependent phase. Qubits are fabricated lithographically on a chip and cooled to about 10–20 millikelvin in a dilution refrigerator to suppress thermal excitation and to keep the superconductor superconducting. Because control wiring is physical (coaxial lines into the fridge), connectivity is limited to a planar, typically nearest-neighbor grid — matching well to the 2D layout the surface code assumes.

Trapped ions

An ion (commonly Yb⁺, Ca⁺, Ba⁺) is confined by a combination of static and oscillating electric fields in a linear Paul trap, forming a chain of ions that mutually repel via Coulomb interaction and share collective vibrational (phonon) modes. The qubit is encoded in two internal electronic states, chosen either as hyperfine ground-state sublevels (long-lived, insensitive to magnetic field with the right choice) or as a ground and metastable excited state. Single-qubit gates are driven by laser pulses (or microwaves, for hyperfine qubits) tuned to the qubit transition, rotating the Bloch vector via stimulated Raman transitions. Two-qubit gates exploit the shared phonon modes: a laser pulse conditionally displaces the ions' collective motion in a way that imparts a state-dependent phase, disentangling the motion at the end (the Mølmer–Sørensen gate is the standard scheme). Because every ion in the chain shares the same motional modes, any pair of ions can in principle be entangled directly — giving all-to-all connectivity within a trap, a qualitatively different topology from superconducting grids. Readout uses state-dependent fluorescence: shining a laser resonant with a cycling transition causes ions in one state to scatter many photons (detected on a camera or photomultiplier) while the other state stays dark.

Photonic qubits

A photonic qubit encodes a bit in a photon's polarization ($|H\rangle, |V\rangle$), spatial path, or arrival time-bin. Single-qubit gates are trivial and essentially lossless: waveplates or integrated phase shifters and beamsplitters implement arbitrary single-qubit rotations with very high fidelity, because linear optical elements do not directly decohere the encoded state. The hard part is two-qubit gates. Photons do not naturally interact with each other, so entangling operations must be engineered either through measurement-induced nonlinearity (the Knill–Laflamme–Milburn scheme routes two photons through beamsplitters and post-selects on detector outcomes, succeeding only probabilistically) or through a matter-mediated interaction (coupling photons to a physical qubit such as an atom or a superconducting cavity, e.g., in cluster-state or measurement-based schemes). This intrinsic probabilism is the platform's defining structural feature and drives its entire architecture toward measurement-based computation with heavy multiplexing and error-corrected fusion of small entangled resource states. Because photons travel at the speed of light and barely interact with their environment, coherence loss is not the dominant error source; instead, photon loss (absorption, scattering, coupling inefficiency) is the primary enemy, and it grows with circuit depth and distance traveled.

Comparative pseudocode: a single logical operation across platforms

The following pseudocode captures the common abstraction — apply a native two-qubit entangling gate — while making explicit where each platform's physics enters. ``` function ENTANGLE(platform, qubit_i, qubit_j): if platform == SUPERCONDUCTING: require ADJACENT(qubit_i, qubit_j) # planar connectivity constraint tune_frequency(qubit_i, target = qubit_j.frequency) apply_microwave_pulse(duration ≈ 20-40 ns) return CZ_or_CNOT gate, fidelity ≈ 0.995-0.999 if platform == TRAPPED_ION:

# no adjacency requirement: shared phonon bus select_motional_mode(chain) apply_bichromatic_laser_pulse(qubit_i, qubit_j, duration ≈ 1-100 μs) return Mølmer-Sørensen gate, fidelity ≈ 0.99-0.999 if platform == PHOTONIC: route_photons_through_linear_optics(qubit_i, qubit_j) measure_ancilla_photons() if measurement_outcome == SUCCESS: # probabilistic! return fused entangled pair, fidelity ≈ 0.97-0.99 else: return FAILURE # must retry or use fresh resource state ``` The `if measurement_outcome == FAILURE` branch is not a corner case for photonics — it is the normal operating regime, and real photonic architectures are built around amortizing this failure probability across many parallel attempts (multiplexing) rather than eliminating it.

There is no single "complexity" for a physical platform the way there is for an algorithm, but the relevant analog is the resource overhead required to reach a target logical error rate, and this is where platform physics becomes a quantitative, derivable quantity.

Gate count budget. If a qubit has dephasing time $T_2$ and a two-qubit gate takes time $\tau_{2q}$, the number of two-qubit gates executable before decoherence dominates scales as

Superconducting: $T_2 \approx 100\,\mu s$, $\tau_{2q} \approx 30\,ns \Rightarrow N_{\text{gates}} \sim 3000$. Trapped ion: $T_2 \approx 1\,s$, $\tau_{2q} \approx 50\,\mu s \Rightarrow N_{\text{gates}} \sim 20{,}000$. Photonic: coherence is not the limiting quantity; loss probability per component plays the analogous role, so the relevant ratio is total transmittance across the circuit depth, $\eta^{d}$ for per-component transmittance $\eta$ and depth $d$. This ratio is the correct comparison metric — not $T_2$ alone — because it already accounts for the fact that a slower platform "wastes" more of its coherence budget per operation.

Threshold theorem connection. The surface code's threshold theorem states that if the physical two-qubit gate error rate $p$ is below a threshold $p_{th} \approx 10^{-2}$ (numerically), then increasing code distance $d$ suppresses the logical error rate roughly as

for constant $A$. Correctness of this comparison hinges on the fact that gate error rate $p$, not gate speed or coherence time individually, is the fundamental quantity entering the threshold theorem. A platform can have short coherence and still be viable if gates are fast and clean enough that $p$ stays under threshold — which is precisely the superconducting bet. A platform can have gates well above threshold error even with long coherence, if crosstalk or control-line imperfections dominate — a real risk for large trapped-ion chains.

Connectivity and code overhead. The surface code is defined on a 2D nearest-neighbor lattice, matching superconducting connectivity almost natively — an architectural correctness argument: physical layout and code layout coincide, so no extra "routing" gates (SWAPs) are needed to bring distant qubits together for stabilizer measurements. Trapped ions have better raw connectivity (all-to-all) but this is a double-edged sword: sufficiently large ion chains suffer from crosstalk and slower gates as chain length grows (motional mode density increases), which is why large trapped-ion systems increasingly use modular architectures — small chains linked by photonic interconnects — rather than one giant chain. Photonic systems have essentially reconfigurable connectivity determined by the optical network, but the probabilistic nature of entangling gates means the effective connectivity depends on a success probability that must be multiplied into all resource estimates.

Honesty about trade-offs. No platform is dominant:

• Superconducting wins on gate speed and code-matching connectivity, loses on coherence and fabrication-variability-driven calibration overhead.
• Trapped ions win on coherence and connectivity, lose on gate speed and chain-scaling engineering (laser addressing precision, vacuum system complexity).
• Photonics wins on decoherence immunity and room-temperature operation, loses on deterministic two-qubit gates, forcing large redundancy (many attempts, many ancilla photons) to succeed with high probability.

Consider designing a device meant to sustain a single surface-code logical qubit at distance $d = 15$ — a middling but realistic target — for long enough to run $10^6$ physical gate cycles (a modest sequence for a small algorithm run). We compare superconducting and trapped-ion platforms on whether their coherence-to-gate ratio comfortably exceeds the code cycle count, and check the physical two-qubit gate error against the surface code threshold.

Step 1 — surface code cycle count. Distance $d=15$ requires physical error rate roughly a factor of $10$ below threshold to reach useful logical error suppression over many cycles (a standard rule of thumb, not a universal law). With $p_{th} \approx 1\%$, we need $p \lesssim 0.1\%$ per physical two-qubit gate.

Step 2 — check reported gate fidelities.

Step 3 — compute available gate budget from coherence. For superconducting, $T_2 \approx 100\,\mu s$, gate time $30\,ns$:

A single surface-code syndrome-extraction cycle uses roughly $O(d^2)$ physical two-qubit gates (each of the $d^2$ data qubits participates in a constant number of stabilizer checks per round), so for $d = 15$, one round costs on the order of a few hundred two-qubit gates. Sustaining $10^6$ rounds is therefore not limited by single-shot coherence — coherence is refreshed every round via active error correction — but by whether the per-gate error rate stays under threshold across all $10^6 \times O(d^2)$ gates, which is a fidelity question, not a raw coherence-time question.

Step 4 — the real bottleneck. This is the crucial correctness point: error correction is designed precisely so that coherence time does not need to exceed algorithm runtime — decoherence is corrected round by round, provided the per-gate error rate is under threshold. So the deciding factor is column 2 of the table above (gate fidelity), not $T_2$ directly. Superconducting devices, despite their short $T_2$, remain viable candidates for the surface code specifically because their gates are fast enough that many error-correction rounds fit inside $T_2$, keeping the effective per-round error controlled. Photonic architectures instead pursue a structurally different code (e.g., fusion-based or bosonic codes) precisely because the two-qubit gate error is currently too high for the standard surface-code threshold with realistic loss rates.

Step 5 — connectivity check. At $d=15$, the surface code needs a $15\times15$ (or similar) grid of data and ancilla qubits with only nearest-neighbor two-qubit gates — around $2\times15^2 \approx 450$ physical qubits. Superconducting chips map this directly onto silicon layout. A trapped-ion implementation of the same code would either need a single chain of $450$ ions (currently far beyond demonstrated chain lengths with acceptable gate fidelity) or a modular network of smaller chains connected by photonic links, introducing additional loss and latency at every module boundary — illustrating that all-to-all connectivity within a module does not eliminate the scaling problem, it relocates it to the interconnect.

The physical qubit landscape emerged from decades of separate advances in atomic physics, superconducting electronics, and quantum optics, later unified by the shared goal of scalable quantum computation.

Superconducting platforms underlie the processors built by Google, IBM, and Rigetti, and are the leading candidates for near-term surface-code demonstrations precisely because their planar layout matches the code's native geometry. Trapped-ion systems, commercialized by IonQ and Quantinuum, are used where high gate fidelity and flexible connectivity matter more than raw qubit count — useful for algorithms requiring dense, long-range entanglement without deep routing overhead. Photonic platforms, pursued by PsiQuantum and Xanadu, target architectures built around fault-tolerant measurement-based computation and offer a path to room-temperature, fiber-networked quantum computers, leveraging the same optical infrastructure used in classical telecommunications. Beyond these three, neutral-atom arrays (assembled with optical tweezers) and topological qubit proposals borrow ideas from all three paradigms, and hybrid systems increasingly couple superconducting circuits to photonic links for long-distance entanglement distribution. Every one of these engineering choices feeds directly into compiler design: gate scheduling, qubit routing, and error-correction code selection are all downstream of the physical connectivity graph and native gate set discussed here — the concrete hardware backdrop against which The NISQ Era algorithms and near-term error mitigation strategies are designed.

Ask the tutor: How would the resource estimate change if we targeted a fusion-based photonic code instead of the standard surface code?