In short

Every real quantum device suffers noise that fits one of a short catalogue of standard channels. Bit-flip \mathcal E(\rho) = (1-p)\rho + p\,X\rho X shrinks the Bloch vector toward the x-axis. Phase-flip \mathcal E(\rho) = (1-p)\rho + p\,Z\rho Z shrinks it toward the z-axis. Bit-phase flip does the analogous thing toward the y-axis. Depolarizing shrinks the Bloch vector uniformly toward the origin (the maximally mixed state). Amplitude damping (the T_1 channel) models energy decay |1\rangle\to|0\rangle — it both shifts the Bloch vector toward the north pole and shrinks the in-plane component. Phase damping (the T_2 channel) models pure dephasing — it squashes the Bloch ball onto the z-axis without moving anything along z. The Pauli channel is the general convex combination \mathcal E(\rho) = \sum_i p_i\sigma_i\rho\sigma_i. On every IBM, Google, and Quantinuum machine, a qubit's decoherence is some mixture of these processes — and the times T_1 (energy decay, \sim 100\mus on current transmons) and T_2 (phase coherence, always \leq 2T_1) are the single most reported hardware figures.

You have met the Kraus representation, the CPTP axioms, and Stinespring's dilation theorem. All three tell you what a quantum channel is. None of them tells you which channels show up on a real qubit. A silicon chip in a dilution refrigerator at 10 millikelvin is full of stray electromagnetic fields, fluctuating charge traps, thermal phonons, and control-line crosstalk, and every one of those is some specific CPTP map on the system. Which ones?

The answer is a short, universal catalogue. Every practical noise process on a qubit — in a superconducting transmon, a trapped ion, a neutral atom, a photonic mode, a spin qubit in silicon — is built out of a small number of standard channels. Bit-flip. Phase-flip. Depolarizing. Amplitude damping. Phase damping. The general Pauli mixture. If you learn these six by heart, you can read the noise specification of any quantum hardware on the market today and know exactly what physics it is describing.

This chapter is the working vocabulary. Each channel gets its Kraus operators, its action on the Bloch vector, its physical origin, and a figure showing what it does to the Bloch sphere. The punchline arrives at the end: every named channel corresponds to a measurable number on a hardware spec sheet. Walking the catalogue is what makes a line like "this transmon has T_1 = 120\,\mu s and T_2 = 85\,\mu s" mean something in your head.

The language: Pauli channels and Bloch-vector action

Most standard channels are Pauli channels — they are convex combinations of the Pauli unitaries \{I, X, Y, Z\} applied to \rho.

Pauli channel

A single-qubit Pauli channel with probabilities (p_I, p_X, p_Y, p_Z), summing to 1, is

\mathcal E(\rho) \;=\; p_I\,\rho + p_X\,X\rho X + p_Y\,Y\rho Y + p_Z\,Z\rho Z.

The Kraus operators are K_I = \sqrt{p_I}\,I, K_X = \sqrt{p_X}\,X, K_Y = \sqrt{p_Y}\,Y, K_Z = \sqrt{p_Z}\,Z, satisfying completeness \sum p_i I = I because Paulis square to identity.

Pauli channels have a beautifully simple Bloch-vector action. Write \rho = \tfrac{1}{2}(I + \vec r\cdot\vec\sigma) for the Bloch vector \vec r = (r_x, r_y, r_z). Under a Pauli channel, \vec r transforms component-wise:

r_x \mapsto (p_I + p_X - p_Y - p_Z)\,r_x, \quad r_y \mapsto (p_I - p_X + p_Y - p_Z)\,r_y, \quad r_z \mapsto (p_I - p_X - p_Y + p_Z)\,r_z.

Why each Pauli flips exactly two components: X\sigma X = \sigma when \sigma commutes with X (so \sigma \in \{I, X\}) and X\sigma X = -\sigma when \sigma anticommutes with X (so \sigma \in \{Y, Z\}). So conjugating by X preserves r_x and flips r_y, r_z. The general Pauli channel is a weighted average of these flips, giving the three diagonal shrinkage factors above.

