# Five Interpretations of Kernel Quadrature

I’m excited to share that my paper Kernel quadrature with randomly pivoted Cholesky, joint with Elvira Moreno, has been accepted to NeurIPS 2023 as a spotlight.

Today, I want to share with you a little about the kernel quadrature problem. To avoid this post getting too long, I’m going to write this post assuming familiarity with the concepts of reproducing kernel Hilbert spaces and Gaussian processes.

Integration is one of the most widely used operations in mathematics and its applications. As such, it is a basic problem of wide interest to develop numerical methods for evaluating integrals.

In this post, we will consider a quite general integration problem. Let be a domain and let be a (finite Borel) measure on . We consider the task of evaluating

One can imagine that , , and are fixed, but we may want to evaluate this same integral for multiple different functions .

To evaluate, we will design a quadrature approximation to the integral :

Concretely, we wish to find real numbers and points such that the approximation is accurate.

## Smoothness and Reproducing Kernel Hilbert Spaces

As is frequently the case in computational mathematics, the accuracy we can expect for this integration problem depends on the smoothness of the integrand . The more smooth is, the more accurately we can expect to compute for a given budget of computational effort.

In this post, will measure smoothness using the reproducing kernel Hilbert space (RKHS) formalism. Let be an RKHS with norm . We can interpret the norm as assigning a roughness to each function . If is large, then is rough; if is small, then is smooth.

Associated to the RKHS is the titular reproducing kernel . The kernel is a bivariate function . It is related to the RKHS inner product by the reproducing property

Here, represents the univariate function obtained by setting the first input of to be .

## The Ideal Weights

To design a quadrature rule, we have to set the nodes and weights . Let’s first assume that the nodes are fixed, and talk about how to pick the weights .

There’s one choice of weights that we’ll called the ideal weights. There (at least) are five equivalent ways of characterizing the ideal weights. We’ll present all of them. As an exercise, you can try and convince yourself that these characterizations are equivalent, giving rise to the same weights.

### Interpretation 1: Exactness

A standard way of designing quadrature rules is to make them exact (i.e., error-free) for some class of functions. For instance, many classical quadrature rules are exact for polynomials of degree up to .

For kernel quadrature, it makes sense to design the quadrature rule to be exact for the kernel function at the selected nodes. That is, we require

Enforcing exactness gives us linear equations for the unknowns :

Under mild conditions, this system of linear equations is uniquely solvable, and the solution is the ideal weights.

### Interpretation 2: Interpolate and Integrate

Here’s another very classical way of designing a quadrature rule. First, interpolate the function values at the nodes, obtaining an interpolant . Then, obtain an approximation to the integral by integrating the interpolant:

In our context, the appropriate interpolation method is kernel interpolation.1Kernel interpolation is also called Gaussian process regression or kriging though (confusingly) these terms can also refer to slightly different methods. It is the regularization-free limit of kernel ridge regression. The kernel interpolant is defined to be the minimum-norm function that interpolates the data:

Remarkably, this infinite-dimensional problem has a tractably computable solution. In fact, is the unique function of the form

that agrees with on the points .With a little algebra, you can show that the integral of is

where are the ideal weights.

### Interpretation 3: Minimizing the Worst-Case Error

Define the worst-case error of weights and nodes to be

The quantity is the highest possible quadrature error for a function of norm at most 1.

Having defined the worst-case error, the ideal weights are precisely the weights that minimize this quantity

### Interpretation 4: Minimizing the Mean-Square Error

The next two interpretations of the ideal weights will adopt a probabilistic framing. A Gaussian process is a random function such that ’s values at any collection of points are (jointly) Gaussian random variables. We write for a mean-zero Gaussian process with covariance function :

Define the mean-square quadrature error of weights and nodes to be

The mean-square error reports the expected squared quadrature error over all functions drawn from a Gaussian process with covariance function .

Pleasantly, the mean-square error is equal ro the square of the worst-case error

As such, the ideal weights also minimize the mean-square error

### Interpretation 5: Conditional Expectation

For our last interpretation, again consider a Gaussian process . The integral of this random function is a random variable. To numerically integrate a function , compute the expectation of conditional on agreeing with at the quadrature nodes:

One can show that this procedure yields the quadrature scheme with the ideal weights.

### Conclusion

We’ve just seen five sensible ways of defining the ideal weights for quadrature in a general reproducing kernel Hilbert space. Remarkably, all five lead to exactly the same choice of weights. To me, these five equivalent characterizations give me more confidence that the ideal weights really are the “right” or “natural” choice for kernel quadrature.

That said, there are other reasonable requirements that we might want to impose on the weights. For instance, if is a probability measure and , it is reasonable to add an additional constraint that the weights lie in the probability simplex

With this additional stipulation, a quadrature rule can be interpreted as integrating against a discrete probability measure ; thus, in effect, quadrature amounts to approximating one probability measure by another . Additional constraints such as these can easily be imposed when using the optimization characterizations 3 and 4 of the ideal weights. See this paper for details.

We’ve spent a lot of time talking about how to pick the quadrature weights, but how should we pick the nodes ? To pick the nodes, it seems sensible to try and minimize the worst-case error with the ideal weights . For this purpose, we can use the following formula:

Here, is the Nyström approximation to the kernel induced by the nodes , defined to be

We have written for the kernel matrix with entry and and for the row and column vectors with th entry and .

I find the appearance of the Nyström approximation in this context to be surprising and delightful. Previously on this blog, we’ve seen (column) Nyström approximation in the context of matrix low-rank approximation. Now, a continuum analog of the matrix Nyström approximation has appeared in the error formula for numerical integration.

The appearance of the Nyström approximation in the kernel quadrature error also suggests a strategy for picking the nodes.

Node selection strategy. We should pick the nodes to make the Nyström approximation as accurate as possible.

The closer is to , the smaller the function is and, thus, the smaller the error

Fortunately, we have randomized matrix algorithms for picking good nodes for matrix Nyström approximation such as randomly pivoted Cholesky, ridge leverage score sampling, and determinantal point process sampling; maybe these matrix tools can be ported to the continuous kernel setting?

Indeed, all three of these algorithms—randomly pivoted Cholesky, ridge leverage score sampling, and determinantal point process sampling—have been studied for kernel quadrature. The first of these algorithms, randomly pivoted Cholesky, is the subject of our paper. We show that this simple, adaptive sampling method produces excellent nodes for kernel quadrature. Intuitively, randomly pivoted Cholesky is effective because it is repulsive: After having picked nodes , it has a high probability of placing the next node far from the previously selected nodes.

The following image shows 20 nodes selected by randomly pivoted Cholesky in a crescent-shaped region. The cyan–pink shading denotes the probability distribution for picking the next node. We see that the center of the crescent does not have any nodes, and thus is most likely to receive a node during the next round of sampling.

In our paper, we demonstrate—empirically and theoretically—that randomly pivoted Cholesky produces excellent nodes for quadrature. We also discuss efficient rejection sampling algorithms for sampling nodes with the randomly pivoted Cholesky distribution. Check out the paper for details!

# Which Sketch Should I Use?

This is the second of a sequence of two posts on sketching, which I’m doing on the occasion of my new paper on the numerical stability of the iterative sketching method. For more on what sketching is and how it can be used to solve computational problems, I encourage you to check out the first post.

The goals of this post are more narrow. I seek to answer the question:

Which sketching matrix should I use?

To cut to the chase, my answer to this question is:

Sparse sign embeddings are a sensible default for sketching.

There are certainly cases when sparse sign embeddings are not the best type of sketch to use, but I hope to convince you that they’re a good sketching matrix to use for most purposes.

## Experiments

Let’s start things off with some numerical experiments.1Code for all numerical experiments can be found on the blogpost branch of the Github for my recent paper. We’ll compare three types of sketching matrices: Gaussian embeddings, a subsampled randomized trigonometric transform (SRTT), and sparse sign embeddings. See the last post for descriptions of these sketching matrices. I’ll discuss a few additional types of sketching matrices that require more discussion at the end of this post.

Recall that a sketching matrix seeks to compress a high-dimensional matrix or vector to a lower-dimensional sketched matrix or vector . The quality of a sketching matrix for a matrix is measured by its distortion , defined to be the smallest number such that

Here, denotes the column space of the matrix .

### Timing

We begin with timing test. We will measure three different times for each embedding:

1. Construction. The time required to generate the sketching matrix .
2. Vector apply. The time to apply the sketch to a single vector.
3. Matrix apply. The time to apply the sketch to an matrix.

We will test with input dimension (one million) and output dimension . For the SRTT, we use the discrete cosine transform as our trigonometric transform. For the sparse sign embedding, we use a sparsity parameter .

Here are the results (timings averaged over 20 trials):

Our conclusions are as follows:

• Sparse sign embeddings are definitively the fastest to apply, being 3–20× faster than the SRTT and 74–100× faster than Gaussian embeddings.
• Sparse sign embeddings are modestly slower to construct than the SRTT, but much faster to construct than Gaussian embeddings.

Overall, the conclusion is that sparse sign embeddings are the fastest sketching matrices by a wide margin: For an “end-to-end” workflow involving generating the sketching matrix and applying it to a matrix , sparse sign embeddings are 14× faster than SRTTs and 73× faster than Gaussian embeddings.2More timings are reported in Table 1 of this paper, which I credit for inspiring my enthusiasm for the sparse sign embedding l.

### Distortion

Runtime is only one measure of the quality of a sketching matrix; we also must care about the distortion . Fortunately, for practical purposes, Gaussian embeddings, SRTTs, and sparse sign embeddings all tend to have similar distortions. Therefore, we are free to use the sparse sign embeddings, as they as typically are the fastest.

