MIMO Detection

The $N_r \times N_t$ MIMO system model is:

$$\mathbf{y} = \mathbf{H}\mathbf{x} + \mathbf{n}$$

where $\mathbf{x} \in \mathcal{S}^{N_t}$ (each entry from constellation $\mathcal{S}$), $\mathbf{H} \in \mathbb{C}^{N_r \times N_t}$, and $\mathbf{n} \sim \mathcal{CN}(\mathbf{0}, N_0\mathbf{I})$.

def mimo_channel(H, x, N0, rng=None):
    if rng is None: rng = np.random.default_rng()
    Nr = H.shape[0]
    n = np.sqrt(N0/2) * (rng.standard_normal(Nr) + 1j*rng.standard_normal(Nr))
    return H @ x + n

ZF detection applies the pseudoinverse of $\mathbf{H}$:

$$\hat{\mathbf{x}}_{\text{ZF}} = (\mathbf{H}^H\mathbf{H})^{-1}\mathbf{H}^H\mathbf{y} = \mathbf{H}^\dagger\mathbf{y}$$

then quantizes each entry to the nearest constellation point.

def zf_detect(y, H, constellation):
    G = np.linalg.pinv(H)
    x_hat = G @ y
    # Quantize each stream
    det = np.array([constellation[np.argmin(np.abs(xi - constellation))] for xi in x_hat])
    return det

MMSE detection balances interference suppression and noise:

$$\hat{\mathbf{x}}_{\text{MMSE}} = (\mathbf{H}^H\mathbf{H} + \frac{N_0}{E_s}\mathbf{I})^{-1} \mathbf{H}^H\mathbf{y}$$

The regularization term $\frac{N_0}{E_s}\mathbf{I}$ prevents noise amplification.

def mmse_detect(y, H, constellation, N0, Es=1.0):
    Nt = H.shape[1]
    G = np.linalg.inv(H.conj().T @ H + (N0/Es)*np.eye(Nt)) @ H.conj().T
    x_hat = G @ y
    det = np.array([constellation[np.argmin(np.abs(xi - constellation))] for xi in x_hat])
    return det

ML detection searches over all $M^{N_t}$ possible transmit vectors:

$$\hat{\mathbf{x}}_{\text{ML}} = \arg\min_{\mathbf{x} \in \mathcal{S}^{N_t}} \|\mathbf{y} - \mathbf{H}\mathbf{x}\|^2$$

This is optimal but has complexity $O(M^{N_t})$ — exponential in the number of antennas.

from itertools import product

def ml_detect(y, H, constellation):
    Nt = H.shape[1]
    best_dist = np.inf
    best_x = None
    for x_cand in product(constellation, repeat=Nt):
        x_vec = np.array(x_cand)
        dist = np.sum(np.abs(y - H @ x_vec)**2)
        if dist < best_dist:
            best_dist = dist
            best_x = x_vec
    return best_x

The sphere decoder finds the ML solution efficiently by searching only within a sphere of radius $r$ around $\mathbf{y}$:

$$\|\mathbf{y} - \mathbf{H}\mathbf{x}\|^2 \le r^2$$

Using QR decomposition $\mathbf{H} = \mathbf{Q}\mathbf{R}$, the search becomes a tree-search problem that prunes branches exceeding the radius. Average complexity is polynomial (roughly $O(M^{N_t/2})$) for typical SNR.