Every Pauli channel is a diagonal shrinkage of the Bloch vector: each coordinate axis is scaled by its own non-negative factor \leq 1. The whole channel is described by those three numbers — the axis contraction factors.

Amplitude damping is the one non-Pauli channel in our catalogue. It both shrinks the Bloch vector and shifts its origin, for a reason tied to its physical origin (energy loss is not a symmetric process — energy flows out, never in, at zero temperature).

The catalogue

Bit-flip

K_0 = \sqrt{1-p}\,I, \qquad K_1 = \sqrt p\,X.
\mathcal E_{\text{bf}}(\rho) \;=\; (1-p)\rho + p\,X\rho X.

With probability p, a Pauli X flips the qubit. The fixed points of X are the eigenstates |+\rangle = (|0\rangle+|1\rangle)/\sqrt 2 and |-\rangle = (|0\rangle-|1\rangle)/\sqrt 2 — they are unchanged by the flip. States lying elsewhere on the Bloch sphere get pulled toward the x-axis (the line through |+\rangle and |-\rangle).

Bloch-vector action. Using the Pauli-channel formula with (p_I, p_X, p_Y, p_Z) = (1-p, p, 0, 0):

r_x \mapsto r_x, \quad r_y \mapsto (1-2p)\,r_y, \quad r_z \mapsto (1-2p)\,r_z.

The x-component is preserved; the other two shrink by (1-2p). At p = 1/2, the y and z components vanish entirely — every state collapses to a diagonal-plus-I/2 state on the x-axis.

Physical origin. On a classical computer, a bit-flip corresponds to a spurious \pi rotation of the qubit around the x-axis. On a superconducting qubit, stray magnetic-field fluctuations along the z-axis produce bit-flip-like errors (via HZH = X if the rotation happens in an "H-rotated" frame). On a spin qubit, a resonant \pi-pulse mistimed is exactly a partial bit-flip.

Phase-flip

K_0 = \sqrt{1-p}\,I, \qquad K_1 = \sqrt p\,Z.
\mathcal E_{\text{pf}}(\rho) \;=\; (1-p)\rho + p\,Z\rho Z.

With probability p, a Pauli Z flips the relative phase between |0\rangle and |1\rangle. The fixed points of Z are |0\rangle and |1\rangle themselves. States on the equator get pulled toward the z-axis.

Bloch-vector action. (p_I, p_X, p_Y, p_Z) = (1-p, 0, 0, p):

r_x \mapsto (1-2p)\,r_x, \quad r_y \mapsto (1-2p)\,r_y, \quad r_z \mapsto r_z.

The z-component is preserved; the x and y components shrink together.

Physical origin. Phase-flip is the archetypal dephasing error. It preserves classical populations (probabilities of measuring 0 or 1) but destroys coherence between them. Random 1/f noise on the qubit frequency — extremely common in real hardware — produces phase-flip-like errors over time.

Bit-phase flip

K_0 = \sqrt{1-p}\,I, \qquad K_1 = \sqrt p\,Y.
\mathcal E_{\text{bpf}}(\rho) \;=\; (1-p)\rho + p\,Y\rho Y.

Same template with Y. Fixed points are |+i\rangle and |-i\rangle (the Y eigenstates). Bloch vector y-component preserved; x and z shrink by (1-2p).

Depolarizing channel

K_0 = \sqrt{1-\tfrac{3p}{4}}\,I, \quad K_1 = \tfrac{\sqrt p}{2}\,X, \quad K_2 = \tfrac{\sqrt p}{2}\,Y, \quad K_3 = \tfrac{\sqrt p}{2}\,Z.

Equivalently, the depolarizing channel is

\mathcal E_{\text{dep}}(\rho) \;=\; (1-p)\,\rho + p\,\frac{I}{2},

a convex combination of "do nothing" and "replace the state with the maximally mixed state I/2". With probability 1-p, you keep \rho; with probability p, the state is wiped out and replaced by I/2. Why the two forms agree: the identity I/2 = \tfrac{1}{4}(\rho + X\rho X + Y\rho Y + Z\rho Z) holds for every density matrix \rho, so uniformly-mixing the three Paulis with coefficients p/4 each and adding (1 - 3p/4) times the identity channel gives (1-p)\rho + p\cdot I/2 after regrouping.