Consider the following test. We generate a sparse random test matrix of size for and using the MATLAB sprand function; we set the sparsity level to 1%. We then compare the distortion of Gaussian embeddings, SRTTs, and sparse sign embeddings across a range of sketching dimensions between 100 and 10,000. We report the distortion averaged over 100 trials. The theoretically predicted value (equivalently, ) is shown as a dashed line.

To me, I find these results remarkable. All three embeddings exhibit essentially the same distortion parameter predicted by the Gaussian theory.

It would be premature to declare success having only tested on one type of test matrix . Consider the following four test matrices:

• Sparse: The test matrix from above.
• Dense: is taken to be a matrix with independent standard Gaussian random values.
• Khatri–Rao: is taken to be the Khatri–Rao product of three Haar random orthogonal matrices.
• Identity: is taken to be the identity matrix stacked onto a matrix of zeros.

The performance of sparse sign embeddings (again with sparsity parameter ) is shown below:

We see that for the first three test matrices, the performance closely follows the expected value . However, for the last test matrix “Identity”, we see the distortion begins to slightly exceed this predicted distortion for .

To improve sparse sign embeddings for higher values of , we can increase the value of the sparsity parameter . We recommend

With this higher sparsity level, the distortion closely tracks for all four test matrices:

### Conclusion

Implemented appropriately (see below), sparse sign embeddings can be faster than other sketching matrices by a wide margin. The parameter choice is enough to ensure the distortion closely tracks for most test matrices. For the toughest test matrices, a slightly larger sparsity parameter can be necessary to achieve the optimal distortion.

While these tests are far from comprehensive, they are consistent with the uniformly positive results for sparse sign embeddings reported in the literature. We believe that this evidence supports the argument that sparse sign embeddings are a sensible default sketching matrix for most purposes.

## Sparse Sign Embeddings: Theory and Practice

Given the highly appealing performance characteristics of sparse sign embeddings, it is worth saying a few more words about these embeddings and how they perform in both theory and practice.

Recall that a sparse sign embedding is a random matrix of the form

Each column is an independent and randomly generated to contain exactly nonzero entries in uniformly random positions. The value of each nonzero entry of is chosen to be either or with 50/50 odds.

### Parameter Choices

The goal of sketching is to reduce vectors of length to a smaller dimension . For linear algebra applications, we typically want to preserve all vectors in the column space of a matrix up to distortion :

To use sparse sign embeddings, we must choose the parameters appropriately:

Given a dimension and a target distortion , how do we pick and ?

Based on the experiments above (and other testing reported in the literature), we recommend the following parameter choices in practice:

The parameter choice is advocated by Tropp, Yurtever, Udell, and Cevher; they mention experimenting with parameter values as small as . The value has demonstrated deficiencies and should almost always be avoided (see below). The scaling is derived from the analysis of Gaussian embeddings. As Martinsson and Tropp argue, the analysis of Gaussian embeddings tends to be reasonably descriptive of other well-designed random embeddings.

The best-known theoretical analysis, due to Cohen, suggests more cautious parameter setting for sparse sign embeddings:

The main difference between Cohen’s analysis and the parameter recommendations above is the presence of the factor and the lack of explicit constants in the O-notation.

### Implementation

For good performance, it is imperative to store using either a purpose-built data structure or a sparse matrix format (such as a MATLAB sparse matrix or scipy sparse array).

If a sparse matrix library is unavailable, then either pursue a dedicated implementation or use a different type of embedding; sparse sign embeddings are just as slow as Gaussian embeddings if they are stored in an ordinary non-sparse matrix format!

Even with a sparse matrix format, it can require care to generate and populate the random entries of the matrix . Here, for instance, is a simple function for generating a sparse sign matrix in MATLAB:

