Ewin Tang

Some open problems

Tue, 22 Apr 2025 00:00:00 +0000

At last year’s FOCS I participated in a workshop on quantum learning, which included an open problem session. Here are the open problems I contributed. Check out the complete list for more, including the more “classic” problems in the field (e.g. entanglement testing, shadow tomography).

The questions here are mathematically precise, but I don’t have ideas for how to prove them. David Aldous would call these “Type 2” problems. For clarity, I won’t explain the mathematical formalism of Hamiltonians, etc, but the glossary at the bottom of this page will contain precise versions of the terms I’m using.

Why work on quantum learning?

When I say quantum learning here, I mean questions in the following vein: we have an unknown quantum system. How can I run experiments on this quantum system to learn its behavior efficiently?

There are a bunch of standard motivations for these questions which I’ve explained in more detail in my papers: (1) it can be used in practice (even, potentially, in the near-term); (2) it’s closely connected to basic questions about correlations in quantum systems; (3) it naturally generalizes various landmark results in classical learning theory. But beyond this, I think this field is natural and important, given the philosophical perspectives informing the development of quantum computing. These perspectives are famous in physics (see More is different and The theory of everything) but I personally only learned about them recently, and they strongly inform my thinking about the topic now.

The biggest successes in physics are in reducing the phenomena of everyday objects down to fundamental laws governing their constituent particles. To understand the behavior of a system, we can isolate a small piece, run experiments on the small-scale, and extrapolate the findings out to the large-scale behavior. The example of interest to us is non-relativistic quantum mechanics, which is a theory of most things (notable exceptions being light and gravity). There’s plenty of things that this theory explains, and by our current understanding, a few equations is enough to explain them fully.

But this “reductionist” perspective is insufficient: with quantum mechanics, we understand the fundamental particles, and yet, when you put many of these particles together to form a material, a chemical reaction, or a person, we lose understanding of their behavior. The issue here is that, extrapolating the behavior of particles to systems of many particles can be very hard. This is especially true for quantum mechanics, because it has an inherent exponentiality to its mathematical formalism.

With quantum computers, we want to build a bridge between the two. One barrier (perhaps the barrier) to understanding large quantum systems is computational intractability: simulating them from the laws of quantum mechanics is intractable. Using quantum computers, simulation can be done efficiently, and we can actually use our small-scale understanding for large systems.

Quantum learning poses the same philosophical question from another perspective. If we have a large system that we’d like to understand, experiments to characterize it can become intractable, even though we know how to run experiments to characterize small-scale systems. There are practical reasons why big quantum systems are hard to wrangle, but even supposing we had perfect quantum control over our systems, extracting information about these systems could conceivably be inherently intractable, for the same reason that simulation is hard. Quantum learning asks whether we can relate the large-scale and the small-scale for experiments, by making these experiments computationally efficient.

That some kind of quantum learning works is paramount to the success of quantum computing as a program: after all, what is the point of working with large quantum systems if we do not have ways to extract insights from them? I do think there’s room to disagree on whether the current directions are the right ones towards the goal of, say, making scientific progress. Nevertheless, I hope the questions which I’m suggesting to you now are natural enough to stay true to the spirit of the program, while still producing ideas that can be specialized to practically relevant settings.

1. Learning ground states in polynomial time

A striking phenomenon in learning theory is that, even for “hard” mathematical objects, learning can be a surprisingly easy task. Our dream is that quantum computers can help scientists who work with quantum systems, and the main computational task that such scientists struggle with is simulating ground states. For a Hamiltonian \(H\), its ground state is its largest eigenvector \(\ket{\Psi}\). Simulation is known to be hard in the worst case, even on a quantum computer, so if we want efficient algorithms, we must find a way to weave through these computational barriers to find practical advantage.

The dual task to simulating ground states is learning ground states. Unlike for simulation, for learning, there are no barriers: we can hope for algorithms which always just work.

Question. Given copies of a ground state \(\ket{\Psi}\) of a geometrically local, \(n\)-qubit Hamiltonian \(H\), can we output a geometrically local Hamiltonian \(\widehat{H}\) whose ground state is close to \(\ket{\Psi}\), in polynomial time? (For this question, you might need the additional assumption that \(H\) is gapped.)

Many Hamiltonians can have the same ground state, so the problems is phrased to allow for this non-uniqueness. The classical version of this problem is trivial (given a \(b \in \{0,1\}^n\) which is the best assignment for an unknown CSP, find a CSP for which it is the best solution), but in the quantum world, with non-commuting terms, things get much harder.

What’s known? Getting polynomial sample complexity is straightforward: see this paper of Yu and Wei, for example, though it also follows from generic shadow tomography. These algorithms have exponential time complexity, though.

There are also heuristic algorithms in the physics literature, under the keyword of parent Hamiltonians. These work for simple classes of Hamiltonians, like commuting and (I think even) frustration-free, but not general gapped Hamiltonians. We (Ainesh Bakshi, Allen Liu, Ankur Moitra, and I) had ideas for this general case but none gave a polynomial-time algorithm. This question seems connected to the question of area laws, but my bet is that this question doesn’t require making progress on that topic.

2. Does amplitude amplification require inverses?

One of the first quantum algorithms you learn is Grover’s algorithm, along with the closely-related algorithms of amplitude amplification and estimation. These give a quadratic improvement for various kinds of search and estimation tasks.

For example, to estimate the size of an entry of a unitary matrix, \(\left|\braket{0|U|0}\right|^2\), to \(\varepsilon\) error with probability \(0.99\), the naive approach of:

Initialize to \(\ket{0}\);
Apply \(U\);
Measure in the computational basis;
Repeat.

gives an \(\varepsilon\)-good estimate after \(O(1/\varepsilon^2)\) trials, applying \(U\) that many times. But with amplitude estimation, you only need \(O(1/\varepsilon)\) applications of \(U\) and \(U^\dagger\) to estimate the size of the entry.

However, this improvement requires the ability to apply the inverse, \(U^\dagger\). This is a typical feature of these Grover-ish methods. It’s often not a big deal, since in many applications \(U\) is a circuit which can be straightforwardly inverted. But what if \(U\) is a unitary that Nature applies, and we can’t reverse the arrow of time? Do we need the ability to apply \(U^\dagger\)? Or can we get away with just applications of \(U\)?

Question. Can we prove that amplitude amplification/estimation cannot be done as efficiently when we only have access to \(U\)?

What’s known? This question was previously posed in this paper of van Apeldoorn, Cornelissen, Gilyén, and Nannicini, but it seems natural enough that it’s probably been posed even earlier. The main challenge here is that standard lower bound techniques are not able to distinguish \(U\) from \(U^\dagger\), and so cannot separate the inverse-ful and inverse-less access models.

Note that, by this paper of Quintino, Dong, Shimbo, Soeda, and Murao, it is possible to convert \(d^3\) uses of \(U\) to one use of \(U^\dagger\), so when \(d\) is small, amplitude amplification/estimation can be done without \(U^\dagger\). However, this conversion from \(U^\dagger\) to \(U\) becomes extremely expensive as \(d\) grows. So, there may still be a separation between the two settings in the regime where \(d\) is sufficiently large.

3. Lower bounds for Hamiltonian learning

The next two open problems deal with Hamiltonian learning from real-time evolutions. The standard setup (see e.g. [HTFS23] and [HKT22] ) is as follows. Let \(H = \sum_{a = 1}^m \lambda_a E_a\) be an \(n\)-qubit \(k\)-local (but not necessarily geometrically local) Hamiltonian, where we are told the \(E_a\)’s but do not know the \(\lambda_a\)’s.

We are given the ability to perform the channel \(\rho \mapsto e^{-iHt} \rho e^{iHt}\) for all \(t > 0\), and we want to learn a specified coefficient \(\lambda_a\) to \(\varepsilon\) error (with success probability \(\geq 0.99\), say). For such a learning algorithm we consider its total time evolution, i.e. the amount of evolution time of \(H\) used over the course of the algorithm.