Bloch-vector action. (p_I, p_X, p_Y, p_Z) = (1 - 3p/4, p/4, p/4, p/4):

\vec r \mapsto (1-p)\,\vec r.

Uniform shrinkage of the entire Bloch vector by a factor 1 - p. At p = 0, no change. At p = 1, every state collapses to the origin (the maximally mixed state I/2).

Physical origin. Depolarizing is a useful theoretical average model: if you randomly choose one of many noise processes on a qubit, the average effect is often approximately depolarizing (a twirling argument — if the noise's "direction" is uniformly random, only the uniform shrinkage survives). It is not the literal noise on any specific hardware, but it is a common "worst case" baseline in analysis of error-correcting codes.

Amplitude damping (T_1)

K_0 = \begin{pmatrix}1 & 0 \\ 0 & \sqrt{1-\gamma}\end{pmatrix}, \qquad K_1 = \begin{pmatrix}0 & \sqrt\gamma \\ 0 & 0\end{pmatrix}.

Not a Pauli channel. This is the single most physically important channel in quantum hardware: it models spontaneous emission. A qubit in |1\rangle decays to |0\rangle with probability \gamma per time step, emitting a photon (or phonon, or magnon) into the environment.

Action in the computational basis. Take \rho = \begin{pmatrix}a & b \\ b^* & d\end{pmatrix} with a + d = 1. Then

\mathcal E_{\text{AD}}(\rho) \;=\; \begin{pmatrix}a + \gamma d & \sqrt{1-\gamma}\,b \\ \sqrt{1-\gamma}\,b^* & (1-\gamma)d\end{pmatrix}.

Why the (0,0) entry grows: probability \gamma d leaks from |1\rangle to |0\rangle, so the |0\rangle population gains by \gamma d and the |1\rangle population loses by \gamma d. The off-diagonal coherence b gets multiplied by \sqrt{1-\gamma} because any non-trivial Kraus operator mixes populations with coherences in exactly this way — one step of the decay erodes the phase relation as well as the population imbalance.

Bloch-vector action. Starting from \rho = \tfrac{1}{2}(I + \vec r\cdot\vec\sigma),

r_x \mapsto \sqrt{1-\gamma}\,r_x, \quad r_y \mapsto \sqrt{1-\gamma}\,r_y, \quad r_z \mapsto \gamma + (1-\gamma)r_z.

The Bloch vector's x- and y-components shrink by \sqrt{1-\gamma}. The z-component is both scaled and shifted — it moves towards r_z = 1 (the north pole |0\rangle). At \gamma = 1, every state is mapped to |0\rangle regardless of its input: the qubit has completely relaxed to the ground state.

Physical origin. Every qubit that has an energy difference between |0\rangle and |1\rangle suffers amplitude damping. A transmon's |1\rangle has \approx 5 GHz more energy than its |0\rangle; it emits a microwave photon into the readout cavity and falls to |0\rangle on a time scale called T_1. A trapped-ion qubit's excited state emits an optical photon. A nitrogen-vacancy centre's m_s = \pm 1 states relax via phonons. The T_1 time is the characteristic time for \gamma to grow to \approx 0.63 over the duration — \gamma(t) = 1 - e^{-t/T_1}.

Phase damping (T_2)

K_0 = \begin{pmatrix}1 & 0 \\ 0 & \sqrt{1-\gamma}\end{pmatrix}, \qquad K_1 = \begin{pmatrix}0 & 0 \\ 0 & \sqrt\gamma\end{pmatrix}.

Not a Pauli channel either (though it is unitarily equivalent to a Pauli-Z flip channel — more below). This models pure dephasing: phase information is lost without any energy loss.

Action in the computational basis.

\mathcal E_{\text{PD}}(\rho) \;=\; \begin{pmatrix}a & \sqrt{1-\gamma}\,b \\ \sqrt{1-\gamma}\,b^* & d\end{pmatrix}.

Populations are preserved; off-diagonals are attenuated.

Bloch-vector action.

r_x \mapsto \sqrt{1-\gamma}\,r_x, \quad r_y \mapsto \sqrt{1-\gamma}\,r_y, \quad r_z \mapsto r_z.

Pure dephasing shrinks the x- and y-components only.

Equivalence to phase-flip. With the change of variable 1 - 2p = \sqrt{1-\gamma} (i.e. p = \tfrac{1}{2}(1 - \sqrt{1-\gamma})), phase damping has exactly the Bloch action of a phase-flip channel with probability p. The two channels are unitarily equivalent as CPTP maps — the physics is the same; the Kraus operators just differ by a unitary change of environment basis.

Physical origin. Random fluctuations in the qubit's transition frequency (from 1/f charge noise, critical-current noise in Josephson junctions, magnetic-field jitter on spin qubits) smear the accumulated phase over a random angle. After a time t, the random walk's standard deviation grows as \sqrt{t}, and the coherence b gets suppressed by \exp(-t/T_\varphi), where T_\varphi is the pure dephasing time.

General Pauli channel

\mathcal E(\rho) \;=\; p_I\,\rho + p_X\,X\rho X + p_Y\,Y\rho Y + p_Z\,Z\rho Z.

Convex combination of all four Paulis, with probabilities (p_I, p_X, p_Y, p_Z) summing to 1. Bit-flip, phase-flip, bit-phase flip, and depolarizing are all special cases (with three of the four probabilities being 0, or three of the Pauli probabilities being equal). Pauli channels are the most important class for quantum error correction because stabiliser codes correct exactly Pauli errors — and the action of a general Pauli channel is analysed by tracking the error syndrome produced by each Pauli branch.

Action of standard channels on the Bloch sphereA two-by-three grid of Bloch spheres showing the effect of six channels. Row 1: bit-flip (sphere squashed toward x-axis), phase-flip (squashed toward z-axis), depolarizing (sphere uniformly shrunk). Row 2: amplitude damping (sphere pulled toward north pole and squashed), phase damping (sphere squashed onto z-axis), general Pauli channel (diagonal ellipsoid).bit-flip|0⟩|1⟩|+⟩shrink y, zphase-flip|0⟩|1⟩shrink x, ydepolarizing|0⟩|1⟩uniform shrinkamplitude damping|0⟩|1⟩shrink + shift to |0⟩phase damping (T₂)|0⟩|1⟩collapse x, y to 0general Pauli|0⟩|1⟩diagonal axis shrinkage
Six standard channels and what they do to the Bloch ball. The dashed circle is the original unit Bloch sphere; the shaded shape is the image of the sphere under the channel. Bit-flip, phase-flip, and bit-phase flip contract two of the three axes. Depolarizing contracts all three uniformly. Amplitude damping both contracts the $x$-$y$ plane and shifts the centre toward the north pole (not a Pauli channel). Phase damping collapses the $x$ and $y$ components completely while leaving $z$ untouched. A general Pauli channel contracts each axis by its own factor — an axis-aligned ellipsoid.

T_1 and T_2 — the hardware numbers

On any quantum hardware datasheet, the first two noise numbers listed are T_1 and T_2. They are defined as follows.

T_1 — energy relaxation time

Prepare the qubit in |1\rangle. Wait a time t. Measure. The probability of still being in |1\rangle is

P(|1\rangle \mid t) \;=\; e^{-t/T_1}.

T_1 is the 1/e time for exponential decay of the excited-state population under pure amplitude damping.

In the Kraus parametrisation, \gamma(t) = 1 - e^{-t/T_1} — \gamma grows from 0 to 1 over many T_1 times.

Typical values (as of 2026). IBM Heron-class transmons: T_1 \approx 100–300\,\mu s. Quantinuum trapped-ion qubits: T_1 dominated by motional modes, often exceeding 10 seconds on optical transitions. Atom Computing neutral atoms: T_1 \sim 1–10\,s. Silicon spin qubits: T_1 \sim 1–100\,ms. The numbers vary by three orders of magnitude across technologies, which is part of why "which hardware wins" remains an open question.

T_2 — phase coherence time

Prepare the qubit in |+\rangle. Wait a time t. Measure in the X basis. The probability of getting |+\rangle is

P(|+\rangle \mid t) \;=\; \tfrac{1}{2}(1 + e^{-t/T_2}).

T_2 is the 1/e time for the off-diagonal coherence b in the density matrix to decay.

T_2 combines two effects: (1) amplitude damping, which by itself gives an off-diagonal-decay time 2T_1 (because b \mapsto \sqrt{1-\gamma}\,b and \gamma \propto t/T_1 for small t gives b \propto e^{-t/(2T_1)}), and (2) pure dephasing, with characteristic time T_\varphi. The combined relation is

\frac{1}{T_2} \;=\; \frac{1}{2T_1} + \frac{1}{T_\varphi}.

The inequality T_2 \leq 2T_1

From the formula, T_\varphi^{-1} \geq 0 implies T_2^{-1} \geq (2T_1)^{-1}, i.e.

\boxed{T_2 \leq 2T_1.}

This is a theorem about the noise on any physical qubit — not a coincidence, not a convention. Phase coherence cannot outlast energy coherence by more than a factor of two. The equality T_2 = 2T_1 holds exactly when there is no pure dephasing at all (only amplitude damping limits the coherence). In practice, every hardware platform has some dephasing, and T_2 is strictly less than 2T_1.

Why this inequality is physical, not mathematical: any mechanism that flips the qubit (amplitude damping) automatically scrambles the phase by the same amount. You can have pure dephasing without energy loss, but you cannot have energy loss without the associated phase decoherence. The T_2 \leq 2T_1 bound is the quantitative form of "energy decay disturbs the phase at least as much as it disturbs the population".

Example hardware numbers (2026)

Platform Typical T_1 Typical T_2 T_2 / T_1
IBM Heron transmon \sim 200\,\mu s \sim 100\,\mu s 0.5
Google Willow transmon \sim 70\,\mu s \sim 80\,\mu s 1.1
Quantinuum H2 trapped ion \sim hours \sim 10\,s \sim 0
Atom Computing neutral atom \sim 1\,s \sim 1\,s 1
Silicon spin qubit (UNSW, TU Delft) \sim 100\,ms \sim 1\,ms 0.01

Observation for Indian context. At TIFR Mumbai, the pulsed-NMR-based quantum computing group under Anil Kumar measured T_1 and T_2 on nuclear spins in liquid samples, demonstrating coherence times of tens of seconds for nuclear-spin qubits back in the 2000s — some of the longest qubit coherence times ever reported. The practical penalty: nuclear-spin qubits in liquid NMR cannot be scaled to the thousands of qubits needed for fault tolerance, which is why the field shifted to transmons and ions. But the foundational NMR work at TIFR, IISc, and IIT Kanpur in India established many of the measurement techniques used on today's quantum hardware.

Examples

Example 1 — Amplitude damping with $\gamma = 0.2$ on the excited state

Take the pure state \rho = |1\rangle\langle 1| = \begin{pmatrix}0 & 0 \\ 0 & 1\end{pmatrix} and apply amplitude damping with \gamma = 0.2.

Step 1. Write the Kraus operators at \gamma = 0.2.

K_0 = \begin{pmatrix}1 & 0 \\ 0 & \sqrt{0.8}\end{pmatrix} \approx \begin{pmatrix}1 & 0 \\ 0 & 0.894\end{pmatrix}, \qquad K_1 = \begin{pmatrix}0 & \sqrt{0.2} \\ 0 & 0\end{pmatrix} \approx \begin{pmatrix}0 & 0.447 \\ 0 & 0\end{pmatrix}.

Completeness check: K_0^\dagger K_0 + K_1^\dagger K_1 = \text{diag}(1, 0.8) + \text{diag}(0, 0.2) = I. \checkmark

Step 2. Compute K_0|1\rangle\langle 1|K_0^\dagger.

K_0|1\rangle \;=\; \begin{pmatrix}1 & 0 \\ 0 & \sqrt{0.8}\end{pmatrix}\begin{pmatrix}0 \\ 1\end{pmatrix} \;=\; \sqrt{0.8}\,|1\rangle.

So K_0|1\rangle\langle 1|K_0^\dagger = 0.8\,|1\rangle\langle 1|. Why this term gives 0.8|1\rangle\langle 1|: the "no decay" Kraus branch preserves |1\rangle up to the amplitude \sqrt{0.8}, and the outer product gives the density matrix contribution 0.8\,|1\rangle\langle 1| — population 0.8 for the "qubit is still in |1\rangle" event.

Step 3. Compute K_1|1\rangle\langle 1|K_1^\dagger.

K_1|1\rangle \;=\; \begin{pmatrix}0 & \sqrt{0.2} \\ 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1\end{pmatrix} \;=\; \sqrt{0.2}\,|0\rangle.

So K_1|1\rangle\langle 1|K_1^\dagger = 0.2\,|0\rangle\langle 0|. Why this term gives 0.2|0\rangle\langle 0|: the "decay" Kraus branch moves the qubit from |1\rangle to |0\rangle with amplitude \sqrt{0.2}. Squaring gives the population 0.2 in the |0\rangle state — a photon was emitted.

Step 4. Sum the branches.

\mathcal E_{\text{AD}}(|1\rangle\langle 1|) \;=\; 0.8\,|1\rangle\langle 1| + 0.2\,|0\rangle\langle 0| \;=\; \begin{pmatrix}0.2 & 0 \\ 0 & 0.8\end{pmatrix}.

Step 5. Bloch-vector picture. The input |1\rangle\langle 1| has Bloch vector (0, 0, -1) — south pole. Apply the rule r_z \mapsto \gamma + (1-\gamma)r_z = 0.2 + 0.8\cdot(-1) = -0.6. So the output Bloch vector is (0, 0, -0.6). The state has moved from the south pole 20\% of the way toward the origin — a partial relaxation toward the maximally mixed state, biased toward |0\rangle.

Result. \mathcal E_{\text{AD}}(|1\rangle\langle 1|) = 0.2|0\rangle\langle 0| + 0.8|1\rangle\langle 1|. A 20\% chance of finding the photon in the environment (and the qubit relaxed to |0\rangle); an 80\% chance the qubit is still excited. The mixed state has Bloch vector (0, 0, -0.6).

Amplitude damping on |1⟩ with γ=0.2Two bar charts side by side. Left: input populations for |1⟩⟨1| with a bar of height 0 over |0⟩ and height 1 over |1⟩. Right: output populations after amplitude damping with gamma 0.2 — bar of height 0.2 over |0⟩ and 0.8 over |1⟩. The |0⟩ bar on the right is in accent color marked "decayed".input: |1⟩⟨1|10|0⟩|1⟩pure excitedγ=0.2output10|0⟩|1⟩0.20.8mixed: decayed + excited
Amplitude damping with $\gamma = 0.2$ on the excited state $|1\rangle$. The excited population decays by $20\%$: before, the qubit is purely in $|1\rangle$; after, there is an $80\%$ chance of still being in $|1\rangle$ and a $20\%$ chance of having decayed to $|0\rangle$. The state is now a classical mixture — the Bloch vector has moved from the south pole to $(0,0,-0.6)$.

What this shows. One application of amplitude damping with \gamma = 0.2 gives a 20\% decay probability. In real hardware, \gamma(t) = 1 - e^{-t/T_1}, so \gamma = 0.2 corresponds to t \approx 0.22\,T_1 — roughly a fifth of the relaxation time. Every pulse on a transmon qubit burns through this fraction of the T_1 budget; fault-tolerant quantum computing requires that each logical operation finish in a time short compared to T_1.

Example 2 — Depolarizing channel with $p = 1$ destroys the state

Apply the depolarizing channel with p = 1 to an arbitrary qubit state \rho = \tfrac{1}{2}(I + \vec r\cdot\vec\sigma).

Step 1. Write the Kraus operators at p = 1. With p = 1: K_0 = \sqrt{1/4}\,I = \tfrac{1}{2}I, K_1 = \tfrac{1}{2}X, K_2 = \tfrac{1}{2}Y, K_3 = \tfrac{1}{2}Z. Completeness: \sum_k K_k^\dagger K_k = \tfrac{1}{4}(I + I + I + I) = I. \checkmark

Step 2. Apply to a general state.

\mathcal E_{\text{dep}}(\rho) \;=\; \tfrac{1}{4}(I\rho I + X\rho X + Y\rho Y + Z\rho Z).

Step 3. Use the Pauli-twirl identity:

\rho + X\rho X + Y\rho Y + Z\rho Z \;=\; 2\,\text{tr}(\rho)\,I \;=\; 2\,I

for any trace-1 operator \rho on a single qubit. Why the twirl gives 2I: expand \rho = \tfrac{1}{2}(I + r_x X + r_y Y + r_z Z). Pauli X sends this to \tfrac{1}{2}(I + r_x X - r_y Y - r_z Z) (using XYX = -Y, XZX = -Z). Similarly for Y and Z. Sum the four conjugates: the I coefficients add to 4\cdot\tfrac{1}{2} = 2; the X, Y, Z coefficients each sum to 0 (with two +1s and two -1s). Result: 2I.

Step 4. Plug in.

\mathcal E_{\text{dep}}(\rho) \;=\; \tfrac{1}{4}\cdot 2I \;=\; \tfrac{I}{2}.

Step 5. Bloch-vector picture. Every input Bloch vector \vec r gets shrunk by 1 - p = 0 — i.e. sent to the origin. Every state collapses to the maximally mixed state I/2, which has zero Bloch vector.

Result. \mathcal E_{\text{dep}}(\rho) = I/2 for every \rho when p = 1. The state has been destroyed; all information is gone. No measurement on the output can distinguish which \rho was input.

Depolarizing channel with p=1 collapses every stateLeft side: three Bloch-sphere-like circles showing three different input states as dots at different positions — pole, equator, and an arbitrary off-axis point. Right side: a single circle with a central dot, with three arrows from the three input points converging to the single center point. Arrow labelled "p=1 depolarizing".three different input states|0⟩|+⟩arbitraryp=1depolarizeall → I/2maximally mixed state
Complete depolarization. At $p = 1$, the depolarizing channel sends every input state to the maximally mixed state $I/2$ — the centre of the Bloch ball. Three very different input states (north pole, equator, arbitrary) all map to the same output: a single point at the Bloch-ball origin. The channel has destroyed every bit of information about the input.

What this shows. "Depolarizing with p = 1" is the universal eraser: it wipes out every state to the maximally mixed state. Practically, this never happens on hardware in one step, but p accumulates over many operations. If your logical circuit has an effective p > 0.5 or so, the output carries essentially no information about the input — the computation is noise. Fault-tolerant quantum error correction's job is to ensure this never happens.

Common confusions

Going deeper

If you have the six standard channels, their Kraus operators, Bloch-sphere actions, and the T_1–T_2 connection, you have the working vocabulary of quantum-hardware noise. The rest of this section builds the general Pauli channel theory, explains how T_1/T_2 are measured on real machines, and describes channel tomography.

General Pauli channels and stabiliser codes

Every single-qubit Pauli channel is characterised by (p_I, p_X, p_Y, p_Z). Multi-qubit Pauli channels are characterised by an error rate for each element of the Pauli group (products of tensor products of Paulis). On n qubits, the Pauli group has 4^n elements (modulo global phase), so a general Pauli channel has 4^n - 1 independent probabilities.

Pauli channels are the natural error model for stabiliser codes. A stabiliser code's error-correcting procedure measures a set of commuting Pauli operators (the stabilisers), obtaining a syndrome that identifies which Pauli error occurred — up to the ambiguity of errors with the same syndrome. Under a Pauli-channel noise model, the code's logical error rate is a well-defined probability that can be computed exactly (or, more practically, Monte-Carlo simulated) from the error rates of the physical qubits. This is why Pauli channels are the workhorse noise model for surface-code and colour-code simulations.

Measuring T_1 and T_2 on real hardware

T_1 measurement (energy relaxation). Prepare |1\rangle, wait time t, measure in the computational basis, count the fraction of |1\rangle outcomes. Repeat for many values of t; fit the exponential decay P(|1\rangle | t) = e^{-t/T_1}.

T_2^* measurement (Ramsey coherence). Prepare |+\rangle by Hadamard on |0\rangle. Wait time t. Apply Hadamard again. Measure. The oscillation-envelope decay gives T_2^* (the "free" Ramsey time, which includes quasi-static frequency fluctuations).

T_2 measurement (echo coherence). Insert a \pi-pulse halfway through the Ramsey wait. This "echoes out" low-frequency fluctuations, giving the true decoherence time T_{2,\text{echo}}, which can be several times longer than T_2^* on hardware with significant 1/f noise.

On IBM's public cloud, the backend data page for each device lists per-qubit T_1, T_2^*, T_{2,\text{echo}}, and gate error rates, updated weekly. This is the first place to look when evaluating the noise on any real machine.

Composite and non-Markovian channels

Composing multiple channels: \mathcal E_2 \circ \mathcal E_1(\rho) = \mathcal E_2(\mathcal E_1(\rho)). Pauli channels compose as matrix products in the "Pauli transfer matrix" representation. Amplitude damping followed by phase damping gives the standard (T_1, T_\varphi) \to T_2 combined decoherence.

Non-Markovian noise arises when the environment has memory: the channel at time t depends on the system's history, not just its state at t. This violates the assumption underlying the Kraus representation (which assumes an initial product state of system and environment). Real noise on transmons often has a weakly non-Markovian component from 1/f charge noise and spectator qubits. Correcting for this requires more sophisticated dilation models; the standard Kraus/Stinespring framework is the Markovian starting point.

Channel tomography and benchmarking

Channel tomography reconstructs a channel \mathcal E by applying it to many different input states and performing state tomography on the outputs. For a single-qubit channel (a 4\times 4 linear map on Bloch vectors), six input states (the six cardinal Bloch directions) suffice to determine the twelve free parameters.

Randomised benchmarking extracts the average gate fidelity without full tomography — applying sequences of random Clifford gates of varying length and fitting the exponential decay of the success probability. The decay rate gives the average Pauli error rate per gate, which maps back to an effective depolarizing p.

Gate set tomography (GST) goes further, jointly estimating all gates in a gate set including preparation and measurement errors. GST is the gold standard for characterising high-fidelity operations on small-scale quantum processors.

All three techniques produce numbers that feed back into the standard-channel language: once you have measured the process-matrix elements of your qubit's noise, you express the channel as a convex combination of standard channels (bit-flip \oplus phase-flip \oplus amplitude damping \oplus depolarizing remainder). This is the bridge between raw experimental data and the theory frameworks we have built.

Where this leads next

References

  1. Wikipedia, Quantum depolarizing channel — standard channels and their Kraus operators.
  2. Nielsen and Chuang, Quantum Computation and Quantum Information, §8.3 (standard channels: bit-flip, phase-flip, depolarizing, amplitude damping, phase damping) — Cambridge University Press.
  3. John Preskill, Lecture Notes on Quantum Computation, Ch. 3 (master-equation derivations of T_1 and T_2, standard noise channels) — theory.caltech.edu/~preskill/ph229.
  4. Qiskit Textbook, Noise in Quantum Circuits — depolarizing, amplitude damping, phase damping with worked code examples on real IBM hardware.
  5. Wikipedia, T1 and T2 relaxation times — the NMR origin of the T_1, T_2 distinction and its transfer to quantum-computing hardware.
  6. IBM Quantum, Qubit Coherence Times — live per-qubit T_1, T_2 data on public cloud transmons (Heron-class devices).