The Quantum Engineer›Noise: The Real Computer›Chapter 31

31. Quantum Channels

31.1Completely positive maps

Which transformations of density matrices are physically possible? The output must be a valid density matrix for every valid input — but positivity alone is not enough. There exist maps that map every density matrix to something valid, yet when applied to half of an entangled pair produce an impossible, negative state. Complete positivity closes the hole: the map must stay positive even after you tensor it with the identity on any ancillary system. The classic unphysical example is the transpose map — positive, but not completely positive, and equivalent to signaling through entanglement if it were allowed. Complete positivity is the mathematics of "implementable noise", and every hardware noise model must pass this test.

31.2Trace preservation

A channel must conserve probability: Tr(E(ρ)) = Tr(ρ) for every ρ — nothing silently discarded, no unmonitored postselection. In Kraus form this becomes one algebraic constraint, Σₖ Kₖ†Kₖ = I, which you should verify on each channel below. Relax it to Tr(E(ρ)) ≤ 1 and you get the broader class of operations with postselection — the mathematical form of "measure and keep only the good runs", which heralded schemes exploit (42.5). The organizational picture: every gate is the special case of a unitary channel ρ → UρU†, trivially completely positive and trace-preserving; noise is any other map in the same class.

31.3Kraus operators

The central formula of this chapter: E(ρ) = Σₖ Kₖ ρ Kₖ†, with Σₖ Kₖ†Kₖ = I. Read it as an error bank: branch k occurs with probability pₖ = Tr(KₖρKₖ†), leaving the conditional state KₖρKₖ†/pₖ. On d dimensions, d² operators always suffice — every completely positive trace-preserving map fits this form. The representation is not unique: different operator sets can define the identical channel, so the channel, not the operators, is the physical object; the operators are coordinates. Simulation is three lines: loop over the Kraus operators, conjugate, sum. The experiments in this chapter are exactly that loop, instantiated for each standard noise process.

31.4Depolarizing channels

With probability p, replace the state by the maximally mixed state I/2; with probability 1 − p, leave it untouched. Kraus operators: K₀ = √(1 − 3p/4)·I and K₁, K₂, K₃ = √(p/4)·X, √(p/4)·Y, √(p/4)·Z. On the Bloch picture the effect is r → (1 − p)·r: uniform shrink toward the center, all directions equally. This is the "generic noise" default of every simulator — one parameter, symmetric, information-destroying in every basis — and the honest caveat is that real devices are not symmetric. The experiment below builds the channel two ways, by mixing density matrices and by Kraus operators, and confirms they agree exactly.

On your laptop — depolarizing channel, two ways

Build the depolarizing channel by mixing density matrices and by applying Kraus operators; the results must match. Mixing is the definition, Kraus is the simulation workhorse.

import numpy as np

