[MUSIC PLAYING]
LIN LIN: Today I'm going to
talk about quantum LINPACK
benchmark.
You don't need to
know what LINPACK is.
And this is joint work with a
very impressive seven-year grad
student, Yulong
Dong from Berkeley.
This is the paper, and
this is the github link
for the software.
So finally now we have
a few quantum computers.
I'll ask maybe a little
bit stupid question.
How many quantum
computers will we need?
For classical computers, and
there is a famous [? upper ?]
[? bound ?] by Watson made
in 1943, which is about five.
That was really underestimated.
And what this shows
is that prediction
is very difficult, especially
if it's about the future.
So let's now make
some prediction.
It will be, say, 10,000
quantum computers.
I don't know whether
this is true.
But what we are
almost certain is
that the future of quantum
computers don't look like this.
So now among the 10,000
quantum computers,
we want to select the top 500.
How do we do the job?
First let's ask how
to do the same job
for classical supercomputers.
This list was
generated last month
and which is the top 500 for
classical supercomputers.
Number one is now a Japanese
supercomputer [INAUDIBLE]
Fugaku.
The important
thing for this talk
is that in order to
show up on this list,
every machine needs
to turn in something
called a high-performance
LINPACK benchmark.
And I will introduce
what that is.
But now let's say the number
is about 400 petaflops.
We ask what is LINPACK
and why LINPACK?
So the LINPACK
benchmark is based
on that we're interested
in using supercomputers
for scientific
computing applications.
And solving linear
systems, as we just
heard from [? Andras, ?]
is the building
block for numerous scientific
computing applications.
And the classical impact
benchmark is the following.
You want to solve ax equals
to b with some dense, random
matrices, and these
dense random matrices
have no obvious applications.
Reminds us a little bit
about quantum supremacy.
As you can possibly
imagine, there
has been some controversy
over its effectiveness
since the very early days,
and alternative benchmarks
have been proposed,
but this is still
solving some linear systems with
some random sparsity patterns.
Although there is controversy,
this LINPACK benchmark
has been used to
define the top 500
list since the very
beginning of the list.
And this talk is about the
quantum LINPACK benchmark.
So I would like to think
about quantum advantage is
like we're climbing the
quantum Mount Everest.
It's pretty high.
After a very long way, we have
reached the so-called quantum
supremacy.
You look up towards the sky
and that's quantum advantage.
And the punchline of this talk
is that the quantum LINPACK
benchmark, one, is something
that you probably want to do,
and two, is that
unless we have found
that there is a very shortcut
directly along the cliff,
and this is actually
some middle ground
that is only steps away from
Google's quantum supremacy
test.
So we have just heard that
the quantum linear system
problem is to prepare
a quantum state that
is proportional to a inverse b.
How to get the information of
a and b into a quantum computer
is a very nasty business.
It is called the
reading problem.
And in order to
quantify the complexity
of solving linear systems,
there are two important things.
One is the condition
number of the matrix,
and two is target accuracy.
And with some proper
assumptions on a, for example,
is a d-sparse matrix, so
that the oracle getting
access to a scales only as
a poly (n), where the matrix
itself is exponentially
larger, then we can potentially
achieve exponential speed up.
So in the past few
years, I mean starting
from the groundbreaking
HHL algorithm,
in the past few
years, there have
been very significant progresses
in the past few years,
like LCU, QSVT,
and also later we
might hear about the
randomization method
by Rolando Somma
and collaborators.
And we also contributed
along this line
called the time-optimal
adiabatic quantum computing
and eigenstate filtering.
This is a joint with two
brilliant grad students
in the math department at
Berkeley, Dong An and Yu Tong.
And we have together achieved
the near-optimal complexity
matching the lower bounds.
So this talk is about
the quantum benchmark.
I want to say that all those
algorithms used directly
for real applications,
but probably would
require full
fault-tolerant quantum
computers to get anywhere.
And this is really
because getting
the matrix into the
quantum computer
alone, for example
using LCU itself,
I mean before solving
the linear system,
can already be prohibitively
expensive on near-term devices.
Will likely remain
so for some time.
But the quantum
LINPACK benchmark
is a little bit different.
We ask a different question.
Do we really need or want
to generate random numbers
classically, and then get
them into a quantum computer,
say, via QRAM?
That doesn't sound
like a great idea.
So the idea is we want to borrow
from the success of Google's
supremacy test.
So what is Google's
supremacy test?
It is basically a big
random unitary matrix.
It is almost drawn
from the Haar measure.
But it's unitary.
Linear algebra usually works
with non-unitary matrices.
We have just heard
the blocking coding,
and you see it
again, which I think
is a really great idea, that
you take the upper left diagonal
block of n-qubit
matrix, you put it
as an upper left
diagonal block of n
plus 1 qubit unitary matrix.
And this unitary matrix,
denoted by ua, can be random.
The fact is that even though you
just added one ancilla qubit,
it can represent in
principle any n-qubit matrix
after some scaling.
This is the block
encoding, and what
we're going to talk about today
is so-called random circuit
block encoding matrix.
That is this matrix is block
encoded by a random circuit,
or RACBEM.
So as seen in the cartoon here,
this is an n plus 1 qubit.
Pretty chaotic, random circuit.
And this is the matrix
you actually care about.
It's a RACBEM.
You can think that it is
a proper generalization
of this random or
pseudo random matrices
and in the quantum context.
And here what I'm
showing you is this
is not just some
abstract concept.
It's something that is
very, very implementable.
I'm taking this
coupling map from one
of the IBM Q's computer.
I'll be more than
happy to try it
on Google's computer
in the future.
And so there are five qubits.
I get rid of zero.
Now it will be used as
a signal qubit later.
I have four qubits.
And I want to generate a
random circuit using completely
elementary things.
You want U2 gates and
[? C0. ?] That's it.
So there are four qubits.
I generate a random circuit,
completely respecting the copy
map of this architecture.
Now I want to trace
out-- trace out
is not the rigorous word, what
you actually do with this.
So you take this qubit
one, made to take zero,
you have three qubits left.
You end up with a three
qubit RACBEM, or a eight
by eight matrix.
As you can see, this
is a very flexible way
to construct a non-unitary
matrix with respect
to almost any given copy
map of architecture.
So this is totally near term.
Let me show you that the error
of the RACBEM on IBM Q. What
you can do is basically
to measure the success
probability of [INAUDIBLE] zero
and to get this a axiom 0n.
Of course, you can
change this thing.
The important thing is
that it didn't blow up.
I mean, as you
know, that if you--
these numbers are not
particularly large.
And also if you increase
the number of system qubits,
the growth [? are ?]
[? relatively ?] mildly,
and we hope that
with, for example,
Google's better architecture,
the result there would be even
smaller.
But this kind of 20%-ish of
relative error will be used
as a kind of baseline for
understanding the results
of quantum impact on
other results later.
So I don't have that
much time to talk
about technical details,
but thanks to Andras's talk,
we have seen this
beautiful circuit.
Indeed you can use
the same circuit
and to do very
different tasks and when
they show some linear systems,
time series, spectral measure,
computing thermal energy,
all with important
for the Hermitianized RACBEM.
And if you're interested,
you can look at our paper
how to construct that.
It's a very simple
construction using this QSVT.
You can actually always use
an even order polynomial
to compute a matrix function
of this Hermitian RACBEM.
Even order polynomial is
a very important thing
because this QSVT depends
very crucially on the parity
of the polynomial.
So either even or odd, but even
is usually easier to work with.
You always add one
extra ancilla qubit.
That's why I reserved
the qubit zero before.
And you can prepare this thing.
There's not even
[INAUDIBLE] gate.
And all of these things
are just [? a C0. ?]
And they follow the natural
layout of the quantum circuit,
and can run without even
calling a transpiller.
That's using the
language of IBM Q.
And I saw in the chat before
how to obtain the phase factors.
Again, in the past
two years or so,
there has been quite significant
progress along this way.
Our method is called
optimization based method.
Can allow you to get
very high accuracy
for phase factors, which is
about polynomial of order
10,000.
So let's look at some
numerical results.
And this h is a Hermitianized
version of a RACBEM.
And what I want
to do is to solve
this particular linear system.
And in order to really
talk about the error,
we'll compute the
error, or the accuracy,
of the success probability.
If you want to generalize
that into something
like a cross-entropy test,
that's probably doable as well.
Another thing I want to say is
that all these linear systems
are completely tunable.
You can make the condition
number to be anywhere you want,
which is a well
conditioned thing.
Later, we're going to talk
about the hardness in the end.
So you can, at least on
the near-term device,
we can imagine that the
circuit depth will probably
have a very important impact
in terms of accuracy indeed.
So if the number of phase
factors is relatively small,
which is about
three, and you need
to get some accuracy
that is reasonable,
but if you increase the circuit
depth, which is the phase
factors becomes 11, and the
error becomes much larger,
and it is what it is.
On the right hand side,
we do it on the QVM, which
is we dump the error model
from IBM Q, tailor it a bit,
and then use one single
number, called sigma, to dial
between the sigma equal to 0,
which means there is no error
or there is only
[? movement ?] error, and one,
which is a full error.
And you can see that
as copper increases,
indeed the error
will also increase,
but all these things can behave
relatively smoothly, especially
for the well-conditioned case.
If the system behaves
better than this,
we can really have
the hope of getting
something meaningful in
the [? NISQ ?] error.
You can use it to do time
series analysis also, thanks
to the flexibility provided
by quantum singularity
transformation.
And what you do is you
generate the Hermitianized h
RACBEM here, called h.
And you can view this
as a matrix function.
And you compute this
quantum simulation problem.
Important thing is there is
no trotter whatsoever going
on here.
Every circuit looks
like the same,
which is what we showed before.
That's the QSVT circuit.
This is the results on the QVM.
Again, if the error
becomes small and looks
really nice, and the
t goes from 0 to 10.
But when the error
becomes larger still,
the qualitative shape
seems to be preserved,
but the error is a
very [INAUDIBLE]..
You can use it to
compute the spectrometer.
And here we use the
prime a formula.
Instead of first of doing
the [INAUDIBLE] simulation,
and then you do the
inverse for your transform,
you can actually
solve a linear system
with a broadening,
which corresponds
to a lower
[INAUDIBLE] broadening
and directly compute this.
Again, you can see that for
different number of qubits,
this is like a matrix of 1,000.
And when the error rate is
relatively small and at least
the quality of the features
is preserved very well.
This is to compute the
thermal energy, which
computes the ratio
between the two traces.
This one is a bit trickier
but also very interesting.
Here we use the minimal
entangled typical thermal state
algorithm called METTES,
developed originally
by Steve White in 2009.
Also used by Motta in
the [INAUDIBLE] group
in the paper on the [INAUDIBLE]
thing that was present also
last year in the
Google symposium.
What is very interesting is
that as you can see, even
with the near-term device,
the error is so large,
this on the left is the result
of 10 directly on the IBM Q.
And at least for all
the cases in this beta,
the inverse
temperature increases,
the qualitative features,
they are all preserved.
And some of them look
unbelievably good.
I would say that's
probably a coincidence.
On the right is
not a coincidence
where, again, this is
from QVM, so the error
becomes smaller and smaller.
And you can see the
gracefully converges
to the correct result.
So let me now conclude.
So what I talked
about here is how
to solve linear systems,
not with a particular real
application, but with a
RACBEM, or basically you can
think dense random matrices.
This is called the
quantum LINPACK benchmark.
It uses a supremacy type of
circuit as a building block.
So far, we haven't tried
the supremacy circuit,
but you can see you can do that.
It can be very easily
engineered with respect
to almost any architecture
because you can really
literally do the logical
to physical qubit mapping
yourself.
And it's very, very simple.
And maybe this is only steps
away from supremacy test.
What about the hardness?
I don't have a proof,
but intuitively, it
looks like hard.
The reason is that even getting
each ua that is a supremacy
circuit is already hard, and
this QSVT circuit, what it does
is just to have this
ua ua [INAUDIBLE]
interleave with some very
simple phase factors.
And hopefully, we
can show rigorously
that this is also hard.
And you can also use
more quantitative weights
to measure the success and
the classical hardness,
such as cross entropy or
linearized cross-entropy test.
So we have the codes.
And this is to generate
the QSV phase factors.
And this RACBEM, feel
free to play, and let us
know how you think about that.
These are some of the papers
related to linear systems.
Finally, I'd like to thank you
very much for your attention.
[MUSIC PLAYING]