We know how to solve this problem with \(m/\varepsilon\) total evolution time (note that \(m = \operatorname{poly}(n)\)), and when the Hamiltonian has some underlying geometric locality, we can exploit that to get an algorithm with mild-to-no dependence on the system size, something like \(\operatorname{log}(n)/\varepsilon\).

It makes physical sense that assuming geometric locality would effectively remove the dependence on system size. If we think about evolving with respect to a local Hamiltonian, at infinitesimal times, the effect of the particular \(\lambda_aE_a\) term we’re interested only affects the support of \(E_a\), so most of the \(n\) qubits play no role. But at infinitesimal times, we cannot learn the coefficient, since the effect size is similarly infinitesimal. On the other hand, at larger times, the effect of \(\lambda_a E_a\) is large, but we expect this effect to be “scrambled” across all \(n\) qubits. So, to extract out this information we’d need to pay a system size-type cost to “unscramble” it. If the Hamiltonian is geometrically local, then the “scrambling” only happens in a ball around the support of \(E_a\), and so to learn a coefficient you only have to understand that ball, which is independent of system size.

This intuitive argument is not easy to formalize. So, we can ask, is the cost of Hamiltonian learning actually intrinsically linked to geometric locality? I would find such a result interesting, because real-time evolutions are a very strong form of access to \(H\); it’s not obvious to me that you really need geometric locality with such a strong form of access. The simplest version of this question is as follows:

Question. Does learning local (but not necessarily geometrically local) Hamiltonians require a total time evolution of \(\operatorname{poly}(n)\)?

What’s known? This question has been posed previously here and here. We know very little (embarrassingly little, imo) about lower bounds for Hamiltonian learning. The best lower bound is \(1/\varepsilon\), which follows from a simple “hybrid” argument: perturbing a coefficient by \(\varepsilon\) only affects the algorithm by \(O(\varepsilon T)\) where \(T\) is the total evolution time, so \(T\) has to be large enough to detect this difference.

The task of proving stronger lower bounds has been tackled by papers of Huang, Tong, Fang, and Su and Ma, Flammia, Preskill, and Tong. Neither give improved lower bounds on the problem stated here.

4. Learning Hamiltonians from long time evolutions

This problem also has to do with Hamiltonian learning from real-time evolution; see the previous open problem for the setup.

The literature on this question has gone in two different directions: on the one hand, you can ask for algorithms giving stronger guarantees; on the other, you can ask for algorithms with weaker assumptions on, or weaker access to, the input. This open question is in the latter category: it’s an interesting setting where we have less control in our access model and where, to my knowledge, no technique in the literature comes close to working.

Question. Let \(H\) be a geometrically local Hamiltonian, and suppose we are only given the ability to perform the channel \(\rho \mapsto e^{-iHt} \rho e^{iHt}\) for all \(t > 100\). Can we still do Hamiltonian learning with a total time evolution of \(\operatorname{poly}(n/\varepsilon)\)? How about \(O(1/\varepsilon)\)?

As discussed in the previous open problem, there’s a sense in which long time evolutions “scramble” the information we wish to learn. Mathematically, this translates to the relevant objects becoming more difficult to handle: local observables become non-local, power series converge slower, and sometimes they don’t converge at all. There’s an additional technical challenge related to identifiability: for a sufficiently large constant \(t\), \(e^{-iHt} = e^{-iGt}\) does not imply that \(H = G\).

What’s known? We (Ainesh Bakshi, Allen Liu, Ankur Moitra, and I) posed this question in our paper, but I don’t think we’re the first to pose this question. In that paper, we showed that Hamiltonian learning with total evolution time \(1/\varepsilon\) and time resolution \(\Theta(1)\) is possible, but the \(\Theta(1)\) is a small constant.

Glossary

A Hamiltonian on \(n\) qubits is a Hermitian matrix \(H \in \mathbb{C}^{2^n \times 2^n}\). We typically imagine this matrix being specified as a linear combination of terms \(E_a \in \mathbb{C}^{2^n \times 2^n}\) with coefficients \(\lambda_a \in \mathbb{R}\). In other words,

\[H = \sum_{a=1}^m \lambda_a E_a.\]

We call a Hamiltonian \(k\)-local if every \(E_a\) is supported on at most \(k\) qubits. Throughout, we additionally impose the constraint that \(E_a\) is a tensor product of Pauli matrices, like \(\sigma_X \otimes \sigma_Z \otimes I \otimes \dots \otimes I\). This can be done without loss of generality (though note that this blows up the number of terms for non-local \(H\)), and it’s important to specify some kind of basis like this so that we can make a sensible definition for what “learning” the Hamiltonian means.

For normalization, we also assume that \(-1 \leq \lambda_a \leq 1\) for all \(a = 1,\dots,m\).

We call our Hamiltonian geometrically local if there is some additional ‘geometric’ structure to the terms that appear; the strongest version of this assumption is that we imagine the \(n\) qubits are nodes on a lattice (represented by a graph \(G = ([n], E)\)); and every term \(E_a\) has a support \(\operatorname{supp}(E_a)\) with diameter at most \(\Delta\).

A Hamiltonian is gapped if its largest eigenvalue and second largest eigenvalue differ by at least (say) a constant.

For these open problems, we imagine that these parameters \(k\) (and \(\Delta\) if we assume geometric locality) are constant, say 2.

Accessible TeX colors

Sun, 12 Jan 2025 00:00:00 +0000

Summary: Instead of using \textcolor{red}, green, and blue, use purple, teal, and blue. Want more colors? Use \usepackage{ninecolors}.

Which default LaTeX colors are readable?

The set of LaTeX default colors are chosen primarily to be a mathematically clean subsample of the RGB space. For example, red, green, and blue are just #FF0000, #00FF00, and #0000FF—the codes look nice, but the actual colors have drastically different brightnesses ■■■. This leads to some unintuitive behavior, like \textcolor{green} making text pretty unreadable. (See this example?)

I wanted to find some simple-to-state advice for what to use instead, so I went through the list of default colors and checked which met the web standard for being readable against a white page. (See the tables at the bottom for more specifics, and additional data for dvipsnames colors.)

6 meet this standard for use as text color against a white background: blue, purple, teal, violet, black, and darkgray. Note that red is not on this list! I think this makes sense: I often see default red in papers, but it is bright to the point that it slightly hurts readability, at least for me. (See this example?)

So, in short, you only wanted to use default colors, purple, teal, and blue would serve as good replacements for a red, green, and blue.

Other color advice

Here’s some other general strategies I use to pick colors for talks/papers.

ninecolors package

In 2021, the ninecolors TeX package was released. It defines reasonable defaults for color choices (for example, here are their colors red4, green4, and blue4), and I’ve used it for papers ever since. Recommend.

Steal colors from data visualization software

If I need more than one color, I often just copy existing sets of colors from matplotlib, Tableau, Excel. They’ve already done all of the hard work of making colors look nice together while also making colors maximally distinguishable, even for colorblind viewers. This sort of software also often has excellent documentation about how to use colors in plots and things.

Don’t steal color schemes from text editors

Once, I gave a talk using the solarized dark theme, and then someone later told me that the slides were very hard to read. Since then, I’ve heard other people make this exact mistake as well. And I think it’s quite a bad mistake: even if everyone can technically make out the text on the slides if they try, once someone in the back starts daydreaming, you will not get them back unless your slide is immediately legible at a glance.

Coding color schemes are often designed to have less contrast between light and dark. This means that they’re harder to read. And for talk slides in particular, you want your text to be easily readable, even for those sitting in the back, and for those with weaker eyesight. (And I think generally “light mode” is preferred over “dark mode”, since the former projects better across various lighting conditions.)

Don’t rely on color too much

As a final comment on accessibility, I want to point out the guideline that no crucial information should be communicated solely through color. I highlight important things with colors all the time. But I try to follow the guideline that, if my document was printed in grayscale, someone could still understand it.

Appendix: methodology and data

There’s accessibility guidelines for how large the contrast of text needs to be against its background. It’s designed for the web, but since pdfs are typically viewed on screens, I used it as the standard.

What these guidelines give is a formula to measure the relative luminance of the two colors, and then measure the relative contrast between them. If the contrast is above 4.5 to 1, it meets the minimum bar for being used for body text.

