Quantum Channels and Kraus Operators: The Language of Quantum Noise

Unitary gates describe ideal quantum operations. Real quantum hardware also involves noise, measurement, and decoherence — operations that cannot be described by unitary matrices. The correct framework is quantum channels: linear maps on density matrices that preserve the physical requirements of a quantum state.

What a quantum channel must satisfy

A density matrix ρ must always be:

Hermitian: ρ = ρ†
Positive semidefinite: ⟨ψ|ρ|ψ⟩ ≥ 0 for all |ψ⟩
Unit trace: Tr(ρ) = 1 (probabilities sum to 1)

A quantum channel ε must map density matrices to density matrices. The precise requirements are:

Linearity: ε(αρ₁ + βρ₂) = αε(ρ₁) + βε(ρ₂)
Trace-preserving (TP): Tr(ε(ρ)) = 1 for all ρ
Completely positive (CP): ε ⊗ I maps positive operators to positive operators, where I acts on any ancilla system

Complete positivity is stronger than ordinary positivity and is required because the channel might act on half of an entangled state. A map that is positive but not completely positive (like the transpose map) would produce invalid states when applied to a subsystem.

A map satisfying all three conditions is called a CPTP map (Completely Positive Trace-Preserving).

The Kraus representation

Every CPTP map can be written as:

ε(ρ) = Σₖ Kₖ ρ Kₖ†

where the operators Kₖ (Kraus operators) satisfy the completeness relation:

Σₖ Kₖ† Kₖ = I

This completeness condition is equivalent to trace preservation. The number of Kraus operators is at most d² where d is the Hilbert space dimension (d=2 for a single qubit, so at most 4 Kraus operators).

The Kraus representation is not unique — you can apply any unitary matrix to the set of Kraus operators and get an equivalent channel.

Unitary gates as Kraus channels: A unitary U is a special case with a single Kraus operator K₁ = U. The completeness condition K₁†K₁ = U†U = I is satisfied. This shows that unitary evolution is a special case of the general framework.

Common noise channels in Kraus form

Bit flip channel

Applies X with probability p, does nothing with probability 1−p:

K₀ = √(1−p) I    K₁ = √p X

Verify: K₀†K₀ + K₁†K₁ = (1−p)I + pI = I ✓

Effect on density matrix:

ε(ρ) = (1−p)ρ + p XρX

On the Bloch sphere: shrinks the x-component (flips the bit with probability p, averaging reduces the x polarisation). Does not affect the z-component for a z-diagonal state.

Phase flip (dephasing) channel

Applies Z with probability p:

K₀ = √(1−p) I    K₁ = √p Z

Effect:

ε(ρ) = (1−p)ρ + p ZρZ
       = ρ₀₀|0⟩⟨0| + ρ₁₁|1⟩⟨1| + (1−2p)(ρ₀₁|0⟩⟨1| + ρ₁₀|1⟩⟨0|)

The off-diagonal coherences decay by factor (1−2p). At p=1/2, they vanish completely. This models T2 dephasing.

Depolarising channel

Applies each Pauli (X, Y, Z) with probability p/3 and does nothing with probability 1−p:

K₀ = √(1−p) I    K₁ = √(p/3) X    K₂ = √(p/3) Y    K₃ = √(p/3) Z

Effect: Shrinks the Bloch vector by factor (1 − 4p/3):

ε(ρ) = (1 − 4p/3)ρ + (4p/3)(I/2)

At p = 3/4, the channel maps everything to I/2 (the maximally mixed state). The Bloch vector shrinks uniformly in all directions — this is why it is called the depolarising channel.

This is the most common noise model in practice because it is analytically tractable and can be calibrated from randomised benchmarking data.

Amplitude damping channel

Models energy relaxation (T1 decay): spontaneous emission from |1⟩ to |0⟩ with probability γ:

K₀ = [[1, 0], [0, √(1−γ)]]    K₁ = [[0, √γ], [0, 0]]

Verify:

K₀†K₀ + K₁†K₁ = [[1, 0], [0, 1−γ]] + [[0, 0], [0, γ]] = I ✓

Effect on density matrix elements:

ρ₀₀ → 1 − (1 − ρ₀₀)(1 − γ) = ρ₀₀ + γ ρ₁₁
ρ₁₁ → ρ₁₁(1 − γ)
ρ₀₁ → ρ₀₁ √(1 − γ)

With γ = 1 − e^(−t/T1), this gives the correct T1 exponential decay.

Generalised amplitude damping

Thermal noise at temperature T > 0: the qubit can absorb energy from the environment as well as emit. Four Kraus operators:

