Quantum Decoherence and Noise: What Every Circuit Developer Should Know

When you simulate a Bell state in a browser, you get exactly 50% |00⟩ and 50% |11⟩. When you run the same circuit on IBM's best hardware today, you might get 48% |00⟩, 49% |11⟩, 2% |01⟩, and 1% |10⟩. Those 3% wrong answers are not random bugs. They are decoherence and gate noise, and understanding them is the difference between circuits that work in simulation and circuits that work on real hardware.

What Decoherence Is

A qubit stores information in a fragile quantum state. Decoherence is the process by which that state leaks into the surrounding environment, causing quantum information to degrade into classical noise.

Every physical qubit interacts weakly with its environment: surrounding silicon, phonons, stray electromagnetic fields, measurement cables. These interactions entangle the qubit with the environment. Once a qubit is entangled with a large, complex environment, the quantum information becomes effectively unrecoverable. The qubit behaves like a classical mixed state rather than a quantum superposition.

This is not a solvable engineering problem in the short term. It is a fundamental consequence of quantum mechanics applied to open systems. The engineering challenge is to slow decoherence down enough that useful computation finishes first.

T1: Energy Relaxation Time

T1 is the time constant describing how long a qubit stays in the excited state |1⟩ before spontaneously decaying to |0⟩. It is analogous to the RC time constant in classical circuits.

If you prepare a qubit in state |1⟩ and wait a time t, the probability of measuring |1⟩ decays as:

P(|1⟩, t) = e^(-t/T1)

On IBM Quantum hardware as of 2026, T1 values range from roughly 50 microseconds to 500 microseconds depending on the qubit and device. On IBM's Heron-architecture devices, typical T1 exceeds 200 microseconds.

What this means for circuits: every qubit spends time idle between gates. If your circuit has 100 gates and each gate takes 100 nanoseconds, the total circuit duration is about 10 microseconds. A qubit with T1 = 100 microseconds has roughly a 10% chance of spontaneous decay during execution. That directly contributes to wrong measurement results.

T2: Dephasing Time

T2 describes how long a qubit maintains phase coherence in a superposition state. While T1 describes energy decay, T2 describes the loss of the relative phase between |0⟩ and |1⟩ in a superposition.

For a qubit in state (|0⟩ + |1⟩)/√2, the phase evolves at a frequency proportional to the qubit's energy. Environmental noise causes small random fluctuations in this energy, causing the phase to drift randomly over time. After time T2, the phase information is lost.

T2 is always less than or equal to 2*T1 (this is the Bloch-Redfield constraint). On current hardware, T2 often falls below T1 due to additional dephasing noise sources. Typical T2 values on IBM hardware range from 50 to 300 microseconds.

The practical implication: circuits that rely on phase relationships (which is most circuits, since interference is the mechanism of quantum computation) degrade as circuit depth increases. A deep circuit accumulates more phase error than a shallow one.

Gate Errors

Every quantum gate is implemented by a physical pulse. On superconducting hardware (IBM, Google), gates are microwave pulses. On trapped-ion hardware (IonQ, Quantinuum), gates are laser pulses. These pulses are imperfect, and each gate introduces a small error.

Gate errors are expressed as average gate infidelity. A single-qubit gate with 99.9% fidelity introduces 0.1% error per gate. A two-qubit gate (like CNOT) with 99.5% fidelity introduces 0.5% error.

For a circuit with 10 CNOTs and 99.5% CNOT fidelity, the approximate total fidelity is:

0.995^10 ≈ 0.951

That is about a 5% error from gate noise alone, before accounting for decoherence. For 50 CNOTs the fidelity drops to about 78%.

You can query gate fidelities from IBM Quantum in Qiskit:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")

props = backend.properties()
for i, qubit in enumerate(props.qubits):
    t1 = [p.value for p in qubit if p.name == 'T1']
    t2 = [p.value for p in qubit if p.name == 'T2']
    if t1 and t2:
        print(f"Qubit {i}: T1={t1[0]*1e6:.0f}us, T2={t2[0]*1e6:.0f}us")

for gate in props.gates:
    if gate.gate == 'cx':
        print(f"CNOT {gate.qubits}: error={gate.parameters[0].value:.4f}")

Readout Errors

When you measure a qubit, the measurement process itself is imperfect. A qubit in state |1⟩ might be read as |0⟩ with some probability, and vice versa. This is readout error, separate from gate errors.