I = np.eye(2, dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Y = np.array([[0, -1j], [1j, 0]])
Z = np.array([[1, 0], [0, -1]], dtype=complex)

rho = np.array([[0.5, 0.5], [0.5, 0.5]])   # |+><+|
p = 0.3

# way 1: with probability p, replace rho by the maximally mixed state
rho_mix = (1 - p) * rho + p * I / 2

# way 2: Kraus operators K0 = sqrt(1-3p/4) I, K1..3 = sqrt(p/4) X, Y, Z
K = [np.sqrt(1 - 3*p/4) * I,
     np.sqrt(p/4) * X, np.sqrt(p/4) * Y, np.sqrt(p/4) * Z]
rho_kraus = sum(Ki @ rho @ Ki.conj().T for Ki in K)

print("mixing:", np.round(rho_mix.ravel().real, 10))
print("kraus: ", np.round(rho_kraus.ravel().real, 10))
print("match:", np.allclose(rho_mix, rho_kraus))

Then verify the Bloch claim of 31.4: apply both to |0⟩ and check the vector shrinks by the factor 1 − p.

31.5Bit-flip channels

With probability p apply X; otherwise identity. Kraus operators: K₀ = √(1 − p)·I and K₁ = √p·X; the channel is ρ → (1 − p)ρ + p·XρX. On the Bloch sphere: the x component is untouched, while y and z are scaled by (1 − 2p) — the sphere pinches toward the x-axis. This is the closest quantum analogue of classical bit corruption, and it is the channel the three-qubit bit-flip code of Part X was designed to correct. Reality check: hardware does not produce pure bit flips — real noise is closer to depolarizing plus amplitude damping — which is exactly why the clean code analyses of Part X need the general channel theory you are building here.

31.6Phase-flip channels

With probability p apply Z: ρ → (1 − p)ρ + p·ZρZ, with Kraus operators K₀ = √(1 − p)·I and K₁ = √p·Z. Bloch picture: z untouched, x and y scaled by (1 − 2p). Two identities make this channel important. First, it is the bit-flip channel in a rotated basis: since H·X·H = Z, conjugating the states and operators by Hadamards converts one into the other — which is why the three-qubit phase-flip code in Part X is just the bit-flip code wearing H gates. Second, its continuous-time limit is pure dephasing (29.3): many small random phase kicks rather than rare discrete flips, governed by Tφ.

31.7Amplitude damping

The channel of T1 (29.2), written in the {|0⟩, |1⟩} basis as K₀ with diagonal (1, √(1 − γ)) and K₁ = γ-excitation-lowering: K₁ takes the amplitude of |1⟩ and moves it to |0⟩, with γ = 1 − exp(−t/T1) the decay probability over time t. It maps |1⟩ → |0⟩ with probability γ — irreversible, and therefore non-unital: E(I) ≠ I, the identity is not a fixed point because the channel cools the qubit toward |0⟩. Bloch arithmetic: z → (1 − γ)z − γ and x, y → √(1 − γ)·(x, y). On superconducting hardware this is the dominant irreducible channel; the experiment applies it and recovers the exponential T1 curve.

On your laptop — T1 decay with amplitude damping

Start a qubit in |1⟩ and apply the amplitude-damping channel for growing times with T1 = 100 µs. The excited population should follow the exponential 1 − exp(−t/T1).

import numpy as np

def amplitude_damping(rho, gamma):
    K0 = np.array([[1, 0], [0, np.sqrt(1 - gamma)]], dtype=complex)
    K1 = np.array([[0, np.sqrt(gamma)], [0, 0]], dtype=complex)
    return K0 @ rho @ K0.conj().T + K1 @ rho @ K1.conj().T

ket1 = np.array([0, 1], dtype=complex)
rho = np.outer(ket1, ket1.conj())          # start in |1>

for t_us in (0, 50, 100, 200, 400):
    gamma = 1 - np.exp(-t_us / 100)        # T1 = 100 µs
    d = amplitude_damping(rho, gamma)
    print(f"t = {t_us:3d} µs   P(|0>) = {d[0,0].real:.3f}   P(|1>) = {d[1,1].real:.3f}")

At t = T1 = 100 µs you should see P(|0>) ≈ 0.632. Then feed it |+⟩ and confirm that both populations move while coherence shrinks by √(1 − γ).

31.8Phase damping

Energy-preserving loss of coherence: populations untouched, off-diagonal entries multiplied by a decay factor. A Kraus pair: K₀ = diag(1, √(1 − λ)) and K₁ = diag(0, √λ); over time t the off-diagonals carry the factor exp(−t/T2). Distinguish it carefully from the phase-flip channel (31.6): phase flips are rare discrete events; phase damping is a continuous random walk of the qubit's phase — the physical picture of a transition frequency wobbling under low-frequency noise. Compose amplitude damping (31.7) with phase damping and you have both independent decay clocks of hardware, T1 and T2: the complete minimal one-qubit noise model that Chapter 29's numbers describe.

31.9Channel composition

Build large noise models from small pieces. Sequential composition E₂∘E₁ (apply E₁, then E₂) has as its Kraus set all products of a second-channel operator applied after a first-channel operator. Parallel composition on disjoint qubits tensor-products the operator sets. A full circuit's noise model is exactly this: after every gate, insert that gate's channel, all composed in circuit order. In continuous time the family of channels forms a semigroup E(t) = exp(tL), whose generator L is the Lindbladian — the equation behind physical-device simulators. And note what composition preserves: the state stays a density matrix, so noise remains representable at every step — something state-vector simulation structurally cannot deliver.