K₀ = √p [[1, 0], [0, √(1−γ)]]
K₁ = √p [[0, √γ], [0, 0]]
K₂ = √(1−p) [[√(1−γ), 0], [0, 1]]
K₃ = √(1−p) [[0, 0], [√γ, 0]]

where p = 1/(1 + e^(−ℏω/kT)) is the thermal excitation probability. At T=0, p=1 and this reduces to the ordinary amplitude damping channel.

Implementing Kraus operators in Qiskit

from qiskit_aer.noise import NoiseModel, QuantumError
from qiskit_aer.noise.errors import kraus_error
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit
import numpy as np

def make_depolarising_channel(p: float) -> list:
    """Return Kraus operators for depolarising channel."""
    I = np.eye(2, dtype=complex)
    X = np.array([[0, 1], [1, 0]], dtype=complex)
    Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
    Z = np.array([[1, 0], [0, -1]], dtype=complex)
    return [
        np.sqrt(1 - p) * I,
        np.sqrt(p / 3) * X,
        np.sqrt(p / 3) * Y,
        np.sqrt(p / 3) * Z,
    ]

def make_amplitude_damping(gamma: float) -> list:
    """Return Kraus operators for amplitude damping channel."""
    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, K1]

# Build noise model with custom Kraus channels
p_depol = 0.01        # 1% depolarising error per gate
gamma_amp = 0.005     # 0.5% amplitude damping per gate

noise_model = NoiseModel()
depol_error = kraus_error(make_depolarising_channel(p_depol))
amp_error   = kraus_error(make_amplitude_damping(gamma_amp))

noise_model.add_all_qubit_quantum_error(depol_error, ['h', 'rz'])
noise_model.add_all_qubit_quantum_error(amp_error, ['id'])

# Test: prepare |+⟩, idle, measure ⟨Z⟩
qc = QuantumCircuit(1, 1)
qc.h(0)
for _ in range(50):   # 50 identity gates ≈ idle time
    qc.id(0)
qc.h(0)          # Rotate back to Z basis
qc.measure(0, 0)

backend = AerSimulator(noise_model=noise_model)
result = backend.run(qc, shots=50_000).result()
counts = result.get_counts()
p0 = counts.get('0', 0) / 50_000
print(f"P(|0⟩) = {p0:.3f}  (ideal: 1.0, depolarised: 0.5)")

The Choi-Jamiolkowski isomorphism

Every quantum channel ε on a d-dimensional system corresponds to a unique d²×d² matrix called the Choi matrix:

J(ε) = (ε ⊗ I)(|Φ+⟩⟨Φ+|)

where |Φ+⟩ = (1/√d) Σᵢ |i⟩|i⟩ is the maximally entangled state. The channel acts on the first subsystem while the second is untouched.

The Choi matrix encodes the channel completely:

Channel is completely positive ↔ Choi matrix is positive semidefinite
Channel is trace-preserving ↔ partial trace over first subsystem gives I

This isomorphism is useful for:

Channel tomography: Experimentally reconstruct ε by preparing |Φ+⟩ and measuring the output state.
Checking CP: Verify a proposed channel is physical by checking J(ε) ≥ 0.
Theoretical analysis: Many channel properties are easier to prove in the Choi picture.

from qiskit.quantum_info import Choi, SuperOp, PTM
import numpy as np

# Construct Choi matrix for the depolarising channel
from qiskit_aer.noise.errors import kraus_error
from qiskit.quantum_info import Kraus, Choi

kraus_ops = make_depolarising_channel(0.2)
kraus_channel = Kraus(kraus_ops)
choi_matrix = Choi(kraus_channel)

print("Choi matrix (depolarising, p=0.2):")
print(np.round(choi_matrix.data, 3))
# Eigenvalues should all be non-negative (CP condition)
eigenvalues = np.linalg.eigvalsh(choi_matrix.data)
print(f"Eigenvalues: {np.round(eigenvalues, 4)}")
print(f"All non-negative (CP): {all(eigenvalues >= -1e-10)}")

Why this matters for error mitigation

Understanding the Kraus structure of noise channels allows you to:

Choose the right error mitigation technique: Zero-noise extrapolation (ZNE) works by artificially amplifying the noise and extrapolating back to zero — it implicitly assumes the noise scales uniformly. This is a good approximation for depolarising noise but poor for amplitude damping.
Design error-aware circuits: If the dominant noise is amplitude damping (T1), initialise ancillas as |0⟩ not |1⟩ whenever possible to minimise the excitation population that can decay.
Implement probabilistic error cancellation (PEC): PEC requires decomposing noise-free operations as linear combinations of noisy operations. This decomposition uses the Kraus representation directly.
Benchmark accurately: Process tomography reconstructs the Choi matrix of a noisy gate, giving you the complete noise characterisation rather than a single number.