Readout errors on current IBM hardware are typically 1 to 3%. On better-calibrated qubits they can drop below 0.5%. They are asymmetric: flipping from |1⟩ to |0⟩ (the relaxation direction) is usually more likely than flipping from |0⟩ to |1⟩.

You can measure the confusion matrix yourself:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

shots = 1024

# Calibration circuit for |0⟩
cal0 = QuantumCircuit(1, 1)
cal0.measure(0, 0)

# Calibration circuit for |1⟩
cal1 = QuantumCircuit(1, 1)
cal1.x(0)
cal1.measure(0, 0)

sim = AerSimulator()
counts0 = sim.run(cal0, shots=shots).result().get_counts()
counts1 = sim.run(cal1, shots=shots).result().get_counts()

p00 = counts0.get('0', 0) / shots  # P(measure 0 | prepared 0)
p10 = counts0.get('1', 0) / shots  # P(measure 1 | prepared 0)
p01 = counts1.get('0', 0) / shots  # P(measure 0 | prepared 1)
p11 = counts1.get('1', 0) / shots  # P(measure 1 | prepared 1)

print(f"Confusion matrix:")
print(f"  P(0|0)={p00:.3f}, P(1|0)={p10:.3f}")
print(f"  P(0|1)={p01:.3f}, P(1|1)={p11:.3f}")

Qiskit Runtime's EstimatorV2 applies readout error mitigation automatically on supported backends when you set resilience_level = 1.

How Noise Shows Up in Circuit Results

For the Bell state circuit (H then CNOT on 2 qubits), ideal simulation gives:

{'00': 512, '11': 512}

On real hardware with a noisy backend, you might see:

{'00': 489, '11': 503, '01': 18, '10': 14}

The |01⟩ and |10⟩ counts (about 3% of shots) come from a combination of gate errors during the CNOT, readout errors during measurement, and T1 decay if a qubit relaxed mid-circuit.

The rough symmetry between |01⟩ and |10⟩ errors is normal for a well-calibrated Bell circuit. Strongly asymmetric errors (many |01⟩ but few |10⟩) typically indicate T1 decay rather than gate error, because T1 decay collapses |1⟩ to |0⟩ preferentially.

Practical Strategies for Reducing Noise Impact

Choose qubits carefully. Not all qubits on a device are equal. Always query current calibration data and select qubits with the best T1, T2, and gate fidelity for your circuit's critical paths. IBM Quantum's dashboard shows per-qubit calibration data updated hourly.

Reduce circuit depth. Every layer of gates adds noise. Transpile to the device's native gate set and optimize for depth. Qiskit's transpiler optimization levels 2 and 3 do this automatically:

from qiskit import transpile

transpiled = transpile(qc, backend=backend, optimization_level=3)
print(f"Original depth: {qc.depth()}")
print(f"Transpiled depth: {transpiled.depth()}")

Minimize two-qubit gates. CNOT fidelity is typically 10 times worse than single-qubit gate fidelity. Rewrite circuits to reduce CNOT count wherever possible.

Apply error mitigation. Zero-Noise Extrapolation (ZNE) is available in Qiskit Runtime and runs circuits at artificially increased noise levels, then extrapolates back to zero noise:

from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime import EstimatorOptions

options = EstimatorOptions()
options.resilience_level = 1  # Enables ZNE

estimator = Estimator(session=session, options=options)

Run more shots. Statistical noise decreases as 1/√(shots). Running 8192 shots instead of 1024 halves the measurement sampling uncertainty. This does not reduce systematic gate errors, but it tightens your estimate of the true probability distribution.

What This Means for the Registry

Every circuit in the quantumcomputer.dev registry is stored as OpenQASM and can be simulated in the browser with zero noise. The browser simulation shows you what the circuit should do on ideal hardware.

When you run the same circuit on real hardware, you will see noise. The gap between simulation and hardware results is a direct read on your circuit's noise sensitivity. A well-designed circuit produces results close to simulation even on noisy hardware. A fragile circuit (many CNOT gates, long depth, long coherence requirement) will diverge significantly.

Use the playground to build and verify circuit logic in simulation, then use the "Open in IBM Quantum" button to submit to real hardware. Paste the hardware results into the Experiment Dashboard to compare against your simulation baseline.

Key Numbers to Know

These numbers are device-specific and improve over time. Always check the current calibration data for your target device before designing circuits that depend on specific fidelity budgets.