Basic Operations

For $\mathbf{A} \in \mathbb{C}^{m \times n}$ and $\mathbf{B} \in \mathbb{C}^{n \times p}$, the product $\mathbf{C} = \mathbf{A}\mathbf{B}$ has entries:

$$C_{ij} = \sum_{k=1}^{n} A_{ik} B_{kj}$$

In NumPy, this is computed via the @ operator (PEP 465):

C = A @ B           # matrix-matrix
y = A @ x           # matrix-vector
s = x.conj() @ y    # inner product (scalar)

The @ operator dispatches to BLAS gemm (general matrix multiply), which achieves near-peak hardware throughput via cache-optimal blocking and SIMD vectorization.

The transpose $\mathbf{A}^T$ swaps rows and columns: $(A^T)_{ij} = A_{ji}$.

The conjugate transpose (Hermitian transpose) $\mathbf{A}^H$ additionally conjugates each element: $(A^H)_{ij} = A_{ji}^*$.

A_T = A.T                    # transpose
A_H = A.conj().T             # conjugate transpose
A_H = np.conj(A.T)           # equivalent

For real matrices, $\mathbf{A}^H = \mathbf{A}^T$. In wireless communications, channel matrices are complex, so $\mathbf{H}^H$ appears in matched filtering, MMSE estimation, and beamforming.

The trace of a square matrix $\mathbf{A} \in \mathbb{C}^{n \times n}$ is:

$$\mathrm{tr}(\mathbf{A}) = \sum_{i=1}^{n} A_{ii}$$

Key properties:

• $\mathrm{tr}(\mathbf{A} + \mathbf{B}) = \mathrm{tr}(\mathbf{A}) + \mathrm{tr}(\mathbf{B})$
• $\mathrm{tr}(\mathbf{A}\mathbf{B}) = \mathrm{tr}(\mathbf{B}\mathbf{A})$ (cyclic property)
• $\mathrm{tr}(\mathbf{A}) = \sum_i \lambda_i$ (sum of eigenvalues)

t = np.trace(A)

In MIMO, $\mathrm{tr}(\mathbf{R}_{xx})$ gives the total transmit power when $\mathbf{R}_{xx}$ is the transmit covariance matrix.

The determinant of a square matrix $\mathbf{A}$ is a scalar that encodes the signed volume scaling factor of the linear transformation:

$$\det(\mathbf{A}) = \prod_{i=1}^{n} \lambda_i$$

d = np.linalg.det(A)
sign, logdet = np.linalg.slogdet(A)  # numerically stable

For large matrices, use slogdet to avoid overflow/underflow: it returns $(\mathrm{sign}, \log|\det|)$ so that $\det = \mathrm{sign} \cdot e^{\log|\det|}$.

The inverse $\mathbf{A}^{-1}$ of a nonsingular matrix satisfies $\mathbf{A}\mathbf{A}^{-1} = \mathbf{I}$. To solve $\mathbf{A}\mathbf{x} = \mathbf{b}$:

# BAD: computes full inverse (slow, numerically unstable)
x_bad = np.linalg.inv(A) @ b

# GOOD: solves directly via LU decomposition
x = np.linalg.solve(A, b)

np.linalg.solve calls LAPACK gesv, which performs LU factorization with partial pivoting: $\mathbf{P}\mathbf{A} = \mathbf{L}\mathbf{U}$. Cost: $\frac{2}{3}n^3$ flops for the factorization, $2n^2$ flops for the solve. Computing and applying $\mathbf{A}^{-1}$ costs $2n^3$ flops and doubles the numerical error.

The $p$-norm of a vector $\mathbf{x} \in \mathbb{C}^n$ is: $$\|\mathbf{x}\|_p = \left(\sum_{i=1}^{n} |x_i|^p\right)^{1/p}$$

Common choices: $p=2$ (Euclidean), $p=1$ (Manhattan), $p=\infty$ (max).

The matrix $p$-norm is the induced operator norm: $$\|\mathbf{A}\|_p = \max_{\mathbf{x} \neq \mathbf{0}} \frac{\|\mathbf{A}\mathbf{x}\|_p}{\|\mathbf{x}\|_p}$$

The Frobenius norm uses all entries: $\|\mathbf{A}\|_F = \sqrt{\sum_{ij} |A_{ij}|^2}$.

np.linalg.norm(x, ord=2)      # vector 2-norm
np.linalg.norm(A, ord=2)      # largest singular value
np.linalg.norm(A, ord='fro')  # Frobenius norm