Nick Appleton’s blog and stuff - Understanding the Levinson-Durbin Algorithm

Introduction

I’ve recently been playing with this algorithm and wanted to do a write-up of my understanding on how it works. Better references certainly exist, but I wanted to write down how my brain thinks about the algorithm if for no other reason than for my own future reference.

I’m going to focus on the algorithm and explain how to build it - it won’t be the most efficient version, but will hopefully demonstrate the concepts.

Toeplitz systems

The Levinson-Durbin algorithm finds the solution to a Toeplitz system which has a non-zero main diagonal:

$\begin{array}{cc} T x = y \\ (\begin{array}{ccccc} t_{0} & t_{1} & t_{2} & \dots & t_{n - 1} \\ t_{- 1} & t_{0} & t_{1} & ⋱ & ⋮ \\ t_{- 2} & t_{- 1} & t_{0} & ⋱ & t_{2} \\ ⋮ & ⋱ & ⋱ & ⋱ & t_{1} \\ t_{- (n - 1)} & \dots & t_{- 2} & t_{- 1} & t_{0} \end{array}) x = y \end{array}$

Toeplitz systems arise frequently in signal processing problems and, whenever I see them, I think “convolution”. For example, given a discrete convolution:

$y [n] = \sum_{k} a [k] b [n - k]$

Where $a [k]$ is zero outside of the range $0 \leq k \leq N_{a}$ and $b [k]$ is zero outside of the range $0 \leq k \leq N_{b}$ , we can write the equation as a Toeplitz matrix vector product:

$(\begin{matrix} y_{0} \\ y_{1} \\ y_{2} \\ y_{3} \\ ⋮ \end{matrix}) = (\begin{array}{ccccc} a_{0} & 0 & 0 & 0 & \dots \\ a_{1} & a_{0} & 0 & 0 & ⋱ \\ a_{2} & a_{1} & a_{0} & 0 & ⋱ \\ a_{3} & a_{2} & a_{1} & a_{0} & ⋱ \\ ⋮ & ⋱ & ⋱ & ⋱ & ⋱ \end{array}) (\begin{matrix} b_{0} \\ b_{1} \\ b_{2} \\ b_{3} \\ ⋮ \end{matrix})$

Toeplitz matrix multiplications can be implemented using convolutions!

The algorithm

Start by solving a 2x2 Toeplitz system using Cramer’s rule:

$(\begin{array}{cc} t_{0} & t_{1} \\ t_{- 1} & t_{0} \end{array}) (\begin{matrix} x_{0} \\ x_{1} \end{matrix}) = (\begin{matrix} y_{0} \\ y_{1} \end{matrix})$

$(\begin{matrix} x_{0} \\ x_{1} \end{matrix}) = \frac{1}{t_{0}^{2} - t_{1} t_{- 1}} (\begin{array}{cc} t_{0} & - t_{1} \\ - t_{- 1} & t_{0} \end{array}) (\begin{matrix} y_{0} \\ y_{1} \end{matrix})$

To move to higher order systems, let’s define some new quantities:

$T_{n}$ is the $n$ -by- $n$ Topelitz matrix that is taken as the first $n$ rows and columns of a larger Toeplitz matrix. In the above 2x2 example:

$\begin{aligned} T_{2} & = (\begin{array}{cc} t_{0} & t_{1} \\ t_{- 1} & t_{0} \end{array}) \\ T_{1} & = t_{0} \end{aligned}$

$u_{n}$ is the $n$ -row column vector that when multiplied by $T_{n}$ produces $e_{1}$ (i.e. the column vector which has a 1 in the top row and 0 in all other rows). See $u$ , think upper - it is orthogonal to all but the top row of $T_{n}$ .

$u_{2} = \frac{1}{t_{0}^{2} - t_{1} t_{- 1}} (\begin{matrix} t_{0} \\ - t_{- 1} \end{matrix})$

$l_{n}$ is the $n$ -row column vector that when multiplied by $T_{n}$ produces $e_{n}$ (i.e. the column vector with a 1 in the bottom row and 0 in all other rows). See $l$ , think lower - it is orthogonal to all but the bottom row of $T_{n}$ .

$l_{2} = \frac{1}{t_{0}^{2} - t_{1} t_{- 1}} (\begin{matrix} - t_{1} \\ t_{0} \end{matrix})$

$y_{n}$ is the top $n$ rows of the column vector $y$ being solved.
$x_{n}$ is the top $n$ rows of the column vector that satisfies $T_{n} x_{n}$ = $y_{n}$ .

Let’s go ahead and define a $T_{3}$ matrix now:

