# An attempt at an intuitive description of the QR decomposition using Householder reflectors

I really like the Householder matrix. I’ve blogged about its ability to generate an orthonormal basis containing a particular vector in a previous blog post. This blog post is a bit of a tutorial which will use the Householder matrix to perform a QR decomposition. Applying Householder reflectors to compute a QR decomposition is nothing new, but I want this blog post to attempt to provide some intuition into how the algorithm works starting from almost nothing. We’ll briefly visit inner products, matrix multiplication, the Householder matrix and then build a QR decomposition in C. I’m not going to use formal language to define these operations unless it’s necessary. I’m going to assume that you understand things like matrix multiplication and what a matrix inverse is, but not much more than that. The post will be written assuming complex numbers are being used (the C implementation will not… maybe I will add one later).

## The inner product

The inner product takes two vectors and produces a scalar. You can think of a vector as being an array of length values representing coordinates in some N-dimensional space.

Note the bar in the above indicates conjugation. If and are row vectors, we could write the above as:

Where is the transposed conjugate of . Two vectors are said to be orthogonal if they have an inner product of zero. If the inner product of a vector with itself is equal to one, the vector is said to be a unit-vector. The inner product of a vector with a unit-vector is the proportion of that vector that is pointing in the same direction as the unit-vector i.e. if is some unit vector and I define a new vector as:

The vector is now orthogonal to i.e. .

There are some good geometric visualisations of these for two and three dimensional vectors… but everything continues to work in arbitrary dimensions. The above image contains two plots which both contain two perpendicular unit vectors (red and green) and an arbitrary vector (black). In both plots we can verify the red and green vectors are unit vectors by applying the inner product. We can also verify they are orthogonal by applying the inner product. If we compute the inner product of the black vector on the two unit vectors, then multiply each of the scalar results by the corresponding unit vectors used to compute them and sum the results, we should get back the black vector.

## Matrix multiplications

We can define matrix multiplication using inner products of the vectors which make up the rows of the left-hand side matrix with the vectors which make up the columns of the right-hand side matrix.

We can use this to demonstrate that a matrix that is made up of rows (or columns) that are all orthogonal to each other is trivially invertible – particularly if the vectors are unit vectors, in which case the inverse of matrix is . To make this particularly clear:

If the rows are orthogonal to each other, the inner products off the main diagonal will all be zero. If the rows are unit vectors, the diagonal entries are by definition 1 and .

## The Householder matrix

Define a matrix as:

Where is a unit vector. Then:

Thereore is its own inverse () and must also be unitary ().

If we can work out a method to choose such that will contain a particular unit vector and we multiply by any scaled version of vector , we will get a vector which has only one non-zero entry (because all other rows of the matrix will be orthogonal to ). I have described this process before in a previous blog post but will repeat it here with some more detail. Define a vector that we want the first column of to equal:

If is real, we can break into its individual coordinates to solve for their values:

Given the way the matrix is defined, the computation of the square root is unnecessary in an implementation. This is best seen if we expand out the matrix:

Define a scalar and a vector :

Then . This is a particularly useful formulation because we rarely want to compute in its entirity and perform a matrix mutliplication. Rather, we compute:

Which is substantially more efficient. A final necessary change is necessary: if is close to one (which implies all other coefficients of are approaching zero), will begin to approach infinity. There is a relatively simple change here which is to recognise that and are parallel but pointing in different directions (their inner-product is -1). If we don’t care about the direction of the vector, we can change its sign to be the most numerically suitiable for the selection of i.e. if use otherwise use .

This is actually very useful in many applications, one of which is the QR decomposition.

## The QR decomposition

The QR decomposition breaks down a matrix into a unitary matrix and an upper-triangular matrix . There are a number of ways to do this, but we are going use the Householder matrix.

Let’s start by defining a series of unitary transformations applied to as:

Where are all n-by-n unitary matrices. Notice that the first row of will be unmodified by all the transforms that follow. The first two rows of will be unmodified by all the transforms that follow – and so-on.

If we can somehow force the first row of to be the first column of scaled to be a unit vector (while keeping unitary), the first column of will contain only one non-zero entry. We then set about finding a way to select such that the second column contains only two non-zero entries… and so on. Once the process is finished, is upper triangular and the unitary matrix which converts into this form can be written as:

And:

When we follow the above process and the matricies are chosen to be Householder matrices, we have performed the QR decomposition using Householder matrices.

Follows is the C code that implements the decomposition. Because the algorithm repeatedly applies transformations to to eventually arrive at , we will design an API that operates in-place on the supplied matrix. The orthogonal matrix will be built in parallel. The N-1 iterations over the i variable, correspond to the N-1 transformation steps presented earlier. I make no claims about the computational performance of this code. The numerical performance could be improved by using a different method to compute the length of the vector (first thing that happens in the column loop).

/* Perform the QR decomposition of the given square A matrix. * A/R is stored and written in columns i.e. * a[0] a[3] a[6] * a[1] a[4] a[7] * a[2] a[5] a[8] * * q is stored in rows i.e. * q[0] q[1] q[2] * q[3] q[4] q[5] * q[6] q[7] q[8] */ void qr(double *a_r, double *q, int N) { int i, j, k;   /* Initialise qt to be the identity matrix. */ for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { q[i*N+j] = (i == j) ? 1.0 : 0.0; } }   for (i = 0; i < N-1; i++) { double norm, invnorm, alpha; double *ccol = a_r + i*N;   /* Compute length of vector (needed to perform normalisation). */ for (norm = 0.0, j = i; j < N; j++) { norm += ccol[j] * ccol[j]; } norm = sqrt(norm);   /* Flip the sign of the normalisation coefficient to have the * effect of negating the u vector. */ if (ccol[0] > 0.0) norm = -norm; invnorm = 1.0 / norm;   /* Normalise the column * Convert the column in-place into the w vector * Compute alpha */ ccol[i] = (1.0 - ccol[i] * invnorm); for (j = i+1; j < N; j++) { ccol[j] = -ccol[j] * invnorm; } alpha = 1.0 / ccol[i];   /* Update the orthogonal matrix */ for (j = 0; j < N; j++) { double acc = 0.0; for (k = i; k < N; k++) { acc += ccol[k] * q[k+j*N]; } acc *= alpha; for (k = i; k < N; k++) { q[k+j*N] -= ccol[k] * acc; } }   /* Update the upper triangular matrix */ for (j = i+1; j < N; j++) { double acc = 0.0; for (k = i; k < N; k++) { acc += ccol[k] * a_r[k+j*N]; } acc *= alpha; for (k = i; k < N; k++) { a_r[k+j*N] -= ccol[k] * acc; } }   /* Overwrite the w vector with the column data. */ ccol[i] = norm; for (j = i+1; j < N; j++) { ccol[j] = 0.0; } } }

The algorithm follows almost everthing described on this page – albiet with some minor obfuscations (the vector is stored temporarily in the output matrix to avoid needing any extra storage). It’s worth mentioning that the first step of initialising the matrix to isn’t necessary. The initialisation could be performed explicitly in the first iteration of the loop over i – but that introduces more conditional code.