[MUSIC PLAYING]
SHELBY KIMMEL: Today
I'm going to be
talking about algorithm design.
And in particular,
this tool that
can be used to design all
sorts of quantum algorithms.
And so I'm calling
it a multi-tool.
And I'm going to be
mentioning a couple of papers
that I've worked on
with other folks,
so I encourage you to
check out some of the links
that I've listed
here under the title
if you'd like more information.
So I'm going to be talking about
designing quantum algorithms
for classical problems.
And there already exists
some really great tools
for doing this.
Obviously, the quantum
Fourier transform
is one of the workhorses
of quantum algorithms
for classical problems, as
Peter mentioned in his talk.
And of course, it's used
in the factoring algorithm.
There is also the
Grover Search subroutine
and more recent algorithms,
such as QAOA for optimization.
But these tools for
quantum algorithm design
tend to have specific
regimes where
they seem like they're
going to work really well,
or where we know they
work really well.
So the quantum
Fourier transform,
we know that is a
really good tool
to use if your problem
has a lot of structure,
especially some kind
of periodic structure
like we saw in Peter's talk.
Those kind of periodic
lattice structures.
Grover's search searches for
an item in an unordered list,
and Grover's search is very
good at doing that one task,
but if there's more
structure to the problem,
then Grover's
search is not always
that good a technique to use.
Newer algorithms,
like QAOA, are really
exciting algorithms
that we hope can
be used to solve classical
optimization problems,
but they're pretty
hard to analyze,
although we're continuing to
make progress in understanding
how they will work.
So the tool, this
multi-tool tool
that I'm going to be
talking about today,
tries to kind of fill in the
gap in this intermediate regime.
It kind of works in both
highly structured problems,
and it also works to solve
unstructured problems.
So it kind of goes from the
regime of the quantum Fourier
transform to like a Grover
search-type problem.
Not only that, but
it's easy to create,
so you don't need to know very
much about quantum computing
or quantum algorithm
design to use this tool
to create a quantum algorithm.
And also to analyze how
well it's going to do.
It's pretty easy to
analyze and prove.
And again, you don't need to
know very much about quantum
computing to do that
analysis, unlike some
of the more challenging
quantum algorithms
that are challenging to analyze.
I will say that this tool
is in the query model,
so that's a model
where we assume
that the kind of time-consuming
parts of the problem
are looking at
bits of the input.
And for problems
like optimization,
this is not really a good model.
So the types of
problems that I'm
going to be talking about today
are not really those same types
of problems that you might
want to solve with the QAOA
algorithm.
OK, so I'm basically going
to talk about the workflow.
So if you wanted
to design a quantum
algorithm using this tool, how
would you go about doing it?
So it's a simple workflow.
You start by taking
your classical problem,
and then you turn it into
another classical problem
called st-connectivity.
So there's the first step, where
you reduce the original problem
you want to solve
to this new problem.
Once you have it in
the specific form,
that's the form that the
quantum algorithm can solve.
And so at that point,
you can analyze
your st-connectivity
problem to figure out,
is this a problem that our
quantum computer could actually
solve in a way that is fast
enough to make it worth it?
Because maybe you're not going
to get a big enough speed-up,
and you decide, I'll just use
my regular computer to do this.
But once you do the analysis and
you can put bounds on how long
your quantum algorithm will
take to solve the problem,
at that point, you can
go and actually run
the quantum algorithm, and
it's a quantum span-program
algorithm.
So I'll kind of very briefly
go through this workflow/
but my hope is that even at the
end of these 10 or 15 minutes,
you can kind of follow this.
And if you wanted
to go and design
a quantum algorithm
for a classical problem
using this technique, you
would be able to do that.
So first, what I mean
by this reduction.
So a reduction to
st-connectivity.
So we start with the classical
problem that we want to solve.
So in this case, just
as our working example,
I'll consider that we have a
bit string with three bits.
And we just want to
know if it contains a 1.
So this is the problem of
or that I mentioned before.
This is a problem that you
could use Grover's search on.
It doesn't have a
lot of structure,
but it is very easy
to describe, so that's
why I'm going to be using
it as our working example.
And so our goal here is
to take this problem that
has to do with some
unknown input string,
and we want to turn that into
an st-connectivity problem.
So st-connectivity, we have a
graph with vertices s and t.
And we want to know, is
there a path from the vertex
s to the vertex t.
And if there is a path, then
we should be answering yes
to our original problem.
And if there is no
path, then we would
want to answer no to
our original problem.
So somehow we take
our original problem
that had nothing
to do with graphs,
and we turn it
into this new kind
of path finding
problem that also
answers our original question.
So there's always a way to
turn your original problem
into an st-connectivity problem.
And the kind of foolproof
way of doing this,
is to use a classical
decision tree approach.
So the idea is, you just turn
a classical algorithm that
solves your original
problem, you
can take that and turn it into
an st-connectivity problem.
So I'll do an example of how you
do this with this, our example
problem.
So if we're just
searching for a 1,
a classical algorithm
that does this is it
looks at each bit in turn,
and if it ever finds a 1,
it outputs 1 and
ends the algorithm.
And otherwise, if it
looks through all the bits
and doesn't find
a 1, it outputs 0.
So we can create a decision
tree for this algorithm.
So we start at the start node.
And then we have
two output nodes
whenever the algorithm outputs.
And the first thing
that the algorithm does,
is it looks at the bit x1.
And if it has value 1, it
can go straight to output 1
and end the algorithm.
But if x1 has value 0, then
we create a new node and kind
of continue down with
our decision tree.
And the next thing we
do is look at bit x2
and check if it has value 1.
If it does, we can go
to the output 1 node.
Otherwise, we have
to keep going.
So in this way,
we can create, I'm
calling this a decision tree.
Technically it's not
a tree, because there
are cycles in the graph.
But this is a graph that
encodes the classical algorithm.
Now, this decision
tree can be turned
into an st-connectivity
problem, where
we identify the start node as
s and the output 1 node as t.
And then if you have an
input, like for example,
the input x 011, then you
include edges in your graph
if they have the correct
corresponding value for that
bit.
So for example, for x1 in
this example, x equals 011.
The first bit has value 0.
So we get to include the edge
corresponding to x1 equals 0.
And then the
question is, is there
a way to follow paths to get
from our initial vertex s
to our vertex t?
And in this case, we
see that there is.
We can go down to x1 equals
0, edge, and then over
on the x2 equals 1
edge and get to t.
So in this case,
there is a path,
so we should output
1, which is what
we want to output, because
there is a 1 in the bit string.
On the other hand, if
our input had all 0s,
then there's no way to get to
t, which is also what we want,
because there's no
1 in the bit string.
So this is kind of
a foolproof method
to take any problem
that involves
looking at bits of
an input and creating
an st-connectivity problem
based on whatever problem you're
trying to solve
regarding those bits.
There are other methods
for doing this too,
and I want to mention one more,
because this decision tree
approach, while it
always works, it
produces a very large
tree, a very large graph.
And that is not ideal for
creating a quantum algorithm.
And I'll explain
why in a little bit.
So sometimes it's possible to
be a little bit more clever.
So we can actually
encode this same problem
into much smaller
st-connectivity problem, where
we just have two vertices, s
and t, and three edges, one
for each of the
bits in our input,
that only get included when
those bits have value 1.
So for example, if
we had the input 011,
now we get the x2 and x3
edges, but not the x1 edge.
But still we see
that there's a path,
just like we would like there
to be, since there's a 1
in the input bit.
Or if all of the input bits
are 0, then there is no path.
So that is the first
step in this workflow
when you're trying to use
this algorithmic tool,
this multi-tool.
You start with your
classical problem
and you turn it into an
st-connectivity problem.
Now that you've
done that, you need
to analyze how well a
quantum computer would
do to solve this st-connectivity
problem to decide if you
actually, if it's
worth it to code it
up using a quantum computer.
Because we know for
some types of problems,
you don't get a
very large speed-up
from using a quantum
computer for some
of these types of problems,
and for some you do.
So you want to know what
kind of a speed-up you get.
So to analyze the
algorithm, you first
assign a weight to each edge.
So in the kind of simpler graph,
there are just three edges.
So we assigned a
weight to each one.
And then you imagine attaching a
battery to the vertices s and t
and you think of this as
an electrical network.
And now anytime there is
an edge that is actually
present in the graph, you
imagine putting a resistor
there, with the resistance that
is equal to the weight that's
on that edge.
And if there's ever a case
where an edge is kind of removed
from the graph because the
corresponding bit doesn't have
the correct value,
then you imagine again,
connecting a wire between
those two vertices,
but putting a capacitor on with
capacitance 1 over the weight.
So now if there is
a path from s to t,
current will flow
through this circuit,
but it will hit all
of these resistors
so there will be an effective
resistance to the circuit.
On the other hand, if
there's no path from s to t,
then all of the
current flow will
get caught on these
capacitors, and there will
be an effective capacitance.
So what you do is, you look
at all possible graphs,
all possible graphs
where there are paths,
all possible glassware
there's no path,
and you can calculate
for each one
of those the
effective resistance
or the effective capacitance.
Then the quantum
query complexity,
so how well a quantum
algorithm would
do in solving this
problem, is just
the square root of the
maximum effective capacitance
times the maximum
effective resistance.
And that's the maximum over
all possible input graphs.
We saw earlier that as we
add different inputs, that
resulted in different graphs
that we were dealing with.
And what's nice about
this kind of everything
I've said so far,
if you've noticed,
I haven't really said anything
about quantum mechanics
or quantum computing.
And calculating the
effective resistance
and effective
capacitance are things
that most physicists know
how to do, because they've
taken E and M. It's a thing that
most CS folks know how to do
and most math folks
know how to do,
because they've
taken graph theory.
So this kind of opens up, I
feel like, the quantum algorithm
design to potentially
people who feel
a little bit uncomfortable
with bars and kets and some
of the other quantum
notation that we
like to throw into things.
So you've taken your original
problem that you want to solve,
you've turned it into an
st-connectivity problem,
you've analyzed the effective
capacitance and effective
resistance, and
that has given you--
so you know how long it's going
to take to run on your quantum
computer.
And now you've decided,
yes, it's worth it,
and I want to encode this
into a quantum algorithm.
And so the way that
I suggest doing this
is using this
quantum span program
algorithm for st-connectivity.
And I'm not going to
go into the details,
because we don't
have enough time.
But you apply phase
estimation to a unitary
that's a product of two
different unitaries.
I guess the main thing
that I want to say though,
is that the space
complexity, so how many
qubits you actually need to
run this algorithm, scales
logarithmically with the
number of edges and vertices
in the graph.
So that's why if you can
come up with an encoding that
uses some small
graph, that is good,
because we don't expect to have
very large quantum computers,
at least in the near term.
And this algorithm
was originally
developed by Belovs
and Reichardt.
So now you might be
wondering, well, this
seems simple and nice, but it
can't be that this actually
produces good algorithms.
It seems too simple.
We should need to do something
more sophisticated than this.
But here I have a partial
list of all of the algorithms
or all of the problems
for which we either
have optimal or best-known
algorithms using this approach.
And you can see,
well, a lot of these
are graph problems, which
kind of makes sense,
because we're reducing
to another graph problem,
so it's natural.
But some of them,
like the very top one,
is for Boolean formulas,
which don't have anything
to do with graphs, ostensibly.
And also, the very last one
gives a super polynomial
speed-up for evaluating games.
So that's a problem where
you have a lot of structure,
and that structure allows you to
get improved performance better
than polynomial over
a classical algorithm.
But at the same time,
using this approach.
So I'm just about out
of time, so I will just
conclude and remind
you that I've told you
about a multi-tool for
quantum algorithm design that
is accessible.
And by accessible, I mean
that it's easy for non-experts
to use to design
quantum algorithms
and get a sense for how
those algorithms will do.
And also, it's a
multi-tool in the sense
that it can be applied to lots
of different types of problems,
as we saw on the slide.
There are several very
important problems.
So one thing that I just kind
of cavalierly said, was OK,
you just put weights
on these edges
and calculate the
effective resistance
and effective capacitance.
But actually, we don't
know in all cases
how to set this optimal weights.
There are heuristics
that people use,
and that's how most
of those results
came about-- through using
heuristics for deciding
how to set the weights.
Also, we saw that it seems to
be optimal for a lot of types
of problems.
And it'd be nice to
know more generally
when this approach actually is
going to be a good approach,
and when you might need
to resort to other tools.
And so finally, I just want to
thank funding sources and some
of my collaborators.
[MUSIC PLAYING]