$\begin{aligned} T_{3} & = (\begin{array}{ccc} t_{0} & t_{1} & t_{2} \\ t_{- 1} & t_{0} & t_{1} \\ t_{- 2} & t_{- 1} & t_{0} \end{array}) \\ = (\begin{array}{cc} T_{2} & \begin{matrix} t_{2} \\ t_{1} \end{matrix} \\ \begin{array}{cc} t_{- 2} & t_{- 1} \end{array} & t_{0} \end{array}) \\ = (\begin{array}{cc} t_{0} & \begin{array}{cc} t_{1} & t_{2} \end{array} \\ \begin{matrix} t_{- 1} \\ t_{- 2} \end{matrix} & T_{2} \end{array}) \end{aligned}$

Notice that $T_{n}$ can be expressed in two different by equivalent ways in terms of $T_{n - 1}$ with two new variables $t_{n - 1}$ and $t_{- (n - 1)}$ inserted into the matrix (all the other new elements are already present in $T_{n - 1}$ ). All $T_{n}$ matricies contain $t_{0}$ on the diagonal.

From here we derive three new quantities ${\hat{y}}_{3}$ , ${\hat{u}}_{3}$ and ${\hat{l}}_{3}$ , and which are based on $x_{2}$ , $u_{2}$ and $l_{2}$ that we defined earlier.

$\begin{aligned} {\hat{y}}_{3} & = T_{3} (\begin{array}{c} x_{2} \\ 0 \end{array}) = (\begin{array}{cc} T_{2} & \begin{matrix} t_{2} \\ t_{1} \end{matrix} \\ \begin{array}{cc} t_{- 2} & t_{- 1} \end{array} & t_{0} \end{array}) (\begin{array}{c} x_{2} \\ 0 \end{array}) = (\begin{array}{c} y_{2} \\ r_{3} \end{array}) \\ {\hat{u}}_{3} & = T_{3} (\begin{array}{c} u_{2} \\ 0 \end{array}) = (\begin{array}{cc} T_{2} & \begin{matrix} t_{2} \\ t_{1} \end{matrix} \\ \begin{array}{cc} t_{- 2} & t_{- 1} \end{array} & t_{0} \end{array}) (\begin{array}{c} u_{2} \\ 0 \end{array}) = (\begin{array}{c} e_{1} \\ α_{3} \end{array}) \\ {\hat{l}}_{3} & = T_{3} (\begin{array}{c} 0 \\ l_{2} \end{array}) = (\begin{array}{cc} t_{0} & \begin{array}{cc} t_{1} & t_{2} \end{array} \\ \begin{matrix} t_{- 1} \\ t_{- 2} \end{matrix} & T_{2} \end{array}) (\begin{array}{c} 0 \\ l_{2} \end{array}) = (\begin{array}{c} β_{3} \\ e_{2} \end{array}) \end{aligned}$

${\hat{u}}_{3}$ is almost $e_{1}$ except for the annoying probably-non-zero entry $α_{3}$ in the bottom row and ${\hat{l}}_{3}$ is almost $e_{3}$ except for a probably-non-zero entry $β_{3}$ at the top row. These scalars have values of:

$\begin{aligned} α_{3} & = (\begin{array}{cc} t_{- 2} & t_{- 1} \end{array}) u_{2} \\ β_{3} & = (\begin{array}{cc} t_{1} & t_{2} \end{array}) l_{2} \end{aligned}$

It is a straight-forward to show that for $n$ , ${\hat{u}}_{n}$ and ${\hat{l}}_{n}$ have values of:

$\begin{aligned} {\hat{u}}_{n} & = T_{n} (\begin{array}{c} u_{n - 1} \\ 0 \end{array}) & = (\begin{array}{c} e_{1} \\ α_{n} \end{array}) \\ {\hat{l}}_{n} & = T_{n} (\begin{array}{c} 0 \\ l_{n - 1} \end{array}) & = (\begin{array}{c} β_{n} \\ e_{n - 1} \end{array}) \end{aligned}$

These values are useless independently, but because of linearity in matrix multiplication, we can use ${\hat{u}}_{n}$ and ${\hat{l}}_{n}$ to obtain $u_{n}$ and $l_{n}$ :

$T_{n} (γ (\begin{matrix} u_{n - 1} \\ 0 \end{matrix}) + δ (\begin{matrix} 0 \\ l_{n - 1} \end{matrix})) = γ (\begin{matrix} e_{1} \\ α_{n} \end{matrix}) + δ (\begin{matrix} β_{n} \\ e_{n - 1} \end{matrix})$

To make the RHS $e_{1}$ , we must solve $γ + δ β_{n} = 1$ and $γ α_{n} + δ = 0$ :

