Chapter 17: Quantum Channels

Part VI: Quantum Information

Completely Positive Trace-Preserving Maps

A quantum channel is a linear map \(\mathcal{E}: \rho \mapsto \mathcal{E}(\rho)\)on density matrices satisfying:

Trace preserving: \(\text{Tr}(\mathcal{E}(\rho)) = 1\) (probabilities sum to 1)
Completely positive: \((\mathcal{E} \otimes \mathcal{I})(\sigma) \geq 0\) for any extension with identity (physical positivity)

The Stinespring dilation theorem guarantees every CPTP map arises from unitary evolution on a larger system followed by partial trace — every noise channel can be modeled as entanglement with an environment.

Kraus Representation

Every CPTP map has a Kraus decomposition:

\( \mathcal{E}(\rho) = \sum_k K_k \rho K_k^\dagger \quad \text{with} \quad \sum_k K_k^\dagger K_k = I \)

Depolarizing Channel

\(\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)\)

Bloch vector shrinks uniformly: \(\vec{r} \to (1 - \tfrac{4p}{3})\vec{r}\)

Amplitude Damping

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

Models spontaneous emission (\(T_1\) decay). \(\gamma\) = decay probability.

Holevo Bound & Channel Capacity

The Holevo bound limits the classical information extractable from a quantum ensemble. For encoding classical message \(x\) into quantum state \(\rho_x\)with probability \(p_x\):

\( I(X:B) \leq \chi = S\!\left(\sum_x p_x \rho_x\right) - \sum_x p_x S(\rho_x) \)

The Holevo capacity \(\chi\)(chi) is achieved by measuring in the optimal basis. For a depolarizing channel with noise \(p\), the classical capacity approaches \(1 - H_b(p)\)per qubit transmission.

The quantum channel capacity \(Q\) (for transmitting quantum information) is generally lower and given by the coherent information. For degraded channels,\(Q = 0\) when the channel is too noisy.

Python: Quantum Channel Simulation

Simulate the depolarizing channel (Bloch sphere shrinkage), plot classical capacity vs noise, and show amplitude damping trajectory on the Bloch sphere cross-section.

Python

script.py168 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# ── Bloch sphere helpers ─────────────────────────────────────────────────────
def bloch_to_rho(r):
    """Convert Bloch vector r=(rx,ry,rz) to 2x2 density matrix."""
    rx, ry, rz = r
    return 0.5 * np.array([[1 + rz,        rx - 1j*ry],
                            [rx + 1j*ry,    1 - rz]], dtype=complex)

def rho_to_bloch(rho):
    """Extract Bloch vector from 2x2 density matrix."""
    rx = 2 * np.real(rho[0,1])
    ry = 2 * np.imag(rho[1,0])
    rz = np.real(rho[0,0] - rho[1,1])
    return np.array([rx, ry, rz])

# ── Depolarizing channel ─────────────────────────────────────────────────────
# E(rho) = (1-p)*rho + p*(I/2)
# Bloch vector shrinks: r -> (1 - 4p/3) * r  for p in [0, 3/4]

def depolarizing_channel(rho, p):
    """Apply depolarizing channel with noise parameter p."""
    return (1 - p) * rho + p * np.eye(2) / 2

def depolarizing_bloch(r, p):
    return (1 - 4*p/3) * np.array(r)

# ── Amplitude damping channel ────────────────────────────────────────────────
# Models energy relaxation (T1 decay): |1> -> |0>
# Kraus operators: K0 = [[1,0],[0,sqrt(1-gamma)]], K1 = [[0,sqrt(gamma)],[0,0]]