There are 19 default LaTeX colors. I used a color checker to check the contrast.

color	hex code	contrast ratio
red	FF0000 ■	3.99
green	00FF00 ■	1.37
blue	0000FF ■	8.59
brown	C08040 ■	3.27
lime	C0FF00 ■	1.19
orange	FF8000 ■	2.51
pink	FFC0C0 ■	1.54
purple	C00040 ■	6.33
teal	008080 ■	4.77
violet	800080 ■	9.41
cyan	00FFFF ■	1.25
magenta	FF00FF ■	3.13
yellow	FFFF00 ■	3.99
olive	808000 ■	4.19
black	000000 ■	21
darkgray	404040 ■	10.36
gray	808080 ■	3.94
lightgray	C0C0C0 ■	1.81
white	FFFFFF ■	1

And here are the colors named by dvips, sorted by contrast.

color	hex code	contrast ratio
White	FFFFFF ■	1
Yellow	FFF200 ■	1.16
Goldenrod	FFDF42 ■	1.32
GreenYellow	DFE674 ■	1.33
SpringGreen	C6DC67 ■	1.51
Dandelion	FDBC42 ■	1.68
Apricot	FBB982 ■	1.69
YellowGreen	98CC70 ■	1.87
Lavender	F49EC4 ■	1.99
LimeGreen	8DC73E ■	2.02
SkyBlue	46C5DD ■	2.04
YellowOrange	FAA21A ■	2.04
Melon	F89E7B ■	2.06
Peach	F7965A ■	2.21
Salmon	F69289 ■	2.23
BurntOrange	F7921D ■	2.31
Tan	DA9D76 ■	2.31
SeaGreen	3FBC9D ■	2.36
CarnationPink	F282B4 ■	2.43
CornflowerBlue	41B0E4 ■	2.45
ProcessBlue	00B0F0 ■	2.47
Turquoise	00B4CE ■	2.49
Aquamarine	00B5BE ■	2.51
Cyan	00AEEF ■	2.52
BlueGreen	00B3B8 ■	2.57
Orange	F58137 ■	2.59
Thistle	D883B7 ■	2.67
TealBlue	00AEB3 ■	2.72
Cerulean	00A2E3 ■	2.88
Emerald	00A99D ■	2.93
JungleGreen	00A99A ■	2.94
Gray	949698 ■	2.96
Green	00A64F ■	3.19
VioletRed	EF58A0 ■	3.19
RedOrange	F26035 ■	3.23
Rhodamine	EF559F ■	3.24
Orchid	AF72B0 ■	3.58
ForestGreen	009B55 ■	3.6
WildStrawberry	EE2967 ■	4.07
Periwinkle	7977B8 ■	4.08
Magenta	EC008C ■	4.24
PineGreen	008B72 ■	4.25
RubineRed	ED017D ■	4.28
OrangeRed	ED135A ■	4.33
Red	ED1B23 ■	4.39
CadetBlue	74729A ■	4.54
Bittersweet	C04F17 ■	4.8
OliveGreen	3C8031 ■	4.85
DarkOrchid	A4538A ■	5.02
RoyalBlue	0071BC ■	5.13
NavyBlue	006EB8 ■	5.35
Mulberry	A93C93 ■	5.59
Purple	99479B ■	5.63
BrickRed	B6321C ■	6.06
MidnightBlue	006795 ■	6.22
Maroon	AF3235 ■	6.3
Mahogany	A9341F ■	6.56
RawSienna	974006 ■	6.88
Fuchsia	8C368C ■	6.95
RedViolet	A1246B ■	7.04
Plum	92268F ■	7.25
RoyalPurple	613F99 ■	7.83
Violet	58429B ■	7.87
BlueViolet	473992 ■	9.25
Brown	792500 ■	10.1
Blue	2D2F92 ■	10.86
Sepia	671800 ■	12.29
Black	221E1F ■	16.48

Bolded are the ones that meet the contrast guidelines against a white background. Overall, the colors that remain are pretty unsatisfying: for example, there’s only one green. This is why I was so happy to see the ninecolors package when it came out; it is much more usable as a set of colors than any other package I am familiar with.

Some settings supporting efficient state preparation

Thu, 13 Jun 2019 00:00:00 +0000