$\begin{aligned} γ & = \frac{1}{1 - β_{n} α_{n}} \\ δ & = - \frac{α_{n}}{1 - β_{n} α_{n}} \\ u_{n} & = γ (\begin{array}{c} u_{n - 1} \\ 0 \end{array}) + δ (\begin{array}{c} 0 \\ l_{n - 1} \end{array}) \\ = \frac{1}{1 - β_{n} α_{n}} ((\begin{array}{c} u_{n - 1} \\ 0 \end{array}) - α_{n} (\begin{array}{c} 0 \\ l_{n - 1} \end{array})) \end{aligned}$

To make the RHS $e_{n}$ , we must solve $γ + δ β_{n} = 0$ and $γ α_{n} + δ = 1$ :

$\begin{aligned} δ & = \frac{1}{1 - β_{n} α_{n}} \\ γ & = - \frac{β_{n}}{1 - β_{n} α_{n}} \\ l_{n} & = δ (\begin{array}{c} 0 \\ l_{n - 1} \end{array}) + γ (\begin{array}{c} u_{n - 1} \\ 0 \end{array}) \\ = \frac{1}{1 - β_{n} α_{n}} ((\begin{array}{c} 0 \\ l_{n - 1} \end{array}) - β_{n} (\begin{array}{c} u_{n - 1} \\ 0 \end{array})) \end{aligned}$

Because $T_{n} l_{n} = e_{n}$ , we know that it is an orthogonal component i.e. any multiple of it may be added to $x_{n}$ and it will only influence the value of $y_{n - 1}$ i.e. the scalar final row of $T_{n} x_{n}$ .

$\begin{aligned} {\hat{y}}_{3} & = T_{3} (\begin{array}{c} x_{2} \\ 0 \end{array}) = (\begin{array}{c} y_{2} \\ r_{3} \end{array}) \\ y_{3} & = T_{3} ((\begin{array}{c} x_{2} \\ 0 \end{array}) + (y_{2} - r_{3}) l_{3}) = T_{3} x_{3} \end{aligned}$

That is, use $l_{3}$ to remove the erroneous quantity $r_{3}$ from ${\hat{y}}_{3}$ and set it to the desired value i.e. the last element of $y_{3}$ which is $y_{2}$ . $x_{3}$ is now:

$x_{3} = (\begin{matrix} x_{2} \\ 0 \end{matrix}) + (y_{2} - r_{3}) l_{3}$

The algorithm continues to replace the $l$ , $u$ and $x$ vectors until the complete solution exists in $x$ .

C Implementation

The following implementation follows the naming of quantities in the above working. l, u and x are first initialised to the quantities $l_{2}$ , $u_{2}$ and $x_{2}$ . The loop then updates and extends these arrays until the solution is found. u and x get a new value appended to the end for each iteration. l gets a new element pre-pended per iteration which removes the need for a reverse-access read.

/* Solves Tx = y for x where x and y are vectors and T is Toeplitz.
 *
 * `ord` is the number of rows and columns in the matrix.
 * `t` contains the toeplitz diagonal coefficients from the bottom left to the
 *   top right (it must contain 2*ord-1 elements). t[ord-1] must be non-zero.
 * `y` contains the desired output (it must contain ord elements).
 * `x` will contain the computed solution. */
static void levindurb(double *x, const double *t, const double *y, unsigned ord) {
    const int diag_offset = ord-1;
    double    u[16];
    double    l[16];
    double    tmp;
    int       i, j;

    assert(ord < 16);

    tmp      = 1.0 / (t[diag_offset] * t[diag_offset] - t[diag_offset+1] * t[diag_offset-1]);
    u[0]     = tmp * t[diag_offset];
    u[1]     = tmp * -t[diag_offset-1];
    l[ord-2] = tmp * -t[diag_offset+1];
    l[ord-1] = u[0];
    x[0]     = y[0] * u[0] + y[1] * l[ord-2];
    x[1]     = y[0] * u[1] + y[1] * l[ord-1];
    for (i = 2; i < ord; i++) {
        double alpha, beta, r, scale;
        double *p_l = &(l[ord-i]);
        for (j = 0, alpha = 0.0, beta = 0.0, r = 0.0; j < i; j++) {
            r     += x[j]   * t[diag_offset-i+j];
            alpha += u[j]   * t[diag_offset-i+j];
            beta  += p_l[j] * t[diag_offset+1+j];
        }
        scale = 1.0 / (1.0 - beta * alpha);
        for (j = 0; j <= i; j++) {
            double ut = (j < i) ? u[j]     : 0.0;
            double lt = (j > 0) ? p_l[j-1] : 0.0;
            double xt = (j < i) ? x[j]     : 0.0;
            u[j]      = scale * (ut - alpha * lt);
            p_l[j-1]  = scale * (lt - beta * ut);
            x[j]      = xt + (y[i] - r) * p_l[j-1];
        }
    }
}