def amplitude_damping(rho, gamma):
    """Apply amplitude damping channel with damping parameter 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

# ── Classical capacity: Holevo bound for depolarizing channel ─────────────────
# For depolarizing channel with parameter p, classical capacity:
# C = 1 - H_bin(p) approximately (for small p)
# More precisely: C = 1 + lambda*log2(lambda) + (1-lambda)*log2(1-lambda)
# where lambda = (3/4)(1-p) shrinkage factor for each component

def binary_entropy(p):
    if p <= 0 or p >= 1:
        return 0.0
    return -p * np.log2(p) - (1-p) * np.log2(1-p)

def holevo_classical_capacity(p_noise):
    """Holevo classical capacity of depolarizing channel (approximate)."""
    # Output entropy for optimal input (Hadamard basis)
    lam = (1 - 4*p_noise/3)   # shrinkage factor
    # Eigenvalues of output state
    ev1 = (1 + lam) / 2
    ev2 = (1 - lam) / 2
    if ev1 <= 0 or ev2 <= 0 or abs(lam) >= 1:
        return 0.0
    S_out = -ev1 * np.log2(ev1) - ev2 * np.log2(ev2) if ev1 > 0 and ev2 > 0 else 1.0
    # For depolarizing channel input entropy is 1 bit, conditional entropy is
    # roughly h(p) so capacity ~ 1 - h(p) as approximation
    return max(0.0, 1.0 - binary_entropy(p_noise))

print("=== Quantum Channels Analysis ===")
p_test_vals = [0.0, 0.1, 0.25, 0.5, 0.75]
print("Depolarizing channel: Bloch vector shrinkage factor (1 - 4p/3):")
for p in p_test_vals:
    shrink = 1 - 4*p/3
    cap = holevo_classical_capacity(p)
    print(f"  p={p:.2f}: shrinkage = {shrink:.3f}, approx capacity ~ {cap:.3f} bits")
print()

# Amplitude damping
gamma_vals_test = [0.0, 0.1, 0.5, 0.9, 1.0]
rho_excited = np.array([[0, 0], [0, 1]], dtype=complex)  # |1><1|
print("Amplitude damping of |1><1|:")
for g in gamma_vals_test:
    rho_out = amplitude_damping(rho_excited, g)
    r_out = rho_to_bloch(rho_out)
    print(f"  gamma={g:.1f}: rho_out = [[{np.real(rho_out[0,0]):.3f}, ...], ...], "
          f"P(|0>) = {np.real(rho_out[0,0]):.3f}, Bloch_z = {r_out[2]:.3f}")

# ── Plotting ──────────────────────────────────────────────────────────────────
fig = plt.figure(figsize=(15, 5))
fig.patch.set_facecolor('#0a0a1a')

# Plot 1: Bloch sphere cross-section showing depolarizing shrinkage
ax1 = fig.add_subplot(131)
theta_circ = np.linspace(0, 2*np.pi, 300)
# Original Bloch sphere (equatorial circle)
ax1.plot(np.cos(theta_circ), np.sin(theta_circ), color='#818cf8', linewidth=2, label='Pure states (p=0)')
# Shrunk circles for various p
colors_dep = ['#a5b4fc', '#6366f1', '#4338ca', '#312e81']
p_dep_vals = [0.1, 0.25, 0.5, 0.74]
for p_d, col in zip(p_dep_vals, colors_dep):
    r_shrunk = 1 - 4*p_d/3
    if r_shrunk > 0:
        ax1.plot(r_shrunk * np.cos(theta_circ), r_shrunk * np.sin(theta_circ),
                 color=col, linewidth=1.5, linestyle='--', label=f'p={p_d}')
ax1.plot(0, 0, 'w+', markersize=10, label='Maximally mixed (I/2)')
ax1.set_xlim(-1.15, 1.15)
ax1.set_ylim(-1.15, 1.15)
ax1.set_aspect('equal')
ax1.set_xlabel('Bloch x', color='white', fontsize=10)
ax1.set_ylabel('Bloch y', color='white', fontsize=10)
ax1.set_title("Depolarizing Channel\nBloch Sphere Shrinkage", color='white', fontsize=11, fontweight='bold')
ax1.legend(fontsize=7, facecolor='#1a1a2e', edgecolor='#818cf8', labelcolor='white')
ax1.set_facecolor('#0a0a1a')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.2, color='#818cf8')
for sp in ax1.spines.values(): sp.set_color('#818cf8')

# Plot 2: Classical capacity vs noise parameter
ax2 = fig.add_subplot(132)
p_range = np.linspace(0, 0.75, 300)
capacity = [holevo_classical_capacity(p) for p in p_range]
ax2.plot(p_range, capacity, color='#818cf8', linewidth=2.5, label='Classical capacity (Holevo)')
ax2.axhline(1.0, color='#34d399', linestyle=':', linewidth=1.5, alpha=0.8, label='Noiseless (p=0): 1 bit')
ax2.axvline(0.75, color='#f87171', linestyle='--', linewidth=1.5, alpha=0.8, label='p=3/4 (completely depolarizing)')
ax2.fill_between(p_range, capacity, alpha=0.15, color='#818cf8')
ax2.set_xlabel('Depolarizing noise p', color='white', fontsize=11)
ax2.set_ylabel('Classical capacity (bits/channel use)', color='white', fontsize=11)
ax2.set_title("Holevo Capacity\nDepolarizing Channel", color='white', fontsize=12, fontweight='bold')
ax2.legend(fontsize=9, facecolor='#1a1a2e', edgecolor='#818cf8', labelcolor='white')
ax2.set_facecolor('#0a0a1a')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.2, color='#818cf8')
for sp in ax2.spines.values(): sp.set_color('#818cf8')

# Plot 3: Amplitude damping trajectory
ax3 = fig.add_subplot(133)
gammas = np.linspace(0, 1, 100)
# Start with |+> state: rho = [[0.5, 0.5],[0.5, 0.5]]
rho0 = np.array([[0.5, 0.5],[0.5, 0.5]], dtype=complex)
bloch_x = []
bloch_z = []
for g in gammas:
    rho_g = amplitude_damping(rho0, g)
    bv = rho_to_bloch(rho_g)
    bloch_x.append(bv[0])
    bloch_z.append(bv[2])

ax3.plot(bloch_x, bloch_z, color='#818cf8', linewidth=2.5, label='|+> under amplitude damping')
ax3.plot(bloch_x[0], bloch_z[0], 'go', markersize=10, label='Initial |+>')
ax3.plot(bloch_x[-1], bloch_z[-1], 'r^', markersize=10, label='Final (gamma=1): |0>')
# Draw Bloch circle boundary
ax3.plot(np.cos(theta_circ), np.sin(theta_circ), color='#818cf8', linewidth=1, alpha=0.3)
ax3.set_xlim(-1.2, 1.2)
ax3.set_ylim(-1.2, 1.2)
ax3.set_aspect('equal')
ax3.set_xlabel('Bloch x', color='white', fontsize=11)
ax3.set_ylabel('Bloch z', color='white', fontsize=11)
ax3.set_title("Amplitude Damping Channel\n|+> state trajectory", color='white', fontsize=12, fontweight='bold')
ax3.legend(fontsize=9, facecolor='#1a1a2e', edgecolor='#818cf8', labelcolor='white')
ax3.set_facecolor('#0a0a1a')
ax3.tick_params(colors='white')
ax3.grid(True, alpha=0.2, color='#818cf8')
for sp in ax3.spines.values(): sp.set_color('#818cf8')

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a')
plt.show()
print("\nDepolarizing: Bloch sphere shrinks uniformly. At p=3/4: complete depolarization.")
print("Amplitude damping: models T1 relaxation, maps excited states toward ground state.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Ch 16: Von Neumann Entropy Ch 18: Quantum Error Correction →