\[\gdef\BB#1{\mathbb{#1}} \gdef\eps\varepsilon \gdef\ket#1{|#1\rangle} \gdef\bra#1{\langle#1|}\]

I wrote most of this list to procrastinate on the flight back from TQC (which was great!). So, for my own reference: here’s some settings where efficient state preparation / data loading is possible, and classical versions of these protocols. Notes:

There might be errors, especially in details of the quantum protocols, and some of the algorithms may be suboptimal (note the streaming setting, in particular). Let me know if you notice either of these.
Some relevant complexity research here is in QSampling (Section 4).
All these runtimes should have an extra \(O(\log n)\) factor, since we assume that indices and entries take \(\log n\) bits/qubits to specify. However, I’m going to follow the convention from classical computing and ignore these factors, hopefully with little resulting confusion.

For all that follows, we are given \(v \in \mathbb{C}^n\) in some way and want to output

for the quantum case, a copy of the state \(\ket{v} = \sum_{i=1}^n \frac{v_i}{\|v\|} \ket{i}\), and
for the classical case, the pair \((i,v_i)\) output with probability \(\frac{\vert v_i\vert^2}{\|v\|^2}\).

You could think about this as strong quantum simulation of state preparation protocols.

type	sparse	uniform	integrable	QRAM	streamed
quantum	\(O(s)\)	\(O(C\log\frac1\delta)\)	\(O(I \log n)\)	\(O(\log n)\) depth	\(O(1)\) space with 2 passes
classical	\(O(s)\)	\(O(C^2\log\frac1\delta)\)	\(O(I\log n)\)	\(O(\log n)\)	\(O(1)\) space with 1 pass

Recall that if we want to prepare an arbitrary quantum state, we need at least \(\Omega(\sqrt{n})\) time by search lower bounds, so for some settings of the above constants, these protocols are exponentially faster than the naive strategy. Further recall that state preparation and sampling both have easy protocols running in \(O(n)\) time.

\(v\) is sparse

We assume that \(v\) has at most \(s\) nonzero entries and we can access a list of the nonzero entries \(((i_1,v_{i_1}),(i_2,v_{i_2}),\ldots,(i_s,v_{i_s}))\). Thus, we have the oracle \(a \to (i_a, v_{i_a})\).

We can prepare the quantum state and classical sample by preparing the vector \(v' \in \BB{C}^s\) where \(v_a' = v_{i_a}\), and then using the oracle to swap out the index \(a\) with \(i_a\). This gives \(O(s)\) classical and quantum time.

\(v\) is close-to-uniform

We assume that \(\max\vert v_i\vert \leq C\frac{\|v\|}{\sqrt{n}}\) and we know \(C, \|v\|\). Notice that we don’t give a lower bound on the size of entries, but we can’t have too many small entries, since this would lower the norm. Also notice that \(C \geq 1\).

Quantumly, given the typical oracle \(\ket{i}\ket{0} \to \ket{i}\ket{v_i}\) we can prepare the state

\[\frac{1}{\sqrt{n}}\sum_{i=1}^n \ket{i}\Big(\frac{v_i\sqrt{n}}{\|v\|C}\ket{0} + \sqrt{1-\frac{\vert v_i\vert ^2n}{\|v\|^2C^2}}\ket{1}\Big).\]

Measuring the ancilla and post-selecting on 0 gives \(\ket{v}\). This happens with probability \(\frac{1}{C^2}\), and with amplitude amplification this means we can get a copy of the state with probability \(\geq 1-\delta\) in \(O(C\log\frac1\delta)\) time.

Classically, we perform rejection sampling from the uniform distribution: pick an index uniformly at random, and keep it with probability \(\frac{v_i^2n}{\|v\|^2C^2}\); otherwise, restart. This outputs the correct distribution and gives a sample in \(O(C^2\log\frac1\delta)\) time.

\(v\) is efficiently integrable

We assume that, given \(1 \leq a \leq b \leq n\), I can compute \(\sqrt{\sum_{i=a}^b |v_i|^2}\) in \(O(I)\) time. This assumption and the resulting quantum preparation routine comes from Grover-Rudolph.

The quantum algorithm uses one core subroutine: adding an extra qubit, sending \(\ket{v^{(k)}} \to \ket{v^{(k+1)}}\), where

\[\ket{v^{(k)}} := \sum_{b \in \{0,1\}^k} \ket{b}\sqrt{\sum_{i=b\cdot 0^{n-k}}^{b\cdot 1^{n-k}} |v_i|^2}\]

All that’s necessary is to apply it \(O(\log n)\) times and add the phase at the end. I haven’t worked it out, but I think you can run the subroutine efficiently using three calls to the integration oracle, giving \(O(I\log n)\) time.

Classically, we can do essentially the same thing: the integration oracle means that we can compute marginal probabilities; that is,

\[\Pr_{s \sim v}[s\text{'s bit representation starts with } b] = \sum_{i=b\cdot 0^{n-k}}^{b\cdot 1^{n-k}} |v_i|^2\]

Thus, we can sample from the distribution on the first bit, then sample from the distribution on the second bit conditioned on our value of the first bit, and so on. This also gives \(O(I\log n)\) time.

\(v\) is stored in a dynamic data structure

We assume that our vector can be stored in a data structure that supports efficient updating of entries. Namely, we use the standard binary search tree data structure (see, for example, Section 2.2.2 of Prakash’s thesis). This is a simple data structure with many nice properties, including \(O(\log n)\) time updates. If you want to prepare many states corresponding to similar vectors, this is a good option.

There’s not much more to say, since the protocol is the same as the integrability protocol. The only difference is that, instead of assuming that we can compute interval sums efficiently, we instead precompute and store all of the integration oracle calls we need for the state preparation procedure in a data structure.

The classical runtime is \(O(\log n)\), and the quantum circuit takes \(O(n)\) gates but only \(O(\log n)\) depth. The quantum algorithm is larger because here, we need to query a linear number of memory cells, as opposed to the integrabilility assumption, where we only needed to run the integration oracle in superposition.

While it may seem that the classical algorithm wins definitively here, the small depth leaves potential for this protocol to run in \(O(\log n)\) time in practice, matching the classical algorithm.

\(v\) is streamed

We assume that we can receive a stream of the entries of \(v\) in order; we wish to produce a state/sample using as little space as possible.

Classically, we can do this with reservoir sampling. The idea is that we maintain a sample \((s, v_s)\) from all of the entries we’ve seen before, along with their squared norm \(\lambda = \sum_{i=1}^k \vert v_i\vert^2\). Then, when we receive a new entry \(v_{k+1}\), we swap our sample to \((k+1,v_{k+1})\) with probability \(\vert v_{k+1}\vert^2/(\lambda + \vert v_{k+1}\vert^2)\) and update our \(\lambda\) to \(\lambda + \vert v_{k+1}\vert^2\). After we go through all of \(v\)’s entries, we get a sample only using \(O(1)\) space. (This is a particularly nice algorithm for sampling from a vector, since it has good locality and can be generalized to get \(O(k)\) samples in \(O(k)\) space and one pass.)

Quantumly, I only know how to prepare a state in one pass with sublinear space if the norm is known. If you know \(\|v\|\), then you can prepare \(\ket{n}\), and as entries come in, rotate to get \(\frac{v_1}{\|v\|}\ket{1} + \sqrt{1-\frac{|v_1|^2}{\|v\|^2}}\ket{n}\), then \(\frac{v_1}{\|v\|}\ket{1} + \frac{v_2}{\|v\|}\ket{2} + \sqrt{1-\frac{|v_1|^2+|v_2|^2}{\|v\|^2}}\ket{n}\), and so on. This uses only \(O(\log n)\) qubits, which I notate here as \(O(1)\) space.

You can relax this assumption to just having an estimate \(\lambda\) of \(\|v\|\) such that \(\frac{1}{\text{poly}(n)} \leq \lambda/\|v\| \leq \text{poly}(n)\). Finally, if you like, you can remove the assumption that you know the norm just by requiring two passes instead of one; in the first pass, compute the norm, and in the second pass, prepare the state. But it’d be nice to remove the assumption entirely.

So, is it possible to prepare a quantum state corresponding to a generic \(v \in \BB{C}^n\), given only one pass through it? Thanks to Chunhao Wang and Nai-Hui Chia for telling me about this problem.

An overview of quantum-inspired classical sampling

Mon, 28 Jan 2019 00:00:00 +0000

\[\gdef\SC#1{\mathcal{#1}} %katex \gdef\BB#1{\mathbb{#1}} \gdef\eps\varepsilon \gdef\SQ{\operatorname{SQ}} \gdef\Q{\operatorname{Q}} \gdef\Tr{\operatorname{Tr}} \gdef\ket#1{\left|#1\right\rangle} \gdef\bra#1{\left\langle#1\right|} \gdef\poly{\operatorname{poly}} \gdef\polylog{\operatorname{polylog}} %\newcommand{\SC}[1]{\mathcal{#1}} %mathjax %\newcommand{\BB}[1]{\mathbb{#1}} %\newcommand{\eps}{\varepsilon} %\newcommand{\SQ}{\operatorname{SQ}} %\newcommand{\Q}{\operatorname{Q}} %\newcommand{\Tr}{\operatorname{Tr}} %\newcommand{\ket}[1]{\left|#1\right\rangle} %\newcommand{\bra}[1]{\left\langle#1\right|} %\newcommand{\poly}{\operatorname{poly}} %\newcommand{\polylog}{\operatorname{polylog}}\]

Update [2020-08-26]: The way I present this topic in this blog post is not exactly how I present it now. See my STOC 2020 talk for a more recent version. The differences are pretty minor: results are more general and there are fewer hidden caveats. If you’re up for a somewhat technical talk, check it out!

This is an adaptation of a talk I gave at Microsoft Research in November 2018.

I exposit the \(\ell^2\) sampling techniques used in my recommendation systems work and its follow-ups in dequantized machine learning:

Tang – A quantum-inspired algorithm for recommendation systems
Tang – Quantum-inspired classical algorithms for principal component analysis and supervised clustering;
Gilyén, Lloyd, Tang – Quantum-inspired low-rank stochastic regression with logarithmic dependence on the dimension;
Chia, Lin, Wang – Quantum-inspired sublinear classical algorithms for solving low-rank linear systems.

The core ideas used are super simple. This goal of this blog post is to break down these ideas into intuition relevant for quantum researchers and create more understanding of this machine learning paradigm.

Notation is defined in the Glossary.

The intended audience is researchers comfortable with probability and linear algebra (SVD, in particular). Basic quantum knowledge helps with intuition, but is not essential: everything from The model onward is purely classical. The appendix is optional and explains the dequantized techniques in more detail.

An introduction to dequantization

Motivation

The best, most sought-after quantum algorithms are those that take in raw, classical input and give some classical output. For example, Shor’s algorithm for factoring takes this form. These classical-to-classical algorithms (a term I invented for this post) have the best chance to be efficiently implemented in practice: all you need is a scalable quantum computer. (It’s just that easy!)

Nevertheless, many quantum algorithms aren’t so nice. Most well-known QML algorithms convert input quantum states to a desired output state or value. Thus, they do not provide a routine to get necessary copies of these input states (a state preparation routine) and a strategy to extract information from an output state. Both are essential to making the algorithm useful.

An example of an algorithm that is not classical-to-classical is the swap test. If we have many copies of the quantum states \(\ket{a},\ket{b} \in \BB{C}^n\), then the swap test \(\SC{S}\) estimates their inner product in time polylogarithmic in dimension. While this routine seems much faster than naively computing \(\sum_{i=1}^n \bar{a}_ib_i\) classically, we can only run this algorithm if we know how to prepare the states \(\ket{a}\) and \(\ket{b}\). It may well be the case that state preparation is too expensive for input vectors, making the quantum algorithm as slow as the classical algorithm. This illustrates the format and failings of most QML algorithms.

You might then ask: can we fill in the missing routines in QML algorithms to get a classical-to-classical algorithm that’s provably fast and useful? This is an open research problem: see Scott Aaronson’s piece on QML¹. We have a variety of partial results towards the affirmative, but as far as I know, they don’t answer the question unless you’re loose with your definitions of at least one of “classical”, “provably fast”, or “useful”. So let’s settle for a simpler question.

How can we compare the speed of quantum algorithms with quantum input and quantum output to classical algorithms with classical input and classical output? Quantum machine learning algorithms can be exponentially faster than the best standard classical algorithms for similar tasks, but this comparison is unfair because the quantum algorithms get outside help through input state preparation. We want a classical model that helps its algorithms stand a chance against quantum algorithms, while still ensuring that they can be run in nearly all circumstances one would run the quantum algorithm. The answer I propose: compare quantum algorithms with quantum state preparation to classical algorithms with sample and query access to input.

The model

Before we proceed with definitions, we’ll establish some conventions. First, we generally consider our input as being some vector in \(\BB{C}^n\) or \(\BB{R}^n\), subject to an access model to be described. Second, we’ll only concern ourselves with an algorithm’s query complexity, the number of accesses to the input. Our algorithms will have query complexity independent of input dimensions and polynomial in other parameters. If we assume that each access costs (say) \(O(1)\) or \(O(\log n)\), the time complexity is still polylogarithmic in input dimension and at most polynomially worse in other parameters.

Now, we define query access to input; we can get query access simply by having the input in RAM.

Definition. We have query access to \(x \in \BB{C}^n\) (denoted \(\Q(x)\)) if, given \(i \in [n]\), we can efficiently compute \(x_i\).

If we have \(x\) stored normally as an array in our classical computer’s memory, we have \(\Q(x)\) because finding the \(i\)th entry of \(x\) can be done with the code x[i]. This notion of access can represent more than just memory: we can also have \(\Q(x)\) if \(x\) is implicitly described. For example, consider \(x\) the vector of squares: \(x_i = i^2\) for all \(i\). We can have access to \(x\) without writing \(x\) in memory. This will be important for the algorithms to come.

Definition. We have sample and query access to \(x \in \BB{C}^n\) (denoted \(\SQ(x)\)) if we have query access to \(x\); can produce independent random samples \(i \in [n]\) where we sample \(i\) with probability \(|x_i|^2/\|x\|^2\); and can query for \(\|x\|\).

Sampling and query access to \(x\) will be our classical analogue to assuming quantum state preparation of copies of \(\ket{x}\). This should make some intuitive sense: our classical analogue \(\SQ(x)\) has the standard assumption of query access to input, along with samples, which are essentially measurements of \(\ket{x}\) in the computational basis. Knowledge of \(\|x\|\) is for normalization issues, and is often assumed for quantum algorithms as well (though for both classical and quantum algorithms, often approximate knowledge suffices).

Example. Like query access, we can get efficient sample and query access from an explicit memory structure. To get \(\SQ(x)\) for a bit vector \(x \in \{0,1\}^n\), store the number of nonzero entries \(z\) and a sorted array of the 1-indices \(D\). For example, we could store \(x = [1\;1\;0\;0\;1\;0\;0\;0]\) as

\[z, D = 3,\{1,2,5\}\]

Then we can find \(x_i\) by checking if \(i \in D\), we can sample from \(x\) by picking an index from \(D\) uniformly at random, and we know \(\|x\|\), since it’s just \(\sqrt{z}\). This generalizes to an efficient \(O(\log n)\) binary search tree data structure for \(\SQ(x)\) for any \(x \in \BB{C}^n\).

We can also define sample and query access to matrices as just sample and query access to vectors “in” the matrix.

Definition. For \(A \in \BB{C}^{m\times n}\), \(\SQ(A)\) is defined as \(\SQ(A_i)\) for \(A_i\) the rows of \(A\), along with \(\SQ(\tilde{A})\) for \(\tilde{A}\) the vector of row norms (so \(\tilde{A}_i = \|A_i\|\)).

By replacing quantum states with these classical analogues, we form a model based on sample and query access which we codify with the informal definition of “dequantization”.

Definition. Let \(\SC{A}\) be a quantum algorithm with input \(\ket{\phi_1},\ldots,\ket{\phi_C}\) and output either a state \(\ket{\psi}\) or a value \(\lambda\). We say we dequantize \(\SC{A}\) if we describe a classical algorithm that, given \(\SQ(\phi_1),\ldots,\SQ(\phi_C)\), can evaluate queries to \(\SQ(\psi)\) or output \(\lambda\), with similar guarantees to \(\SC{A}\) and query complexity \(\poly(C)\).

That is, given sample and query access to the inputs, we can output sample and query access to a desired vector or a desired value, with at most polynomially larger query complexity.

We justify why this model is a reasonable point of comparison two sections from now, in Implications. Next, though, we will jump into how to build these dequantized protocols.

Quantum for the quantum-less

So far, all dequantized results revolve around three dequantized protocols that we piece together into more useful tasks. In query complexity independent of \(m\) and \(n\), we can perform the following:

(Inner Product) For \(x,y \in \BB{C}^n\), given \(\SQ(x)\) and \(\Q(y)\), we can estimate \(\langle x,y\rangle\) to \(\|x\|\|y\|\eps\) error with probability \(\geq 1-\delta\) and \(\text{poly}(\frac1\eps, \log\frac1\delta)\) queries;
(Thin Matrix-Vector) For \(V \in \BB{C}^{n\times k}, w \in \BB{C}^k\), given \(\SQ(V^\dagger)\) and \(\Q(w)\), we can simulate \(\SQ(Vw)\) with \(\text{poly}(k)\) queries;
(Low-rank Approximation) For \(A \in \BB{C}^{m\times n}\), given \(\SQ(A)\), a threshold \(k\), and an error parameter \(\eps\), we can output a description of a low-rank approximation of \(A\) with \(\text{poly}(k, \frac{1}{\eps})\) queries.

Specifically, our output is \(\SQ(S,\hat{U},\hat{\Sigma})\) for \(S \in \BB{C}^{\ell \times n}\), \(\hat{U} \in \BB{C}^{\ell \times k}\), and \(\hat{\Sigma} \in \BB{C}^{k\times k}\) (\(\ell = \poly(k,\frac{1}{\eps})\)), and this implicitly describes the low-rank approximation to \(A\), \(D := A(S^\dagger\hat{U}\hat{\Sigma}^{-1})(S^\dagger\hat{U}\hat{\Sigma}^{-1})^\dagger\) (notice rank \(D \leq k\)).

This matrix satisfies the following low-rank guarantee with probability \(\geq 1-\delta\): for \(\sigma := \sqrt{2/k}\|A\|_F\), and \(A_{\sigma} := \sum_{\sigma_i \geq \sigma} \sigma_iu_iv_i^\dagger\) (using \(A\)’s SVD),
\[\|A - D\|_F^2 \leq \|A - A_\sigma\|_F^2 + \eps^2\|A\|_F^2.\]
This guarantee is non-standard: instead of \(A_k\), we use \(A_\sigma\). This makes our promise weaker, since it is useless if \(A\) has no large singular values.

For intuition, it’s helpful to think of \(D\) as \(A\) multiplied with a “projector” \((S^\dagger\hat{U}\hat{\Sigma}^{-1})(S^\dagger\hat{U}\hat{\Sigma}^{-1})^\dagger\) that projects the rows of \(A\) onto the columns of \(S^\dagger\hat{U}\hat{\Sigma}^{-1}\), where these columns are “singular vectors” with corresponding “singular values” \(\hat{\sigma}_1,\ldots,\hat{\sigma}_k\) that are encoded in the diagonal matrix \(\hat{\Sigma}\). (For those interested, \(\hat{U}\) and \(\hat{\Sigma}\) are from the SVD of a submatrix of \(A\), hence the evocative notation; see the appendix for more details.)

The first two protocols are dequantized swap tests and the third is essentially a dequantized variant of phase estimation seen in quantum recommendation systems².

Now, we describe how these techniques are used to get the results for recommendation systems, supervised clustering, and low-rank matrix inversion. We defer the important details of models and error analyses to Implications, instead focusing on the algorithms themselves and how they use dequantized protocols.

Supervised clustering

We want to find the distance from a point \(p \in \BB{R}^n\) to the centroid (average) of a cluster of points \(q_1,\ldots,q_{m-1} \in \BB{R}^{n}\). If we assume sample and query access to the data points, computing \(\|p - \frac{1}{m-1}(q_1 + \cdots + q_{m-1})\|\) reduces to computing \(\|Mw\|\) for

\[M = \begin{bmatrix} \frac{p}{\|p\|} & \frac{q_1}{\|q_1\|} & \cdots & \frac{q_{m-1}}{\|q_{m-1}\|} \end{bmatrix} \qquad w = \begin{bmatrix} \|p\| \\ -\frac{\|q_1\|}{m-1} \\ \vdots \\ -\frac{\|q_{m-1}\|}{m-1} \end{bmatrix}.\]

\(\SQ\) access to \(p,q_1,\ldots,q_{m-1}\) gives \(\SQ\) access to \(M^T\) and \(w\) so the supervised clustering problem reduces to the following:

Problem. For \(M \in \BB{R}^{m\times n}, w \in \BB{R}^n\), and \(\SQ(M^T,w)\), approximate \((Mw)^T(Mw)\) to additive \(\eps\) error.

Algorithm. We can write \((Mw)^TMw\) as the inner product of an order three tensor; through basic tensor arithmetic, it is equal to \(\langle u, v\rangle\), where \(u,v \in \BB{R}^{m\times n\times n}\) are

\[\begin{aligned} u &= \sum_{i=1}^m\sum_{j=1}^n\sum_{k=1}^n M_{ij}\|M^{(k)}\| e_{i,j,k} \text{ and} \\ v &= \sum_{i=1}^m\sum_{j=1}^n\sum_{k=1}^n \frac{w_jw_kM_{ik}}{\|M^{(k)}\|} e_{i,j,k}. \end{aligned}\]

Applying the algorithm for inner product (1) gives the desired approximation with \(O(\|w\|^2\|M\|_F^2\frac{1}{\eps^2} \log\frac{1}{\delta})\) samples and queries.

Recommendation systems

We want to randomly sample a product \(j \in [n]\) that is a good recommendation for a particular user \(i \in [m]\), given incomplete data on user-product preferences. If we store this data in a matrix \(A \in \BB{R}^{m\times n}\) with sampling and query access, in the right model, finding good recommendations reduces to:

Problem. For a matrix \(A \in \BB{R}^{m\times n}\) along with a row \(i \in [m]\), given \(\SQ(A)\), approximately sample from \(D_i\) where \(D\) is a sufficiently good low-rank approximation of \(A\).

Remark. This task is essentially a variant of PCA, since a low-rank decomposition is dimensionality reduction of the matrix, viewed as a set of row vectors. This is the “dequantized PCA” I refer to in other work³.

Algorithm. Apply (3) to get \(\SQ(S,\hat{U},\hat{\Sigma})\) for a low-rank approximation \(D = AS^T \hat{U}\hat{\Sigma}^{-1}(\hat{\Sigma}^{-1})^T\hat{U}^T S\). It turns out that this low-rank approximation is good enough to get good recommendations. So it suffices to sample from \(D_i = A_iS^TMS\), where \(A_i \in \BB{R}^{1 \times n}, S \in \BB{R}^{\ell \times n}, M = \hat{U}\hat{\Sigma}^{-1}(\hat{\Sigma}^{-1})^T\hat{U}^T \in \BB{R}^{\ell \times \ell}\) with \(\ell = \poly(k)\).

\[\begin{bmatrix} \; \cdots & A_i & \cdots \; \end{bmatrix} \begin{bmatrix} & \vdots & \\ & S^T & \\ & \vdots & \end{bmatrix} \begin{bmatrix} & & \\ & M & \\ & & \end{bmatrix} \begin{bmatrix} & & \\ \; \cdots & S & \cdots \; \\ & & \end{bmatrix}\]

Approximate \(A_iS^T\) to \(\ell^2\) norm using \(k\) inner product protocols (1). Next, compute \(A_iS^TM\) with naive matrix-vector multiplication. Finally, sample from \(A_iS^T\hat{U}\hat{U}^TS\), which is a thin matrix-vector product (2).

An aside. This gives an exponential speedup over previous classical results from 15-20 years ago⁴. The story here is quite odd. From what I can tell, researchers at the time knew the important (read: hard) part of the algorithm, how to compute low-rank approximations fast, but didn’t notice that the resulting knowledge of \(S\) and \(\hat{U}\) could be used to sample the desired recommendations in sublinear time, which I think is much easier to understand. This gave me anxiety during research, since I figured there was no way this would have been overlooked. I’m glad these fears were unfounded; it’s cool that this quantum perspective made this step natural and obvious!

Low-rank matrix inversion

The goal here is to mimic a quantum algorithm that can solve systems of equations \(Ax = b\) for \(A\) low-rank. The dequantized version of this is:

Problem. For a low-rank matrix \(A \in \BB{R}^{m\times n}\) and a vector \(b \in \BB{R}^n\), given \(\SQ(A), \SQ(b)\), (approximately) respond to requests for \(\SQ(A^+b)\), where \(A^+\) is the pseudoinverse of \(A\).

Algorithm. Use the low-rank approximation protocol (3) to get \(\SQ(S,\hat{U}, \hat{\Sigma})\). From applying the matrix-vector protocol (2), we have \(\SQ(\hat{V})\), where \(\hat{V} := S^T\hat{U}\hat{\Sigma}^{-1}\); with some analysis we can show that the columns of \(\hat{V}\) behave like the right singular vectors of \(A\). Further, \(\hat{\Sigma}_{ii}\) behaves like their approximate singular values. Using this information, we can approximate the vector we want to sample from:

\[A^+b= (A^TA)^+A^Tb \approx \sum_{i=1}^k \frac{1}{\hat{\Sigma}_{ii}^2}\hat{v}_i\hat{v}_i^T A^Tb\]

We approximate \(\hat{v}_i^TA^Tb\) to additive error for all \(i\) by noticing that \(\hat{v}_i^TA^Tb = \Tr(A^Tb\hat{v}_i^T)\) is an inner product of the order two tensors \(A^T\) and \(b\hat{v}_i^T\). Thus, we can apply (1), since being given \(\SQ(A)\) implies \(\SQ(A^T)\) for \(A^T\) viewed as a long vector. Finally, using (2), sample from the linear combination using these estimates and \(\hat{\sigma}_i\).

Implications

We have just described examples of dequantized algorithms for the following problems:

Recommendation systems⁵² (this classical algorithm exponentially improves on the previous best!)
PCA³⁶
Supervised clustering³⁷
Low-rank matrix inversion⁸⁹¹⁰

We address here what to take away from these results.

For quantum computing

The most important conclusion, in my opinion, is a heuristic:

Heuristic 1. Linear algebra problems in low-dimensional spaces (constant, say, or polylogarithmic) likely can be dequantized.

The intuition for this heuristic is that, if your problem operates in a subspace of such low dimension, the main challenge is “finding” this subspace and rotating to it. Then, we can think about our problem as lying in \(\BB{C}^d\) where \(d\) is small, and can solve it with a simple polynomial-time (in \(d\)) algorithm. Finding the subspace is an unordered search problem if you squint, so can’t be sped up much by exploiting quantum.

Remark. There are high-dimensional problems that cannot be dequantized; for example, given \(\SQ(v)\), it takes \(\Omega(n)\) queries to approximately sample from \(Hv\), where \(H\) is the Hadamard matrix (this is the Fourier Sampling problem¹¹).

Why do we care about dequantizing algorithms? As the name suggests, I argue that this is a reasonable classical analogue to quantum machine learning algorithms.

Heuristic 2. For machine learning problems, SQ assumptions are more reasonable than state preparation assumptions.

That is, the practical task of preparing quantum states is probably always harder than the practical task of preparing sample and query access. Practically, this makes sense, since for state preparation we need, well, quantum computers.

Quantum computing applications that are realizable with zero qubits!
– Scott Aaronson's "elevator pitch" of my work, paraphrased

Even assuming the existence of a practical quantum computer, there is evidence that state preparation assumptions are still harder to satisfy than sample and query access, up to polynomial slowdown. For example, preparing a generic quantum state \(\ket{v}\) corresponding to an input vector \(v\) takes \(\Omega(\sqrt{n})\) quantum queries to \(v\) in general, while responding to \(\SQ(v)\) accesses takes \(\Theta(n)\) classical queries. Because dequantized algorithms are polynomial in \(\log n\), this means that getting SQ access to a generic vector is much more expensive than running the algorithm.

Of course, we can also consider special classes of vectors where quantum state preparation is easier, but generally SQ access gets proportionally faster as well. For example, we can quickly prepare vectors where all entries have roughly equal magnitude (think vectors whose entries are either \(+1\) or \(-1\)), but correspondingly, we can compute SQ accesses to such vectors similarly quickly.

On the classical side, the assumption of SQ access is on par with other typical assumptions to make machine learning algorithms sublinear:

There is a classical dynamic data structure that supports SQ access, fast updates, and sparsity in log time.
Given an input vector as a list of nonzero entries, sampling from it takes time linear in sparsity.
\(k\) independent samples can be prepared with one pass through the data in \(O(k)\) space.

To summarize these heuristics: quantum machine learning for low-dimensional datasets will probably never get speedups as significant as, say, Shor’s algorithm, even in best-case scenarios. Unfortunately, QML for low-dimensional problems were the most practical algorithms in the literature, so with this research it’s unclear what the state of the field is today.

The story might not be over, though. We know that quantum computers can “efficiently solve” high-dimensional linear algebra problems¹²; however, this assumes that we have some way to evolve a quantum system precisely according to input data, a much harder problem than the linear algebra itself. Nevertheless, I hold out hope that this result can be applied to achieve exponential speedups in machine learning or elsewhere.

For classical computing

I am cautiously optimistic about the implications of this work for classical computing. The major advantage of dequantized algorithms is sheer speed (asymptotically, at least). However, the issues listed below prevent dequantized algorithms from being strict improvements over current algorithms.

Gaining SQ access to input typically requires preliminary data processing or the use of a data structure. This means that dequantized algorithms can’t be plugged into existing systems without large amounts of computation.
SQ access to output might not always be useful or practical.
Current dequantized algorithms have large error compared to standard techniques.
Current algorithms have large theoretical exponents, so right now we don’t know whether they run quickly in practice. I expect we can cut down these exponents greatly.

If I had to guess, the best chance for success in dequantized techniques remains recommendation systems, since speed matters significantly in that context. I view the other algorithms as significantly less likely to see use in practice, though probably more likely than their corresponding quantum algorithms.

Regardless, these works fit nicely into the classical literature: dequantized quantum machine learning is just a nicely modular, quantum-inspired form of randomized numerical linear algebra.

Appendix: More details

As a reminder, here are the three techniques:

Inner Product
Thin Matrix-Vector
Low-rank Approximation

Below, we explain (1) and (2) fully, and give a rough sketch of (3).

1. Estimating inner products

First, we give a basic way of estimating the mean of an arbitrary distribution with finite variance.

Fact. For \(\{X_{i,j}\}\) i.i.d random variables with mean \(\mu\) and variance \(\sigma^2\), let

\[Y := \underset{j \in [6\log 1/\delta]}{\operatorname{median}}\;\underset{i \in [6/\eps^2]}{\operatorname{mean}}\;X_{i,j}\]

Then \(\vert Y - \mu\vert \leq \eps\sigma\) with probability \(\geq 1-\delta\), using only \(O(\frac{1}{\eps^2}\log\frac{1}{\delta})\) copies of \(X\).

Proof sketch. The proof follows from two facts: first, the median of \(C_1,\ldots,C_n\) is at least \(\lambda\) precisely when at least half of the \(C_i\) are at least \(\lambda\); second, Chebyshev’s inequality (applied to the mean).

Estimating the inner product is just a basic corollary of this estimator.

Proposition. For \(x,y \in \BB{C}^n\), given \(\SQ(x)\) and \(\Q(y)\), we can estimate \(\langle x,y\rangle\) to \(\eps\|x\|\|y\|\) error with probability \(\geq 1-\delta\) with query complexity \(O(\frac{1}{\eps^2}\log\frac{1}{\delta})\).

Proof. Sample \(s\) from \(v\) and let \(Z = x_sv_s\frac{\|v\|^2}{|v_s|^2}\). Apply the Fact with \(X_{i,j}\) being independent copies of \(Z\).

2. Thin matrix-vector product with rejection sampling

We first go over rejection sampling, a naive way to efficiently generate samples from a specified distribution from samples from another distribution.

Input: samples from distribution \(P\)
Output: samples from distribution \(Q\)

Pull a sample \(s\) from \(P\);
Compute \(r_s = \frac{Q(s)}{MP(s)}\) for some constant \(M\);
Output \(s\) with probability \(r_s\) and restart otherwise.

Fact. If \(r_i \leq 1\) for all \(i\), then the above procedure is well-defined and outputs a sample from \(Q\) in \(M\) iterations in expectation.

Proposition. For \(V \in \BB{R}^{n\times k}\) and \(w \in \BB{R}^k\), given \(\SQ(V)\) and \(\Q(w)\), we can simulate \(\SQ(Vw)\) with expected query complexity \(O(k^2C(V,w))\), where

\[C(V,w) := \frac{\sum_{i=1}^k\|w_iV^{(i)}\|^2}{\|Vw\|^2}.\]

We can compute entries \((Vw)_i\) with \(O(k)\) queries.
We can sample using rejection sampling:

\(P\) is the distribution formed by sampling from \(V^{(j)}\) with probability proportional to \(\|w_jV^{(j)}\|^2\);
\(Q\) is the target \(Vw\).

\[r_i = \frac{(Vw)_i^2}{k \sum_{j=1}^k (w_jV_{ij})^2} = \frac{Q(i)}{kC(V,w)P(i)}\]

Notice that we can compute these \(r_i\)’s (in fact, despite that we cannot compute probabilities from the target distribution), and that the rejection sampling guarantee is satisfied (via Cauchy-Schwarz).

The probability of success is \(\frac{\|Vw\|^2}{k\sum_{i=1}^k\|w_iV^{(i)}\|^2}\). Thus, to estimate the norm of \(Vw\), it suffices to estimate the probability of success of this rejection sampling process. We can view this as estimating the heads probability of a biased coin, where the coin is heads if rejection sampling succeeds and tails otherwise. Through a Chernoff bound, we see that the average of \(O(kC(V,w)\frac{1}{\eps^2}\log\frac{1}{\delta})\) “coin flips” is in \([(1-\eps)\|Vw\|,(1+\eps)\|Vw\|]\) with probability \(\geq 1-\delta\), where each coin flip costs \(k\) queries and samples.

3. Low-rank approximation, briefly

Proposition. For \(A \in \BB{C}^{m\times n}\), given \(\SQ(A)\) and some threshold \(k\), we can output a description of a low-rank approximation of \(A\).

Specifically, our output is \(\SQ(S,\hat{U}, \hat{\Sigma})\) for \(S \in \BB{C}^{\ell \times n}\), \(\hat{U} \in \BB{C}^{\ell \times k}\), \(\hat{\Sigma} \in \BB{C}^{k\times k}\) (\(\ell = \poly(k,\frac{1}{\eps})\)), and this implicitly describes the low-rank approximation to \(A\), \(D := A(S^\dagger\hat{U}\hat{\Sigma}^{-1})(S^\dagger\hat{U}\hat{\Sigma}^{-1})^\dagger\) (notice rank \(D \leq k\)).

This matrix satisfies the following low-rank guarantee with probability \(\geq1-\delta\): for \(\sigma := \sqrt{2/k}\|A\|_F\), and \(A_{\sigma} := \sum_{\sigma_i \geq \sigma} \sigma_iu_iv_i^\dagger\) (using SVD),

\[\|A - D\|_F^2 \leq \|A - A_\sigma\|_F^2 + \eps^2\|A\|_F^2.\]

This algorithm comes from the 1998 paper of Frieze, Kannan, and Vempala¹³. See the recent survey¹⁴ by Kannan and Vempala for a survey of these techniques, and see Woodruff’s textbook¹⁵ for a discussion of more general techniques. The form I state above is a simple variant that I discuss in my recommendation systems paper⁵.

The core piece of analysis is the following theorem (sometimes called the Approximate Matrix Product property in the literature).

Theorem. Let \(S^TS = \sum_{j=1}^\ell S_jS_j^T\), where \(S_j\) is \(\frac{A_i\|A\|_F^2}{\|A_i\|}\) with probability \(\frac{\|A_i\|^2}{\|A\|_F^2}\) (so \(i\) is sampled from \(\tilde{A}\)). For sufficiently small \(\eps\) and \(\ell = \Omega(\frac{1}{\eps^2}\log\frac1\delta)\), with probability \(\geq 1-\delta\),

\[\|S^TS - A^TA\|_F \leq \eps\|A\|_F^2.\]

This looks like a further higher-order (two order two tensor inner product) generalization of inner product (two order one tensor inner product) and thin matrix-vector (order two and order one tensor inner product); it’s possible that a clever rephrasing of this result in the \(SQ\) model could make the low-rank approximation result more quantum-ic.

We now sketch the algorithm along with intuition: it’s most useful to consider the low-rank approximation task as one of finding large approximate singular vectors. First, sample \(\ell\) rows of \(A\) according to \(\ell^2\) norm, and consider the matrix \(S \in \BB{C}^{\ell \times n}\) of these rows, all renormalized to have the same length. This is the \(S\) that we output. By the above theorem, \(\|S^TS - A^TA\|_F \leq \eps\|A\|_F^2\) with good probability, which implies that the large right singular vectors of \(S\) (eigenvectors of \(S^TS\)) approximate the large right singular vectors of \(A\) (eigenvectors of \(A^TA\)).

Next, we can perform the same process to \(S^T\): sample rows of \(S^T\) and get a normalized submatrix \(W \in \BB{R}^{\ell \times \ell}\) such that \(\|WW^T-SS^T\|_F \leq \eps\|A\|_F^2\). Since \(W\) is a constant-sized matrix, we can compute \(\hat{U}\) and \(\hat{\Sigma}\), the large left singular vectors and values of \(W\), which approximate the large left singular vectors and values of \(S\). Then, \(S^T\hat{U}\hat{\Sigma}^{-1}\) translates these large left singular vectors to their corresponding right singular vectors and rescales them accordingly, giving the approximate singular vectors of \(A\) as desired.

Glossary

For natural numbers \(m, n\), vector \(v \in \BB{C}^n\) and \(A \in \BB{C}^{m\times n}\):

\([n]\) denotes \(\{1,2,\ldots,n\}\); \(O(\cdot)\) and \(\Omega(\cdot)\) is big O notation; \(A_i\) and \(A^{(j)}\) denotes the \(i\)th row of \(A\) and the \(j\)th column of \(A\); \(\|v\|\) denotes the \(\ell^2\) norm of \(v\), \(\sqrt{\|v_1\|^2 + \cdots + \|v_n\|^2}\);

\(\ket{\psi}\) is bra-ket notation: kets are column vectors \(\ket{\psi} \in \BB{C}^{n \times 1}\), bras are row vectors \(\bra{\psi} := (\ket{\psi})^\dagger\), standard basis vectors are denoted \(\ket{1},\ldots,\ket{n}\), and the tensor product of \(\ket{\alpha}\) and \(\ket{\beta}\) is denoted \(\ket{\alpha}\ket{\beta}\). Of course, these are all really quantum states, but that’s only relevant for quantum algorithms: for my purposes, I use \(\ket{\phi}\) and \(\phi\) interchangeably to refer to vectors. (I ignore normalization, but those issues can be dealt with.)

The singular value decomposition (SVD) of \(A \in \BB{C}^{m\times n}\) is a decomposition \(A = U\Sigma V^\dagger\), where \(U \in \BB{C}^{m\times m}\) and \(V \in \BB{C}^{n\times n}\) are unitary and \(\Sigma \in \BB{R}^{m\times n}\) is diagonal. In other words, for \(u_i\) and \(v_i\) the columns of \(U\) and \(V\), respectively, and \(\sigma_i\) the diagonal entries of \(\Sigma\), \(A = \sum \sigma_iu_iv_i^\dagger\). By convention, \(\sigma_1 \geq \ldots \geq \sigma_{\min m,n} \geq 0\).

Using \(A\)’s SVD, we can define basic linear algebraic objects. \(\|A\|_2 = \max_{v \in \BB{C}^n} \|Av\|/\|v\| = \sigma_1\) is the spectral norm of \(A\). \(\|A\|_F = \sqrt{\sum_{i=1}^m\sum_{j=1}^n |A_{ij}|^2} = \sqrt{\sigma_1^2 + \cdots + \sigma_{\min m,n}^2}\) is the Frobenius norm of \(A\). \(A_k = \sum_{i=1}^k \sigma_iu_iv_i^\dagger\) is an optimal rank \(k\) approximation to \(A\) in both spectral and Frobenius norm. \(A^+ = \sum_{\sigma_i > 0} \frac{1}{\sigma_i}v_iu_i^\dagger\) is \(A\)’s pseudoinverse.

I define \(\SQ(v)\), \(\SQ(A)\), and \(\Q(v)\) in An introduction to dequantization.

References

Scott Aaronson. Read the fine print. Nature Physics 11.4, 2015. Link ↩
Iordanis Kerenidis, Anupam Prakash. Quantum recommendation systems. arXiv:1603.08675. ↩ ↩²
Ewin Tang. Quantum-inspired classical algorithms for principal component analysis and supervised clustering. arXiv:1811.00414, 2018. ↩ ↩² ↩³
Petros Drineas, Iordanis Kerenidis, Prabhakar Raghavan. Competitive recommendation systems. STOC, 2002. Link. ↩
Ewin Tang. A quantum-inspired algorithm for recommendation systems. arXiv:1807.04271, 2018. ↩ ↩²
Seth Lloyd, Masoud Mohseni, Patrick Rebentrost. Quantum principal component analysis. arXiv:1307.0401, 2013. ↩
Seth Lloyd, Masoud Mohseni, Patrick Rebentrost. Quantum algorithms for supervised and unsupervised machine learning. arXiv:1307.0411, 2013. ↩
Patrick Rebentrost, Adrian Steffens, Iman Marvian, Seth Lloyd. Quantum singular-value decomposition of nonsparse low-rank matrices. arXiv:1607.05404 . ↩
András Gilyén, Seth Lloyd, Ewin Tang. Quantum-inspired low-rank stochastic regression with logarithmic dependence on the dimension. arXiv:1811.04909, 2018. ↩
Nai-Hui Chia, Han-Hsuan Lin, Chunhao Wang. Quantum-inspired sublinear classical algorithms for solving low-rank linear systems. arXiv:1811.04852, 2018. ↩
Scott Aaronson and Lijie Chen. Complexity-theoretic foundations of quantum supremacy experiments. arXiv:1612.05903, 2016. ↩
Aram W. Harrow, Avinatan Hassidim, Seth Lloyd. Quantum algorithm for solving linear systems of equations. arXiv:0811.3171, 2008. ↩
Alan Frieze, Ravindran Kannan, Santosh Vempala. Fast monte-carlo algorithms for finding low-rank approximations. Journal of the ACM, vol. 51, no. 6, 2004. Link. ↩
Ravindran Kannan and Santosh Vempala. Randomized algorithms in numerical linear algebra. Acta Numerica 26, 2017. Link. ↩
David P. Woodruff. Sketching as a tool for numerical linear algebra. Foundations and Trends in Theoretical Computer Science 10.1–2, 2014. Link. ↩