function S = sparsesign_slow(d,n,zeta)
cols = kron((1:n)',ones(zeta,1)); % zeta nonzeros per column
vals = 2*randi(2,n*zeta,1) - 3; % uniform random +/-1 values
rows = zeros(n*zeta,1);
for i = 1:n
rows((i-1)*zeta+1:i*zeta) = randsample(d,zeta);
end
S = sparse(rows, cols, vals / sqrt(zeta), d, n);
end

Here, we specify the rows, columns, and values of the nonzero entries before assembling them into a sparse matrix using the MATLAB sparse command. Since there are exactly nonzeros per column, the column indices are easy to generate. The values are uniformly and can also be generated using a single line. The real challenge to generating sparse sign embeddings in MATLAB is the row indices, since each batch of row indices much be chosen uniformly at random between and without replacement. This is accomplished in the above code by a for loop, generating row indices at a time using the slow randsample function.

As its name suggests, the sparsesign_slow is very slow. To generate a sparse sign embedding with sparsity requires 53 seconds!

Fortunately, we can do (much) better. By rewriting the code in C and directly generating the sparse matrix in the CSC format MATLAB uses, generating this same 200 by 10 million sparse sign embedding takes just 0.4 seconds, a speedup of 130× over the slow MATLAB code. A C implementation of the sparse sign embedding that can be used in MATLAB using the MEX interface can be found in this file in the Github repo for my recent paper.

## Other Sketching Matrices

Let’s leave off the discussion by mentioning other types of sketching matrices not considered in the empirical comparison above.

### Coordinate Sampling

Another family of sketching matrices that we haven’t talked about are coordinate sampling sketches. A coordinate sampling sketch consists of indices and weights . To apply , we sample the indices and reweight them using the weights:

Coordinate sampling is very appealing: To apply to a matrix or vector requires no matrix multiplication of trigonometric transforms, just picking out some entries or rows and rescaling them.

In order for coordinate sampling to be effective, we need to pick the right indices. Below, we compare two coordinate sampling sketching approaches, uniform sampling and leverage score sampling (both with replacement), to the sparse sign embedding with the suggested parameter setting for the hard “Identity” test matrix used above.

We see right away that the uniform sampling fails dramatically on this problem. That’s to be expected. All but 50 of 100,000 rows of are zero, so picking rows uniformly at random will give nonsense with very high probability. Uniform sampling can work well for matrices which are “incoherent”, with all rows of being of “similar importance”.

Conclusion (Uniform sampling). Uniform sampling is a risky method; it works excellently for some problems, but fails spectacularly for others. Use only with caution!

The ridge leverage score sampling method is more interesting. Unlike all the other sketches we’ve discussed in this post, ridge leverage score sampling is data-dependent. First, it computes a leverage score for each row of and then samples rows with probabilities proportional to these scores. For high enough values of , ridge leverage score sampling performs slightly (but only slightly) worse than the characteristic scaling we expect for an oblivious subspace embedding.

Ultimately, leverage score sampling has two disadvantages when compared with oblivious sketching matrices:

• Higher distortion, higher variance. The distortion of a leverage score sketch is higher on average, and more variable, than an oblivious sketch, which achieve very consistent performance.
• Computing the leverage scores. In order to implement this sketch, the leverage scores have to first be computed or estimated. This is a nontrivial algorithmic problem; the most direct way of computing the leverage scores requires a QR decomposition at cost, much higher than other types of sketches.

There are settings when coordinate sampling methods, such as leverage scores, are well-justified:

• Structured matrices. For some matrices , the leverage scores might be very cheap to compute or approximate. In such cases, coordinate sampling can be faster than oblivious sketching.
• “Active learning”. For some problems, each entry of the vector or row of the matrix may be expensive to generate. In this case, coordinate sampling has the distinct advantage that computing or only requires generating the entries of or rows of for the randomly selected indices .

Ultimately, oblivious sketching and coordinate sampling both have their place as tools in the computational toolkit. For the reasons described above, I believe that oblivious sketching should usually be preferred to coordinate sampling in the absence of a special reason to prefer the latter.

### Tensor Random Embeddings

There are a number of sketching matrices with tensor structure; see here for a survey. These types of sketching matrices are very well-suited to tensor computations. If tensor structure is present in your application, I would put these types of sketches at the top of my list for consideration.

### CountSketch

The CountSketch sketching matrix is the case of the sparse sign embedding. CountSketch has serious deficiencies, and should only be used in practice with extreme care.

Consider the “Identity” test matrix from above but with parameter , and compare the distortion of CountSketch to the sparse sign embedding with parameters :

We see that the distortion of the CountSketch remains persistently high at 100% until the sketching dimension is taken , 20× higher than .

CountSketch is bad because it requires to be proportional to in order to achieve distortion . For all of the other sketching matrices we’ve considered, we’ve only required to be proportional to (or perhaps ). This difference between for CountSketch and for other sketching matrices is a at the root of CountSketch’s woefully bad performance on some inputs.3Here, the symbol is an informal symbol meaning “proportional to”.

The fact that CountSketch requires is simple to show. It’s basically a variant on the famous birthday problem. We include a discussion at the end of this post.4In fact, any oblivious sketching matrix with only 1 nonzero entry per column must have . This is Theorem 16 in the following paper.

There are ways of fixing the CountSketch. For instance, we can use a composite sketch , where is a CountSketch of size and is a Gaussian sketching matrix of size .5This construction is from this paper. For most applications, however, salvaging CountSketch doesn’t seem worth it; sparse sign embeddings with even nonzeros per column are already way more effective and reliable than a plain CountSketch.

## Conclusion

By now, sketching is quite a big field, with dozens of different proposed constructions for sketching matrices. So which should you use? For most use cases, sparse sign embeddings are a good choice; they are fast to construct and apply and offer uniformly good distortion across a range of matrices.

Bonus: CountSketch and the Birthday Problem
The point of this bonus section is to prove the following (informal) theorem:

Let be the “Identity” test matrix above. If is a CountSketch matrix with output dimension , then the distortion of for is with high probability.

Let’s see why. By the structure of the matrix , has the form

where each vector has a single in a uniformly random location .

Suppose that the indices are not all different from each other, say . Set , where is the standard basis vector with in position and zeros elsewhere. Then, but . Thus, for the distortion relation

to hold, . Thus,

For a moment, let’s put aside our analysis of the CountSketch, and turn our attention to a famous puzzle, known as the birthday problem:

How many people have to be in a room before there’s at least a 50% chance that two people share the same birthday?

The counterintuitive or “paradoxical” answer: 23. This is much smaller than many people’s intuition, as there are 365 possible birthdays and 23 is much smaller than 365.

The reason for this surprising result is that, in a room of 23 people, there are pairs of people. Each pair of people has a chance of sharing a birthday, so the expected number of birthdays in a room of 23 people is . Since are 0.69 birthdays shared on average in a room of 23 people, it is perhaps less surprising that 23 is the critical number at which the chance of two people sharing a birthday exceeds 50%.

Hopefully, the similarity between the birthday problem and CountSketch is becoming clear. Each pair of indices and in CountSketch have a chance of being the same. There are pairs of indices, so the expected number of equal indices is . Thus, we should anticipate is required to ensure that are distinct with high probability.

Let’s calculate things out a bit more precisely. First, realize that

To compute the probability that are distinct, imagine introducing each one at a time. Assuming that are all distinct, the probability are distinct is just the probability that does not take any of the values . This probability is

Thus, by the chain rule for probability,

To bound this quantity, use the numeric inequality for every , obtaining

Thus, we conclude that

Solving this inequality, we conclude that

This is a quantitative version of our informal theorem from earlier.

# Does Sketching Work?

I’m excited to share that my paper, Fast and forward stable randomized algorithms for linear least-squares problems has been released as a preprint on arXiv.

With the release of this paper, now seemed like a great time to discuss a topic I’ve been wanting to write about for a while: sketching. For the past two decades, sketching has become a widely used algorithmic tool in matrix computations. Despite this long history, questions still seem to be lingering about whether sketching really works:

In this post, I want to take a critical look at the question “does sketching work”? Answering this question requires answering two basic questions:

1. What is sketching?
2. What would it mean for sketching to work?

I think a large part of the disagreement over the efficacy of sketching boils down to different answers to these questions. By considering different possible answers to these questions, I hope to provide a balanced perspective on the utility of sketching as an algorithmic primitive for solving linear algebra problems.

## Sketching

In matrix computations, sketching is really a synonym for (linear) dimensionality reduction. Suppose we are solving a problem involving one or more high-dimensional vectors or perhaps a tall matrix . A sketching matrix is a matrix where . When multiplied into a high-dimensional vector or tall matrix , the sketching matrix produces compressed or “sketched” versions and that are much smaller than the original vector and matrix .

Let be a collection of vectors. For to be a “good” sketching matrix for , we require that preserves the lengths of every vector in up to a distortion parameter :

(1)

for every in .

For linear algebra problems, we often want to sketch a matrix . In this case, the appropriate set that we want our sketch to be “good” for is the column space of the matrix , defined to be

Remarkably, there exist many sketching matrices that achieve distortion for with an output dimension of roughly . In particular, the sketching dimension is proportional to the number of columns of . This is pretty neat! We can design a single sketching matrix which preserves the lengths of all infinitely-many vectors in the column space of .

## Sketching Matrices

There are many types of sketching matrices, each with different benefits and drawbacks. Many sketching matrices are based on randomized constructions in the sense that entries of are chosen to be random numbers. Broadly, sketching matrices can be classified into two types:

• Data-dependent sketches. The sketching matrix is constructed to work for a specific set of input vectors .
• Oblivious sketches. The sketching matrix is designed to work for an arbitrary set of input vectors of a given size (i.e., has elements) or dimension ( is a -dimensional linear subspace).

We will only discuss oblivious sketching for this post. We will look at three types of sketching matrices: Gaussian embeddings, subsampled randomized trignometric transforms, and sparse sign embeddings.

The details of how these sketching matrices are built and their strengths and weaknesses can be a little bit technical. All three constructions are independent from the rest of this article and can be skipped on a first reading. The main point is that good sketching matrices exist and are fast to apply: Reducing to requires roughly operations, rather than the operations we would expect to multiply a matrix and a vector of length .1Here, is big O notation.

### Gaussian Embeddings

The simplest type of sketching matrix is obtained by (independently) setting every entry of to be a Gaussian random number with mean zero and variance . Such a sketching matrix is called a Gaussian embedding.2Here, embedding is a synonym for sketching matrix.

Benefits. Gaussian embeddings are simple to code up, requiring only a standard matrix product to apply to a vector or matrix . Gaussian embeddings admit a clean theoretical analysis, and their mathematical properties are well-understood.

Drawbacks. Computing for a Gaussian embedding costs operations, significantly slower than the other sketching matrices we will consider below. Additionally, generating and storing a Gaussian embedding can be computationally expensive.

### Subsampled Randomized Trigonometric Transforms

The subsampled randomized trigonometric transform (SRTT) sketching matrix takes a more complicated form. The sketching matrix is defined to be a scaled product of three matrices

These matrices have the following definitions:

• is a diagonal matrix whose entries are each a random (chosen independently with equal probability).
• is a fast trigonometric transform such as a fast discrete cosine transform.3One can also use the ordinary fast Fourier transform, but this results in a complex-valued sketch.
• is a selection matrix. To generate , let be a random subset of , selected without replacement. is defined to be a matrix for which for every vector .

To store on a computer, it is sufficient to store the diagonal entries of and the selected coordinates defining . Multiplication of against a vector should be carried out by applying each of the matrices , , and in sequence, such as in the following MATLAB code:

% Generate randomness for S
signs = 2*randi(2,m,1)-3; % diagonal entries of D
idx = randsample(m,d); % indices i_1,...,i_d defining R

% Multiply S against b
c = signs .* b % multiply by D
c = dct(c) % multiply by F
c = c(idx) % multiply by R
c = sqrt(n/d) * c % scale

Benefits. can be applied to a vector in operations, a significant improvement over the cost of a Gaussian embedding. The SRTT has the lowest memory and random number generation requirements of any of the three sketches we discuss in this post.

Drawbacks. Applying to a vector requires a good implementation of a fast trigonometric transform. Even with a high-quality trig transform, SRTTs can be significantly slower than sparse sign embeddings (defined below).4For an example, see Figure 2 in this paper. SRTTs are hard to parallelize.5Block SRTTs are more parallelizable, however. In theory, the sketching dimension should be chosen to be , larger than for a Gaussian sketch.

### Sparse Sign Embeddings

A sparse sign embedding takes the form

Here, each column is an independently generated random vector with exactly nonzero entries with random values in uniformly random positions. The result is a matrix with only nonzero entries. The parameter is often set to a small constant like in practice.6This recommendation comes from the following paper, and I’ve used this parameter setting successfully in my own work.

Benefits. By using a dedicated sparse matrix library, can be very fast to apply to a vector (either or operations) to apply to a vector, depending on parameter choices (see below). With a good sparse matrix library, sparse sign embeddings are often the fastest sketching matrix by a wide margin.

Drawbacks. To be fast, sparse sign embeddings requires a good sparse matrix library. They require generating and storing roughly random numbers, higher than SRTTs (roughly numbers) but much less than Gaussian embeddings ( numbers). In theory, the sketching dimension should be chosen to be and the sparsity should be set to ; the theoretically sanctioned sketching dimension (at least according to existing theory) is larger than for a Gaussian sketch. In practice, we can often get away with using and .

### Summary

Using either SRTTs or sparse maps, a sketching a vector of length down to dimensions requires only to operations. To apply a sketch to an entire matrix thus requires roughly operations. Therefore, sketching offers the promise of speeding up linear algebraic computations involving , which typically take operations.

## How Can You Use Sketching?

The simplest way to use sketching is to first apply the sketch to dimensionality-reduce all of your data and then apply a standard algorithm to solve the problem using the reduced data. This approach to using sketching is called sketch-and-solve.

As an example, let’s apply sketch-and-solve to the least-squares problem:

(2)

We assume this problem is highly overdetermined with having many more rows than columns .

To solve this problem with sketch-and-solve, generate a good sketching matrix for the set . Applying to our data and , we get a dimensionality-reduced least-squares problem

(3)

The solution is the sketch-and-solve solution to the least-squares problem, which we can use as an approximate solution to the original least-squares problem.

Least-squares is just one example of the sketch-and-solve paradigm. We can also use sketching to accelerate other algorithms. For instance, we could apply sketch-and-solve to clustering. To cluster data points , first apply sketching to obtain and then apply an out-of-the-box clustering algorithms like k-means to the sketched data points.

## Does Sketching Work?

Most often, when sketching critics say “sketching doesn’t work”, what they mean is “sketch-and-solve doesn’t work”.

To address this question in a more concrete setting, let’s go back to the least-squares problem (2). Let denote the optimal least-squares solution and let be the sketch-and-solve solution (3). Then, using the distortion condition (1), one can show that

If we use a sketching matrix with a distortion of , then this bound tells us that

(4)

Is this a good result or a bad result? Ultimately, it depends. In some applications, the quality of a putative least-squares solution is can be assessed from the residual norm . For such applications, the bound (4) ensures that is at most twice . Often, this means is a pretty decent approximate solution to the least-squares problem.

For other problems, the appropriate measure of accuracy is the so-called forward error , measuring how close is to . For these cases, it is possible that might be large even though the residuals are comparable (4).

Let’s see an example, using the MATLAB code from my paper:

[A, b, x, r] = random_ls_problem(1e4, 1e2, 1e8, 1e-4); % Random LS problem
S = sparsesign(4e2, 1e4, 8); % Sparse sign embedding
sketch_and_solve = (S*A) \ (S*b); % Sketch-and-solve
direct = A \ b; % MATLAB mldivide

Here, we generate a random least-squares problem of size 10,000 by 100 (with condition number and residual norm ). Then, we generate a sparse sign embedding of dimension (corresponding to a distortion of roughly ). Then, we compute the sketch-and-solve solution and, as reference, a “direct” solution by MATLAB’s \.

We compare the quality of the sketch-and-solve solution to the direct solution, using both the residual and forward error:

fprintf('Residuals: sketch-and-solve %.2e, direct %.2e, optimal %.2e\n',...
norm(b-A*sketch_and_solve), norm(b-A*direct), norm(r))
fprintf('Forward errors: sketch-and-solve %.2e, direct %.2e\n',...
norm(x-sketch_and_solve), norm(x-direct))

Here’s the output:

Residuals: sketch-and-solve 1.13e-04, direct 1.00e-04, optimal 1.00e-04
Forward errors: sketch-and-solve 1.06e+03, direct 8.08e-07

The sketch-and-solve solution has a residual norm of , close to direct method’s residual norm of . However, the forward error of sketch-and-solve is nine orders of magnitude larger than the direct method’s forward error of .

Does sketch-and-solve work? Ultimately, it’s a question of what kind of accuracy you need for your application. If a small-enough residual is all that’s needed, then sketch-and-solve is perfectly adequate. If small forward error is needed, sketch-and-solve can be quite bad.

One way sketch-and-solve can be improved is by increasing the sketching dimension and lowering the distortion . Unfortunately, improving the distortion of the sketch is expensive. Because of the relation , to decrease the distortion by a factor of ten requires increasing the sketching dimension by a factor of one hundred! Thus, sketch-and-solve is really only appropriate when a low degree of distortion is necessary.

## Iterative Sketching: Combining Sketching with Iteration

Sketch-and-solve is a fast way to get a low-accuracy solution to a least-squares problem. But it’s not the only way to use sketching for least-squares. One can also use sketching to obtain high-accuracy solutions by combining sketching with an iterative method.

There are many iterative methods for least-square problems. Iterative methods generate a sequence of approximate solutions that we hope will converge at a rapid rate to the true least-squares solution, .

To using sketching to solve least-squares problems iteratively, we can use the following observation:

If is a sketching matrix for , then .

Therefore, if we compute a QR factorization

then

Notice that we used the fact that since has orthonormal columns. The conclusion is that .

Let’s use the approximation to solve the least-squares problem iteratively. Start off with the normal equations7As I’ve described in a previous post, it’s generally inadvisable to solve least-squares problems using the normal equations. Here, we’re just using the normal equations as a conceptual tool to derive an algorithm for solving the least-squares problem.

(5)

We can obtain an approximate solution to the least-squares problem by replacing by in (5) and solving. The resulting solution is

This solution will typically not be a good solution to the least-squares problem (2), so we need to iterate. To do so, we’ll try and solve for the error . To derive an equation for the error, subtract from both sides of the normal equations (5), yielding

Now, to solve for the error, substitute for again and solve for , obtaining a new approximate solution :

We can now go another step: Derive an equation for the error , approximate , and obtain a new approximate solution . Continuing this process, we obtain an iteration

(6)

This iteration is known as the iterative sketching method.8The name iterative sketching is for historical reasons. Original versions of the procedure involved taking a fresh sketch at every iteration. Later, it was realized that a single sketch suffices, albeit with a slower convergence rate. Typically, only having to sketch and QR factorize once is worth the slower convergence rate. If the distortion is small enough, this method converges at an exponential rate, yielding a high-accuracy least squares solution after a few iterations.

Let’s apply iterative sketching to the example we considered above. We show the forward error of the sketch-and-solve and direct methods as horizontal dashed purple and red lines. Iterative sketching begins at roughly the forward error of sketch-and-solve, with the error decreasing at an exponential rate until it reaches that of the direct method over the course of fourteen iterations. For this problem, at least, iterative sketching gives high-accuracy solutions to the least-squares problem!

To summarize, we’ve now seen two very different ways of using sketching:

• Sketch-and-solve. Sketch the data and and solve the sketched least-squares problem (3). The resulting solution is cheap to obtain, but may have low accuracy.
• Iterative sketching. Sketch the matrix and obtain an approximation to . Use the approximation to produce a sequence of better-and-better least-squares solutions by the iteration (6). If we run for enough iterations , the accuracy of the iterative sketching solution can be quite high.

By combining sketching with more sophisticated iterative methods such as conjugate gradient and LSQR, we can get an even faster-converging least-squares algorithm, known as sketch-and-precondition. Here’s the same plot from above with sketch-and-precondition added; we see that sketch-and-precondition converges even faster than iterative sketching does!

“Does sketching work?” Even for a simple problem like least-squares, the answer is complicated:

A direct use of sketching (i.e., sketch-and-solve) leads to a fast, low-accuracy solution to least-squares problems. But sketching can achieve much higher accuracy for least-squares problems by combining sketching with an iterative method (iterative sketching and sketch-and-precondition).

We’ve focused on least-squares problems in this section, but these conclusions could hold more generally. If “sketching doesn’t work” in your application, maybe it would if it was combined with an iterative method.

## Just How Accurate Can Sketching Be?

We left our discussion of sketching-plus-iterative-methods in the previous section on a positive note, but there is one last lingering question that remains to be answered. We stated that iterative sketching (and sketch-and-precondition) converge at an exponential rate. But our computers store numbers to only so much precision; in practice, the accuracy of an iterative method has to saturate at some point.

An (iterative) least-squares solver is said to be forward stable if, when run for a sufficient number of iterations, the final accuracy is comparable to accuracy of a standard direct method for the least-squares problem like MATLAB’s \ command or Python’s scipy.linalg.lstsq. Forward stability is not about speed or rate of convergence but about the maximum achievable accuracy.

The stability of sketch-and-precondition was studied in a recent paper by Meier, Nakatsukasa, Townsend, and Webb. They demonstrated that, with the initial iterate , sketch-and-precondition is not forward stable. The maximum achievable accuracy was worse than standard solvers by orders of magnitude! Maybe sketching doesn’t work after all?

Fortunately, there is good news:

• The iterative sketching method is provably forward stable. This result is shown in my newly released paper; check it out if you’re interested!
• If we use the sketch-and-solve method as the initial iterate for sketch-and-precondition, then sketch-and-precondition appears to be forward stable in practice. No theoretical analysis supporting this finding is known at present.9For those interested, neither iterative sketching nor sketch-and-precondition are backward stable, which is a stronger stability guarantee than forward stability. Fortunately, forward stability is a perfectly adequate stability guarantee for many—but not all—applications.

These conclusions are pretty nuanced. To see what’s going, it can be helpful to look at a graph:10For another randomly generated least-squares problem of the same size with condition number and residual .

The performance of different methods can be summarized as follows: Sketch-and-solve can have very poor forward error. Sketch-and-precondition with the zero initialization is better, but still much worse than the direct method. Iterative sketching and sketch-and-precondition with fair much better, eventually achieving an accuracy comparable to the direct method.

Put more simply, appropriately implemented, sketching works after all!

## Conclusion

Sketching is a computational tool, just like the fast Fourier transform or the randomized SVD. Sketching can be used effectively to solve some problems. But, like any computational tool, sketching is not a silver bullet. Sketching allows you to dimensionality-reduce matrices and vectors, but it distorts them by an appreciable amount. Whether or not this distortion is something you can live with depends on your problem (how much accuracy do you need?) and how you use the sketch (sketch-and-solve or with an iterative method).

# Stochastic Trace Estimation

I am delighted to share that me, Joel A. Tropp, and Robert J. Webber‘s paper XTrace: Making the Most of Every Sample in Stochastic Trace Estimation has recently been released as a preprint on arXiv. In it, we consider the implicit trace estimation problem:

Implicit trace estimation problem: Given access to a square matrix via the matrix–vector product operation , estimate its trace .

Algorithms for this task have many uses such as log-determinant computations in machine learning, partition function calculations in statistical physics, and generalized cross validation for smoothing splines. I described another application to counting triangles in a large network in a previous blog post.

Our paper presents new trace estimators XTrace and XNysTrace which are highly efficient, producing accurate trace approximations using a small budget of matrix–vector products. In addition, these algorithms are fast to run and are supported by theoretical results which explain their excellent performance. I really hope that you will check out the paper to learn more about these estimators!

For the rest of this post, I’m going to talk about the most basic stochastic trace estimation algorithm, the GirardHutchinson estimator. This seemingly simple algorithm exhibits a number of nuances and forms the backbone for more sophisticated trace estimates such as Hutch++, Nyström++, XTrace, and XNysTrace. Toward the end, this blog post will be fairly mathematical, but I hope that the beginning will be fairly accessible to all.

## Girard–Hutchinson Estimator: The Basics

The GirardHutchinson estimator for the trace of a square matrix is

(1)

Here, are random vectors, usually chosen to be statistically independent, and denotes the conjugate transpose of a vector or matrix. The Girard–Hutchinson estimator only depends on the matrix through the matrix–vector products .

### Unbiasedness

Provided the random vectors are isotropic

(2)

the Girard–Hutchinson estimator is unbiased:

(3)

Let us confirm this claim in some detail. First, we use linearity of expectation to evaluate

(4)

Therefore, to prove that , it is sufficient to prove that for each .

When working with traces, there are two tricks that solve 90% of derivations. The first trick is that, if we view a number as a matrix, then a number equals its trace, . The second trick is the cyclic property: For a matrix and a matrix , we have . The cyclic property should be handled with care when one works with a product of three or more matrices. For instance, we have

However,

One should think of the matrix product as beads on a closed loop of string. One can move the last bead to the front of the other two, , but not interchange two beads, .

With this trick in hand, let’s return to proving that for every . Apply our two tricks:

The expectation is a linear operation and the matrix is non-random, so we can bring the expectation into the trace as

Invoke the isotropy condition (2) and conclude:

Plugging this into (4) confirms the unbiasedness claim (3).

### Variance

Continue to assume that the ‘s are isotropic (3) and now assume that are independent. By independence, the variance can be written as

Assuming that are identically distributed , we then get

The variance decreases like , which is characteristic of Monte Carlo-type algorithms. Since is unbiased (i.e, (3)), this means that the mean square error decays like so the average error (more precisely root-mean-square error) decays like

This type of convergence is very slow. If I want to decrease the error by a factor of , I must do the work!

Variance-reduced trace estimators like Hutch++ and our new trace estimator XTrace improve the rate of convergence substantially. Even in the worst case, Hutch++ and XTrace reduce the variance at a rate and (root-mean-square) error at rates :

For matrices with rapidly decreasing singular values, the variance and error can decrease much faster than this.

## Variance Formulas

As the rate of convergence for the Girard–Hutchinson estimator is so slow, it is imperative to pick a distribution on test vectors that makes the variance of the single–sample estimate as low as possible. In this section, we will provide several explicit formulas for the variance of the Girard–Hutchinson estimator. Derivations of these formulas will appear at the end of this post. These variance formulas help illuminate the benefits and drawbacks of different test vector distributions.

To express the formulas, we will need some notation. For a complex number we use and to denote the real and imaginary parts. The variance of a random complex number is

The Frobenius norm of a matrix is

If is real symmetric or complex Hermitian with (real) eigenvalues , we have

(5)

denotes the ordinary transpose of and denotes the conjugate transpose of .

### Real-Valued Test Vectors

We first focus on real-valued test vectors . Since is real, we can use the ordinary transpose rather than the conjugate transpose . Since is a number, it is equal to its own transpose:

Therefore,

The Girard–Hutchinson trace estimator applied to is the same as the Girard–Hutchinson estimator applied to the symmetric part of , .

For the following results, assume is symmetric, .

1. Real Gaussian: are independent standard normal random vectors.

2. Uniform signs (Rademachers): are independent random vectors with uniform coordinates.

3. Real sphere: Assume are uniformly distributed on the real sphere of radius : .

These formulas continue to hold for nonsymmetric by replacing by its symmetric part on the right-hand sides of these variance formulas.

### Complex-Valued Test Vectors

We now move our focus to complex-valued test vectors . As a rule of thumb, one should typically expect that the variance for complex-valued test vectors applied to a real symmetric matrix is about half the natural real counterpart—e.g., for complex Gaussians, you get about half the variance than with real Gaussians.

A square complex matrix has a Cartesian decomposition

where

denote the Hermitian and skew-Hermitian parts of . Similar to how the imaginary part of a complex number is real, the skew-Hermitian part of a complex matrix is Hermitian (and is skew-Hermitian). Since and are both Hermitian, we have

Consequently, the variance of can be broken into Hermitian and skew-Hermitian parts:

For this reason, we will state the variance formulas only for Hermitian , with the formula for general following from the Cartesian decomposition.

For the following results, assume is Hermitian, .

1. Complex Gaussian: are independent standard complex random vectors, i.e., each has iid entries distributed as for standard normal random variables.

2. Uniform phases (Steinhauses): are independent random vectors whose entries are uniform on the complex unit circle .

3. Complex sphere: Assume are uniformly distributed on the complex sphere of radius : .

## Optimality Properties

Let us finally address the question of what the best choice of test vectors is for the Girard–Hutchinson estimator. We will state two results with different restrictions on .

Our first result, due to Hutchinson, is valid for real symmetric matrices with real test vectors.

Optimality (independent test vectors with independent coordinates). If the test vectors are isotropic (2), independent from each other, and have independent entries, then for any fixed real symmetric matrix , the minimum variance for is obtained when are populated with random signs .

The next optimality results will have real and complex versions. To present the results for -valued and an -valued test vectors on unified footing, let denote either or . We let a -Hermitian matrix be either a real symmetric matrix (if ) or a complex Hermitian matrix (if ). Let a -unitary matrix be either a real orthogonal matrix (if ) or a complex unitary matrix (if ).

The condition that the vectors have independent entries is often too restrictive in practice. It rules out, for instance, the case of uniform vectors on the sphere. If we relax this condition, we get a different optimal distribution:

Optimality (independent test vectors). Consider any set of -Hermitian matrices which is invariant under -unitary similary transformations:

Assume that the test vectors are independent and isotropic (2). The worst-case variance is minimized by choosing uniformly on the -sphere: .

More simply, if you wants your stochastic trace estimator to be effective for a class of inputs (closed under -unitary similarity transformations) rather than a single input matrix , then the best distribution are test vectors drawn uniformly from the sphere. Examples of classes of matrices include:

• Fixed eigenvalues. For fixed real eigenvalues , the set of all -Hermitian matrices with these eigenvalues.
• Density matrices. The class of all trace-one psd matrices.
• Frobenius norm ball. The class of all -Hermitian matrices of Frobenius norm at most 1.

## Derivation of Formulas

In this section, we provide derivations of the variance formulas. I have chosen to focus on derivations which are shorter but use more advanced techniques rather than derivations which are longer but use fewer tricks.

### Real Gaussians

First assume is real. Since is real symmetric, has an eigenvalue decomposition , where is orthogonal and is a diagonal matrix reporting ‘s eigenvalues. Since the real Gaussian distribution is invariant under orthogonal transformations, has the same distribution as . Therefore,

Here, we used that the variance of a squared standard normal random variable is two.

For non-real matrix, we can break the matrix into its entrywise real and imaginary parts . Thus,

### Uniform Signs

First, compute

For a vector of uniform random signs, we have for every , so the second sum vanishes. Note that we have assumed symmetric, so the sum over can be replaced by two times the sum over :

Note that are pairwise independent. As a simple exercise, one can verify that the identity

holds for any pairwise independent family of random variances and numbers . Ergo,

In the second-to-last line, we use the fact that is a uniform random sign, which has variance . The final line is a consequence of the symmetry of .

### Uniform on the Real Sphere

The simplest proof is I know is by the “camel principle”. Here’s the story (a lightly edited quotation from MathOverflow):

A father left 17 camels to his three sons and, according to the will, the eldest son was to be given a half of the camels, the middle son one-third, and the youngest son the one-ninth. The sons did not know what to do since 17 is not evenly divisible into either two, three, or nine parts, but a wise man helped the sons: he added his own camel, the oldest son took camels, the second son took camels, the third son camels and the wise man took his own camel and went away.

We are interested in a vector which is uniform on the sphere of radius . Performing averages on the sphere is hard, so we add a camel to the problem by “upgrading” to a spherically symmetric vector which has a random length. We want to pick a distribution for which the computation is easy. Fortunately, we already know such a distribution, the Gaussian distribution, for which we already calculated .

The Gaussian vector and the uniform vector on the sphere are related by

where is the squared length of the Gaussian vector . In particular, has the distribution of the sum of squared Gaussian random variables, which is known as a random variable with degrees of freedom.

Now, we take the camel back. Compute the variance of using the chain rule for variance:

Here, and denote the conditional variance and conditional expectation with respect to the random variable . The quick and dirty ways of working with these are to treat the random variable “like a constant” with respect to the conditional variance and expectation.

Plugging in the formula and treating “like a constant”, we obtain

As we mentioned, is a random variable with degrees of freedom and and are known quantities that can be looked up:

We know and . Plugging these all in, we get

Rearranging, we obtain

### Complex Gaussians

The trick is the same as for real Gaussians. By invariance of complex Gaussian random vectors under unitary transformations, we can reduce to the case where is a diagonal matrix populated with eigenvalues . Then

Here, we use the fact that is a random variable with two degrees of freedom, which has variance four.

### Random Phases

The trick is the same as for uniform signs. A short calculation (remembering that is Hermitian and thus ) reveals that

The random variables are pairwise independent so we have

Since is uniformly distributed on the complex unit circle, we can assume without loss of generality that . Thus, letting be uniform on the complex unit circle,

The real and imaginary parts of have the same distribution so

so . Thus

### Uniform on the Complex Sphere: Derivation 1 by Reduction to Real Case

There are at least three simple ways of deriving this result: the camel trick, reduction to the real case, and Haar integration. Each of these techniques illustrates a trick that is useful in its own right beyond the context of trace estimation. Since we have already seen an example of the camel trick for the real sphere, I will present the other two derivations.

Let us begin with the reduction to the real case. Let and denote the real and imaginary parts of a vector or matrix, taken entrywise. The key insight is that if is a uniform random vector on the complex sphere of radius , then

We’ve converted the complex vector into a real vector .

Now, we need to convert the complex matrix into a real matrix . To do this, recall that one way of representing complex numbers is by matrices:

Using this correspondence addition and multiplication of complex numbers can be carried by addition and multiplication of the corresponding matrices.

To convert complex matrices to real matrices, we use a matrix-version of the same representation:

One can check that addition and multiplication of complex matrices can be carried out by addition and multiplication of the corresponding “realified” matrices, i.e.,

holds for all complex matrices and .

We’ve now converted complex matrix and vector into real matrix and vector . Let’s compare to . A short calculation reveals

Since is a uniform random vector on the sphere of radius , is a uniform random vector on the sphere of radius . Thus, by the variance formula for the real sphere, we get

A short calculation verifies that and . Plugging this in, we obtain

### Uniform on the Complex Sphere: Derivation 2 by Haar Integration

The proof by reduction to the real case requires some cumbersome calculations and requires that we have already computed the variance in the real case by some other means. The method of Haar integration is more slick, but it requires some pretty high-power machinery. Haar integration may be a little bit overkill for this problem, but this technique is worth learning as it can handle some truly nasty expected value computations that appear, for example, in quantum information.

We seek to compute

The first trick will be to write this expession using a single matrix trace using the tensor (Kronecker) product . For those unfamiliar with the tensor product, the main properties we will be using are

(6)

We saw in the proof of unbiasedness that

Therefore, by (6),

Thus, to evaluate , it will be sufficient to evaluate . Forunately, there is a useful formula for these expectation provided by a field of mathematics known as representation theory (see Lemma 1 in this paper):

Here, is the orthogonal projection onto the space of symmetric two-tensors . Therefore, we have that

To evalute the trace on the right-hand side of this equation, there is another formula (see Lemma 6 in this paper):

Therefore, we conclude

## Proof of Optimality Properties

In this section, we provide proofs of the two optimality properties.

### Optimality: Independent Vectors with Independent Coordinates

Assume is real and symmetric and suppose that is isotropic (2) with independent coordinates. The isotropy condition

implies that , where is the Kronecker symbol. Using this fact, we compute the second moment:

Thus

The variance is minimized by choosing with as small as possible. Since , the smallest possible value for is , which is obtained by populating with random signs.

### Optimality: Independent Vectors

This result appears to have first been proven by Richard Kueng in unpublished work. We use an argument suggested to me by Robert J. Webber.

Assume is a class of -Hermitian matrices closed under -unitary similarity transformations and that is an isotropic random vector (2). Decompose the test vector as

First, we shall show that the variance is reduced by replacing with a vector drawn uniformly from the sphere

(7)

where

(8)

Note that such a can be generated as for a uniformly random -unitary matrix . Therefore, we have

Now apply Jensen’s inequality only over the randomness in to obtain

Finally, note that since is closed under -unitary similarity transformations, the supremum over for is the same as the supremum of , so we obtain

We have successfully proven (7). This argument is a specialized version of a far more general result which appears as Proposition 4.1 in this paper.

Next, we shall prove

(9)

where is still defined as in (8). Indeed, using the chain rule for variance, we obtain

Here, we have used that is uniform on the sphere and thus . By definition, is the length of divided by . Therefore,

Therefore, by Jensen’s inequality,

Thus

which proves (9).

# The Vandermonde Decomposition

In this post, I want to discuss a beautiful and somewhat subtle matrix factorization known as the Vandermonde decomposition that appears frequently in signal processing and control theory. We’ll begin from the very basics, introducing the controls-and-signals context, how the Vandermonde decomposition comes about, and why it’s useful. By the end, I’ll briefly share how we can push the Vandermonde decomposition beyond matrices to the realm of tensors, which will can allow us to separate mixed signals from multiple measurements. This tensorial generalization plays an important role in my paper -decompositions, sparse component analysis, and the blind separation of sums of exponentials, joint work with Nithin Govindajaran and Lieven De Lathauwer, which recently appeared in the SIAM Journal of Matrix Analysis and Applications.

## Finding the Frequencies

Suppose I give you a short recording of a musical chord consisting of three notes. How could you determine which three notes they were? Mathematically, we can represent such a three-note chord as a combination of scaled and shifted cosine functions

(1)

We are interested in obtaining the (angular) frequencies , , and .

In the extreme limit, when we are given the values of the signal for all , both positive and negative, the frequencies are immediately given by taking a Fourier transform of the function . In practice, we only have access to the function at certain times which we assume are equally spaced

Given the samples

we could try to identify , , and using a discrete Fourier transform.1The discrete Fourier transform can be computed very quickly using the fast Fourier transform, as I discussed in a previous post. Unfortunately, this generally requires a large number of samples to identify , , and accurately. (The accuracy scales roughly like , where is the number of samples.) We are interested in finding a better way to identify the frequencies.

Now that we’ve moved from the function , defined for any real input , to a set of samples it will be helpful to rewrite our formula (1) for in a different way. By Euler’s identity, the cosines can be rewritten as

As a consequence, we can rewrite one of the frequency components in (1) as

Here, and are complex coefficients and which contain the same information as the original parameters and . Now notice that we are only interest in values which are multiples of the spacing . Thus, our frequency component can be further rewritten as

where and . Performing these reductions, our samples take the form

(2)

We’ve now reformulated our frequency problems in identifying the parameters and in the relation (2) from a small number of measurements .

## Frequency Finding as a Matrix Factorization

We will return to the algorithmic problem of identifying the parameters in the relation (2) from measurements in a little bit. First, we will see that (2) can actually be written as a matrix factorization. Understanding computations by matrix factorization has been an extremely successful paradigm in applied mathematics, and we will see in this post how viewing (2) as a matrix factorization can be very useful.

While it may seem odd at first,2As pointed out to me on math stack exchange, one reason forming the Hankel matrix is sensible is because it effectively augments the sequence of numbers into a sequence of vectors given by the columns of . This can reveal patterns in the sequence which are less obvious when it is represented as given just as numbers. For instance, any seven columns of are linearly dependent, a surprising fact since the columns of have length which can be much larger than seven. In addition, as we will soon effectively exploit later, vectors in the nullspace of (or related Hankel matrices derived from the sequence) give recurrence relations obeyed by the sequence. This speaks to a general phenomenon where properties of sequence (say, arising from snapshots of a dynamical system) can sometimes become more clear by this procedure of delay embedding. it will be illuminating to repackage the measurements as a matrix:

(3)

Here, we have assumed is odd. The matrix is known as the Hankel matrix associated with the sequence . Observe that the entry in position of depends only on the sum of the indices and , . (We use a zero-indexing system to label the rows and columns of where, for instance, the first row of is row .)

Let’s see how we can interpret the frequency decomposition (2) as a factorization of the Hankel matrix . We first write out using (2):

(4)

The power was just begging to be factorized as , which we did. Equation (4) almost looks like the formula for the product of two matrices with entries , so it makes sense to introduce the matrix with entry . This is a so-called Vandermonde matrix associated with and has the form

If we also introduce the diagonal matrix , the formula (4) for can be written as the matrix factorization3In the Vandermonde decomposition , the factor appears transposed even when is populated with complex numbers! This differs from the usual case in linear algebra where we use the conjugate transpose rather than the ordinary transpose when working with complex matrices. As a related issue, observe that if at least one of the measurements is a (non-real) complex number, the Hankel matrix is symmetric but not Hermitian.

(5)

This is the Vandermonde decomposition of the Hankel matrix , a factorization of as a product of the transpose of a Vandermonde matrix, a diagonal matrix, and that same Vandermonde matrix.

The Vandermonde decomposition immediately tells us all the information and describing our sampled recording via (2). Thus, the problem of determining and is equivalent to finding the Vandermonde decomposition (5) of the Hankel matrix .

## Computing the Vandermonde Decomposition: Prony’s Method

Computing the Vandermonde decomposition accurately can be a surprisingly hard task, particularly if the measurements are corrupted by even a small amount of measurement error. In view of this, I want to present a very classical way of computing this decomposition (dating back to 1795!) known as Prony’s method. This method is conceptually simple and will be a vehicle to continue exploring frequency finding and its connection with Hankel matrices. It remains in use, though it’s accuracy may be significantly worse compared to other methods.

As a first step to deriving Prony’s method, let’s reformulate the frequency finding problem in a different way. Sums of cosines like the ones in our expression (1) for the function often appear as the solution to a (linear) ordinary differential equation (ODE). This means that one way we could find the frequencies comprising would be to find a differential equation which satisfies. Together with the initial condition , determining all the frequencies would be very straightforward.

Since we only have access to samples of at regular time intervals, we will instead look for the “discrete-time” analog of a linear ODE, a linear recurrence relation. This is an expression of the form

(6)

In our case, we’ll have because there are six terms in the formula (2) for . Together with initial conditions , such a recurrence will allow us to determine the parameters and in our formula (2) for our sampled recordings and hence also allow us to compute the Vandermonde decomposition (5).

Observe that the recurrence (6) is a linear equation in the variables . A very good rule of thumb in applied mathematics is to always write down linear equations in matrix–vector notation in see how it looks. Doing this, we obtain

(7)

Observe that the matrix on the right-hand side of this equation is also a Hankel matrix (like in (3)) formed from the samples . Call this Hankel matrix . Unlike in (3), is rectangular. If is much larger than , will be tall, possessing many more rows than columns. We assume going forward.4 would also be fine for our purposes, but we assume to illustrate this highly typical case.

Let’s write (7) a little more compactly as

(8)

where we’ve introduced for the vector on the left-hand side of (7) and collected the recurrence coefficients into a vector . For a typical system of linear equations like (8), we would predict the system to have no solution : Because has more rows than columns (if ), the system equations (8) has more equations than unknowns. Fortunately, we are not in the typical case. Despite the fact that we have more equations than unknowns, the linear equations (8) have a unique solution .5This solution can be computed by solving the system of linear equations In particular, the matrix on the right-hand side of this equation is guaranteed to be nonsingular under our assumptions. Using the Vandermonde decomposition, can you see why? The existence of a unique solution is a consequence of the fact that the samples satisfy the formula (2). As a fun exercise, you might want to verify the existence of a unique satisfying (8)!

As a quick aside, if the measurements are corrupted by small measurement errors, then the equations (8) will usually not possess a solution. In this case, it would be appropriate to find the least squares solution to equation (8) as a way of mitigating these errors.

Hurrah! We’ve found the coefficients providing a recurrence relation (6) for our measurements . All that is left is to find the parameters and in our signal formula (2) and the Vandermonde decomposition (5). Fortunately, this is just a standard computation for linear recurrence relations, nicely paralleling the solution of (homogenous) linear ODEs by means of the so-called “characteristic equation”. I’ll go through fairly quickly since this material is well-explained elsewhere on the internet (like Wikipedia). Let’s guess that our recurrence (6) has a solution of the form ; we seek to find all complex numbers for which this is a bonafide solution. Plugging this solution into the formula (6) for gives

(9)

This is the so-called characteristic equation for the recurrence (6). As a single-variable polynomial equation of degree six, it has six complex solutions . These numbers are precisely those numbers which appear in the sequence formula (2) and the Vandermonde decomposition (5).

Finally, we need to compute the coefficients . But this is easy. Observe that the formula (2) provides the following system of linear equations for :

(10)

Again, this system of equations will have a unique solution if the measurements are uncorrupted by errors (and can be solved in the least squares sense if corrupted). This gives , completing our goal of computing the parameters in the formula (2) or, equivalently, finding the Vandermonde decomposition (5).

We have accomplished our goal of computing the Vandermonde decomposition. The approach by which we did so is known as Prony’s method, as mentioned in the introduction to this section. As suggested, this method may not always give high-accuracy results. There are two obvious culprits that jump out about why this is the case. Prony’s method requires solving for the roots of the polynomial equation (9) expressed “in the monomial basis” and solving a system of linear equations (10) with a (transposed) Vandermonde matrix. Both of these problems can be notoriously ill-conditioned and thus challenging to solve accurately and may require the measurements to be done to very high accuracy. Notwithstanding this, Prony’s method does useful results in some cases and forms the basis for potentially more accurate methods, such as those involving generalized eigenvalue problems.

## Separating Signals: Extending the Vandermonde Decomposition to Tensors

In our discussion of the frequency identification problem, the Vandermonde decomposition (5) has effectively been an equivalent way of showing the samples are a combination of exponentials . So far, the benefits of the matrix factorization perspective have yet to really reveal themselves.

So what are the benefits of the Vandermonde decompostions? A couple of nice observations related to the Vandermonde decomposition and the “Hankelization” of the signals have already been lurking in the background. For instance, the rank of the Hankel matrix is the number of frequency components needed to describe the samples and the representation of the samples as a mixture of exponentials is uniquely determined only if the matrix does not have full rank; I have a little more to say about this at the very end. There are also benefits to certain computational problems; one can use Vandermonde decompositions to compute super high accuracy singular value decompositions of Hankel matrices.

The power of the Vandermonde decomposition really starts to shine when we go beyond the basic frequency finding problem we discussed by introducing more signals. Suppose now there are three short recordings , , and . (Here, the superscript denotes an index rather than differentiation.) Each signal is a weighted mixture of three sources , , and , each of which plays a musical chord of three notes (thus representable as a sum of cosines as in (1)). One can think of the sources of being produced three different musical instruments at different places in a room and the recordings , , and being taken from different microphones in the room.6This scenario of instruments and microphones ignores the finite propagation speed of sound, which also would introduce time delays in the sources in the recorded signals. We effectively treat the speed of sound as being instantaneous. Our goal is now not just to identify the musical notes in the recordings but also to identify how to assign those notes to reconstruct the source signals , , and .

Taking inspiration from earlier, we record samples for each recording and form each collection of samples into a Hankel matrix

Here comes the crazy part: Stack the Hankelized recordings , , and as slices of a tensor . A tensor, in this context, just means a multidimensional array of numbers. Just as a vector is a one-dimensional array and a matrix is a two-dimensional array, a tensor could have any number of dimensions. In our case, we need just three. If we use a MATLAB-esque indexing notation, is a array given by

The remarkable thing is that the source signals can be determined (under appropriate conditions) by computing a special kind of Vandermonde decomposition of the tensor ! (Specifically, the required decomposition is a Vandermonde-structured -block term decomposition of the tensor .) Even more cool, this decomposition can be computed using general-purpose software like Tensorlab.

If this sounds interesting, I would encourage you to check out my recently published paper -decompositions, sparse component analysis, and the blind separation of sums of exponentials, joint work with Nithin Govindajaran and Lieven De Lathauwer and recently published in the SIAM Journal on Matrix Analysis and Applications. In the paper, we explain what this -decomposition is and how applying it to can be used to separate mixtures of exponentials signals from the resulting Vandermonde structure, an idea originating in the work of De Lathauewer. A very important question for these signal separation problems is that of uniqueness. Given the three sampled recordings (comprising the tensor ), is there just one way of unscrambling the mixtures into different sources or multiple? If there are multiple, then we might have possibly computed the wrong one. If there is just a single unscrambling, though, then we’ve done our job and unmixed the scrambled signals. The uniqueness of these tensor decompositions is fairly complicated math, and we survey existing results and prove new ones in this paper.7One of our main technical contributions is a new notion of uniqueness of -decompositions which we believe is nicely adapted to the signal separation context. Specfically, we prove mathematized versions of the statement “if the source signals are sufficiently different from each others and the measurements of sufficiently high quality, then the signals can uniquely be separated”.

## Conclusions, Loose Ends, and Extensions

The central idea that we’ve been discussing is how it can be useful to convert between a sequence of observations and a special matricization of this sequence into a Hankel matrix (either square, as in (3), or rectangular, as in (7)). By manipulating the Hankel matrix, say, by computing its Vandermonde decomposition (5), we learn something about the original signal, namely a representation of the form (2).

This is a powerful idea which appears implicitly or explicitly throughout various subfields of mathematics, engineering, and computation. As with many other useful ideas, this paradigm admits many natural generalizations and extensions. We saw one already in this post, where we extended the Vandermonde decomposition to the realm of tensors to solve signal separation problems. To end this post, I’ll place a few breadcrumbs at the beginning of a few of the trails of these generalizations for any curious to learn more, wrapping up a few loose ends on the way.

Is the Vandermonde Decomposition Unique?
A natural question is whether the Vandermonde decomposition (5) is unique. That is, is it possible that there exists two Vandermonde decompositions

of the same (square) Hankel matrix ? This is equivalent to whether the frequency components can be uniquely determined from the measurements .

Fortunately, the Vandermonde decomposition is unique if (and only if) the matrix is a rank-deficient matrix. Let’s unpack this a little bit. (For those who could use a refresher on rank, I have a blog post on precisely this topic.) Note that the Vandermonde decomposition is a rank factorization8Rank factorizations are sometimes referred to as “rank-revealing factorizations”. I discuss my dispreference for this term in my blog post on low-rank matrices. since has rows, has full (row) rank, and is invertible. This means that if take enough samples of a function which is a (finite) combinations of exponentials, the matrix will be rank-deficient and the Vandermonde decomposition unique.9The uniqueness of the Vandermonde decomposition can be proven by showing that, in our construction by Prony’s method, the ‘s, ‘s, and ‘s are all uniquely determined. If too few samples are taken, then does not contain enough information to determine the frequency components of the signal and thus the Vandermonde decomposition is non-unique.

Does Every Hankel Matrix Have a Vandermonde Decomposition?
This post has exclusively focused on a situation where we are provided with sequence we know to be represented as a mixture of exponentials (i.e., taking the form (2)) from which the existence of the Vandermonde decomposition (5) follows immediately. What if we didn’t know this were the case, and we were just given a (square) Hankel matrix . Is guaranteed to possess a Vandermonde decomposition of the form (5)?

Unfortunately, the answer is no; there exist Hankel matrices which do not possess a Vandermonde decomposition. The issue is related to the fact that the appropriate characteristic equation (analogous to (9)) might possess repeated roots, making the solutions to the recurrence (6) not just take the form but also and perhaps , , etc.

Are There Cases When the Vandermonde Decomposition is Guaranteed To Exist?
There is one natural case when a (square) Hankel matrix is guaranteed to possess a Vandermonde decomposition, namely when the matrix is nonsingular/invertible/full-rank. Despite this being a widely circulated fact, I am unaware of a simple proof for why this is the case. Unfortunately, there is not just one but infinitely many Vandermonde decompositions for a nonsingular Hankel matrix, suggesting these decompositions are not useful for the frequency finding problem that motivated this post.
What If My Hankel Matrix Does Not Possess a Vandermonde Decomposition?
As discussed above, a Hankel matrix may fail to have a Vandermonde decomposition if the characteristic equation (a la (9)) has repeated roots. This is very much analogous to the case of a non-diagonalizable matrix for which the characteristic polynomial has repeated roots. In this case, while diagonalization is not possible, one can “almost-diagonalize” the matrix by reducing it to its Jordan normal form. In total analogy, every Hankel matrix can be “almost Vandermonde decomposed” into a confluent Vandermonde decomposition (a discovery that appears to have been made independently several times). I will leave these links to discuss the exact nature of this decomposition, though I warn any potential reader that these resources introduce the decomposition first for Hankel matrices with infinitely many rows and columns before considering the finite case as we have. One is warned that while the Vandermonde decomposition is always a rank decomposition, the confluent Vandermonde decomposition is not guaranteed to be one.10Rather, the confluent Vandermonde decomposition is a rank decomposition for an infinite extension of a finite Hankel matrix. Consider the Hankel matrix This matrix has rank-two but no rank-two confluent Vandermonde decomposition. The issue is that when extended to an infinite Hankel matrix this (infinite!) matrix has a rank exceeding the size of the original Hankel matrix .
The Toeplitz Vandermonde Decomposition
Just as it proved useful to arrange samples into a Hankel matrix, it can also be useful to form them into a Toeplitz matrix

The Toeplitz matrix has the appealing propery that the matrix–vector product computes a (discrete) convolution of the sampled signal with the sampled signal which has all sorts of uses in signal processing and related fields.11I discuss Toeplitz matrices and a fast algorithm to compute the product using the fast Fourier transform more in a blog post I wrote about the subject.

One can interconvert between Hankel and Toeplitz matrices by reversing the order of the rows. As such, to the extent to which Hankel matrices possess Vandermonde decompositions (with all the asterisks and fine print just discussed), Toeplitz matrices do as well but with the rows of the first factor reversed:

There is a special and important case where more is true. If a Toeplitz matrix is (Hermitian) positive semidefinite, then always possesses a Vandermonde decomposition of the form

where is a Vandermonde matrix associated with parameters which are complex numbers of absolute value one and is a diagonal matrix with real positive entries.12The keen-eyed reader will note that appears conjugate transposed in this formula rather than transposed as in the Hankel Vandermonde decomposition (5). This Vandermonde decomposition is unique if and only if is rank-deficient. Positive semidefinite Toeplitz matrices are important as they occur as autocorrelation matrices which effectively describe the similarity between a signal and different shifts of itself in time. Autocorrelation matrices appear under different names in everything from signal processing to random processes to near-term quantum algorithms (a topic near and dear to my heart). A delightfully simple and linear algebraic derivation of this result is given by Yang and Xie (see Theorem 1).13Unfortunately, Yang and Xie incorrectly claim that every Toeplitz matrix possesses a rank factorization Vandermonde decomposition of the form where is a Vandermonde matrix populated with entries on the unit circle and is a diagonal matrix of possibly *complex* entries. This claim is disproven by the example . This decomposition can be generalized to infinite positive semidefinite Toeplitz matrices (appropriately defined).14Specifically, one can show that an infinite positive semidefinite Toeplitz matrix (appropriately defined) also has a “Vandermonde decomposition” (appropriately defined). This result is often known as Herglotz’s theorem and is generalized by the Bochner–Weil theorem.

# Minimal Rank Completions

I’m delighted to share that my first applied mathematics paper, Minimal Rank Completions for Overlapping Blocks, coauthored with Nithin Govindarajan and Shivkumar Chandrasekaran, has been accepted for publication in Linear Algebra and its Applications. (We also have a preprint on arXiv.) In this post, I wanted to share what our paper is about and share an alternate derivation which ended up being cut from the final paper.

Our paper is concerned with the following question: given a collection of matrices which overlap in a particular way, can we choose the region of simultaneous overlap so as to minimize the rank of each of the individual matrices? This is a multi-objective optimization problem, so a priori it is not clear it has a simultaneous solution. So it was of great surprise to us when we discovered that it does. In fact, we were able to find a tractable algorithm to find all solutions to this multi-objective problem.

Our enormous thanks go to the anonymous reviewer, who went above and beyond by discovering and sketching to us a dramatically shorter and more revealing proof1In particular, our original proof only produced some solutions to this problem, where the reviewer’s improved proof strategy allowed us to characterize all solutions. of our main theorem. We are truly indebted to this extraordinary reviewer for the significantly streamlined and more understandable presentation in the current iteration of our paper.

For the remainder of this post, I want to discuss minimal rank completions in a little more generality and present a solution to a special case of a minimal rank completion problem which can be tractably solved. I will present a solution to this problem we discovered which I have not seen elsewhere in the literature. I hope that this perspective will be complementary to existing solutions to this problem published in the literature including the summary of this result in our paper.

## Minimal Rank Completion Problems

Minimal rank completions have achieved a lot of buzz in statistics and data science. Given a matrix with unknown entries, it is often very natural to impute the missing entries as those minimizing the rank of the matrix. This is justified by a kind of Occam’s razor argument: big data matrices are very often (approximately) low-rank, so when data is missing, we may assume it takes whatever values are necessary to minimize the rank.

Alternately, if the missing entries belong to a special pattern, it may be possible to find the rank-minimizing choice of the unknown entries using linear algebraic tools like matrix factorizations. These approaches have significantly more limited domains of applicability than optimization-based approaches, but have advantages in that they

• can be more tractable as they involve matrix factorizations rather than solving optimization problems;
• work over arbitrary fields of numbers, such as finite fields appearing in computer science;
• can find all ways of choosing the entries to minimize the rank, in particular certifying or dis-certifying the uniqueness of the rank-minimizing choice; and
• are guaranteed to find the rank-minimizer, without any statistical assumptions.

These algebraic methods have their roots in systems theory, integral operators, and rank-structured matrices. The last of these was the application which motivated our interest in the subject.

Our paper concerns an overlapping variant of this problem, where we simultaneously minimize the ranks of several matrices by choosing the entries in the overlap carefully. This problem emerged to us naturally in the construction of certain matrix representations, and we hope it might prove useful in tackling other problems. As it turns out, the overlapping problem can be solved very much in the spirit of a much simpler problem, the block minimal rank completion problem, which we will spend most of the remainder of this post discussing.

## A Solution to the Block 2×2 Case

The block minimal rank completion problem is as follows: given a partially filled block matrix

(1)

how can the “?” be filled in to minimize the rank of this matrix?

A generalized version of this problem was originally solved by Kaashoek and Woerdeman. An alternate derivation using matrix factorizations is given by Eidelman, Gohberg, and Haimovici, though they only find some of the solutions to this problem. We seek to characterize all ways of choosing the “?” so that the rank is minimize the rank.

Here, I present the solution to this problem which my coauthors and I originally discovered, which is different than the one we summarize in the final version of our paper.2This construction does appear in Section 4 of an initial preprint of ours on rank-structured matrices. This solution is in the spirit of the one by Eidelman, Gohberg, and Haimovici but does produce all solutions.

Let’s start by recalling some facts about linear algebra. Given an real3The analysis in this discussion holds over any field, but we shall use the real numbers for concreteness. matrix , one can define its column space, which I will denote , to be the vector space consist of all linear combinations of the columns of . From this column space, or indeed any vector subspace of , one can extract a basis for this subspace, meaning every vector in the subspace can be uniquely decomposed as a linear combination of elements from the basis. In this discussion, we shall always arrange the basis vectors as columns of a basis matrix . If we instead consider the row space of , then we arrange the elements of a basis as rows of a matrix .

Before we solve the problem, let’s reason about the lowest possible rank we could possibly expect for the completed matrix. Since the rank of a matrix can be no smaller than the rank of any of its submatrices, clearly we must have that, for any assignment of the “?”,

(2)

However, in general, the rank of the completed matrix must be higher than , as is exemplified when and are both zero but is not. In addition to rank of , we must also account for rows of which cannot be written as linear combinations of the rows above, no matter how is chosen. With a little noodling, one can convince oneself that there are always at least such rows, leading to the bound

(3)

We shall show that, by judicious choice of , Eq. (3) can always be achieved with equality, making the minimal rank for this completion problem.

Let us now find such a rank-minimizing . The construction begins by considering the column spaces and of the matrices and . The intersection of these column spaces is again a vector subspace, and we choose a basis for it. The subspace might have a smaller size than . Therefore, to find a basis for , we can extend the basis by adding new columns to it so that the enlarged matrix forms a basis for . Similarly, we can find new columns to add to so that the matrix forms a basis for .

Now comes something subtle. Since forms a basis for , every column in can be written as a linear combination of columns in . In matrix language, this means there exists a matrix such that —in fact, this exact forms a basis for . Since is divided into two collections of columns, it is only natural to similarly (and conformally) divide into two pieces as . Thus, doing the same with as we did with , we obtain two matrix factorizations

(4)

Now we do the same song and dance with the row spaces of and . Let’s go through the construction somewhat quickly. We start with a basis for the intersection of . We then extend these to bases and for and . From here, we derive the existence of matrix factorizations analogous to Eq. (4):

(5)

For the next part, we shall take advantage of a powerful fact: if I have a bases and for the row and column spaces of a matrix , there exists a nonsingular matrix for which . Applying this fact to the bases and for ‘s column and row spaces, we get the existence of a matrix such that

(6)

We now have all ingredients to describe the solution. Rather than trying to “derive” the solution in a rigorous way, let us try and discover the solution in a non-rigorous way and justify our work later. We’re hoping to find assignments of the “?” such that achieves the minimum possible rank defined in Eq. (3). To do so, let’s try and find a rank factorization of the completed matrix and then infer what values will take. First off, let’s build a rank factorization for using the building blocks we’ve already built

(7)

Now we want to extend this to a rank factorization for the entire completed matrix. Let’s build up to this in stages, denoting by entries whose value we have yet to determine. For us to have a hope of representing the matrix , we’ll need to somehow add into our rank factorization. Doing exactly this, we get the partially specified rank factorization

(8)

Now, to fill in the second block row of the left factor, we recall that . From Eqs. (5) and (6), we deduce that . Thus, we can fill in more entries:

(9)

With these entries filled in, the remaining ‘s can be chosen arbitrarily. Assigning names and to these free variables, we conclude that

(10)

and

(11)

From all the analysis previous, we know that all ‘s of the form Eq. (11) solve the minimal rank completion problem, making the completed matrix achieve the minimal rank defined in Eq. (3). With a little more elbow grease, one can also confirm that all such minimal completions are of the form Eq. (11), proving that Eq. (11) indeed characterizes all solutions to the minimal rank completion problem. This completes the characterization and construction of the complete set of minimizers to the block minimal rank completion problem.

## The Overlapping Block Minimal Rank Completion Problem

If you found this post interesting, be sure to check out our paper (or here on arXiv) for an explanation of a different way of thinking about the solution of the block minimal rank completion problem and a solution to a more general “overlapping” variant. The treatment should be reasonably self-contained, and we hope the solution to this problem could prove a useful tool in tackling open problems in systems theory and the study of rank-structured matrices.