Optimal equalizer weights using MSE algorithm

The minimum mean square error (MSE) criterion chooses the equalizer tap weights that make the average squared error between the desired symbol and the equalizer output as small as possible. The optimum set is called the Wiener solution.

Structure: adaptive linear combiner (transversal equalizer)

 y_k ─┬─[z⁻¹]─┬─[z⁻¹]─┬─ ... ─[z⁻¹]─┐
      │       │       │              │
     (x)w₀   (x)w₁   (x)w₂   ...    (x)w_N
      │       │       │              │
      └───────┴──────(Σ)─────────────┘
                      │ d̂_k (output)
                      v
           x_k ──►(+)─(−)──► e_k (error)
                      │
            [Adaptive algorithm] → updates w

Derivation

Let the input vector and weight vector be:

y_k = [y_k  y_(k−1)  ...  y_(k−N)]ᵀ
w_k = [w₀  w₁  ...  w_N]ᵀ

Equalizer output and error (x_k = desired/transmitted symbol):

d̂_k = y_kᵀ w_k = w_kᵀ y_k
e_k  = x_k − y_kᵀ w_k

Square the error:

|e_k|² = x_k² + w_kᵀ y_k y_kᵀ w_k − 2 x_k y_kᵀ w_k

Take expectation (w is treated as fixed):

ξ = E[|e_k|²]
  = E[x_k²] + wᵀ E[y_k y_kᵀ] w − 2 E[x_k y_kᵀ] w

Define:

R = E[y_k y_kᵀ]   (input correlation matrix, (N+1)×(N+1))
p = E[x_k y_k]    (cross-correlation vector)

Then the MSE is a quadratic ("bowl-shaped") function of w:

ξ = E[x_k²] + wᵀ R w − 2 pᵀ w

Set the gradient to zero to find the minimum:

∇ξ = ∂ξ/∂w = 2 R w − 2 p = 0
R ŵ = p
ŵ = R⁻¹ p          ← optimum (Wiener) weights

Minimum MSE, by substituting ŵ:

ξ_min = E[x_k²] − pᵀ R⁻¹ p = E[x_k²] − pᵀ ŵ

Error surface

 ξ
 |\           /
 | \         /
 |  \       /     quadratic bowl
 |   \_____/      single global minimum
 |      •  ξ_min
 +------ŵ--------> w

Since R is positive definite, the surface has a single global minimum, so any gradient search (steepest descent, LMS) converges to ŵ.

Practical note

Computing R⁻¹ directly needs about (N+1)³ operations and knowledge of the statistics. Adaptive algorithms find ŵ iteratively:

• LMS: w_(k+1) = w_k + α e_k y_k (simple, slow convergence).
• RLS: faster convergence, more computation.