[MUSIC PLAYING]
SPEAKER 1: Let's
start with a talk
by Wolfgang Lechner followed
by Tameem Albash, followed
by Aidan Roy.
And let's get this started.
Wolfgang, the floor is yours.
WOLFGANG LECHNER:
First of all, let
me thank the organizers for this
great opportunity to talk here.
A perfect place.
I always love to come here.
What I would like to present
is the parity adiabatic quantum
computing scheme
which we actually
introduced last year in Siri.
This was worked on together
with Phillip and Peter Zoller.
And today I would
actually like to present
what happened in the last year.
We have a list of new
exciting developments.
And then this talk,
I will basically
start by giving a very short
introduction on this parity
scheme, what it means, and
what the opportunities are.
Then I would like to discuss
some encoding aspects.
So one way to look
at this scheme
is to look at it from
encoding perspective.
So what new opportunities
do we have for encoding?
And then there's also aspect
about efficiency in this talk.
Which would have been also
covered by Tameem in the talk
after that.
Another point of
view for the encoding
is the implementation aspect.
So I hope I can convince you
that this encoding not just
gives us new opportunities
on what we can embed,
but also on the
implementation level.
And I think these two
aspects of the encoding
into implementation
should not be treated
completely independently.
But they should really
go hand in hand.
And as a last part
I would also like
to talk about
application aspects.
So this means things
that we can now
do in this parity
scheme for applications.
And the example will
be machine learning.
So let me quickly introduce
the parity scheme.
The Hamiltonian that
we have seen now
like several times
at this conference
that we usually look at is
a spin glass Hamiltonian.
So we have the
transverse field and we
have our spin glass of problem.
And the paradigm here
is that the problem
is encoded in interactions.
So here I've taken the
example for two body,
but this can be three
body, four body, and so on.
But so to say what
we have to program
is our interaction matrix.
Now in the parity
scheme, we're looking
at a different Hamiltonian.
And I would-- so to say as a
teaser, just compare the two.
The first thing that we
observe about this Hamiltonian
is that it's larger.
So the price that
we pay is that we
have to introduce more qubits.
On the other hand, we gain.
And I think we gain a lot.
One thing is that this is not
a spinning glass Hamiltonian,
but this is a lattice
gauge Hamiltonian.
So this means we have a
constraints, the parity
constraints.
And these are the interactions.
And these interactions
are constant.
What we have to program
is local fields.
So the strategy of the scheme
is to separate interactions
and programming elements,
and put everything
into the local fields.
So this is intended as a teaser.
And then in the
next few slides, I
will show you what
this exactly means.
But as a summary, the
optimization problem
is fully defined
by local fields.
The interactions are
all nearest neighbor.
So they are really local.
They are problem
independent, hence
they don't need
to be fine tuned.
So they can have errors.
This can be realized in
various qubit platforms.
And in the implementation part,
I will outline this a bit more.
I think this is a
great opportunity
to also bring other communities
from quantum simulation
into this field.
Another important fact
here is that the k locality
in the logical
problem is abstracted.
So this means the qubits
that we introduce,
they can also represent three
body or four body interactions.
I will outline this
also in detail.
And then there is
some error tolerance
for spin flips, which
can then be corrected
by a classical algorithm.
So the main idea is this.
And I would like to illustrate
this for two body terms.
But keep in mind this can also
be three body or four body
terms.
But let me just give
you the outline.
So the idea is to take our
fully connected spin model,
and I'll represent it
by the dual variables.
So instead of looking
at the individual spins,
we would like to
represent the whole system
by spins that actually represent
a pair of spins, or pair
correlations.
So if two spins are up, then
the physical spin is up.
If they're looking in different
directions, it's down.
And if both are up, it's up.
And now what I want
to do is I want
to represent the whole system
by these new variables.
And for example if I have
three spins, which is a down,
down, up, then the new spins
will be up, down, down.
And now if I look at this
here, and this is basically
just a product of
the two, which means
if I have a Hamiltonian
that looks like this.
Now I have an interaction
matrix times the product.
Then in the new variables
just simply becomes
a sum over n squared elements.
Hence what was previously
the interaction matrix
is now suddenly a local field.
So it's a different
physical thing.
But now if we count the
number of degrees of freedom,
we have too many
degrees of freedom.
So here, we have k elements.
And here we have k elements.
So k is n squared.
But here we have only
in n degrees of freedom,
because we have n spins.
While here we really have n
squared degrees of freedom.
Which means we have
to get rid of them.
And we have to get
rid of k minus n
of the additional
degrees of freedom.
So that's basically
all that we have to do.
And now we could
ask ourself well,
what are these constraints?
Where do the new degrees
of freedom come from?
These new degrees
of freedom come
from configurations which
have no correspondence
in their original model.
So if you take the example
of my three spins again,
I can make a translation table.
So in my original
spins will be 1 to 3.
And my new spins, they would
always represent pairs.
And now I can make a list.
And maybe at some point
I want to have 1, 2 is 1.
So 1, 2 is up.
1, 3 is up.
So it's also up,
but 2, 3 is down.
And it's not possible to arrange
the original spins like this.
So this is an unphysical
solution of the new spins.
And this, I have to get rid of.
And they way I can
get rid of this
is by simply translating this
into a Hamiltonian term again.
So here's my logical
problem, and then
I translate this into
my physical qubits.
So my pairs.
And now I give them
a three body term.
So I say 1, 3, 1, 2, 2, 3.
Gets a three body term.
This means I rule out all
configurations that have
an even number of spin down.
Now this rule is true for any
closed loop in any spin model.
So if I have a loop
of four, I would
have a four, [INAUDIBLE]
a four, and this
will give me a four body term.
So this is so to say,
the general concept.
And now I can look at what can
I actually encode with this?
So as I said, this example
was not built on the two body.
Now let's look at the two body.
So imagine we have now a
fully connected system.
So all to all.
Then I can ask myself
which of the constraints
do I have to select.
So I have to make a selection.
So I have an enormous
number of closed loops,
but it only needs
k minus n of them.
And it turns out that there is
only one particular solution
that actually allows one to make
all interactions then local.
So we can get rid of
all local interactions.
And it's the basic building
block always looks like this.
So I go one to the right,
two left, three to the right,
two left back.
And this is sort of
say the pattern which
then goes through
the whole system,
and the closed loop
that I've drawn here
would then represent this
blockade for example.
And with this I can represent
a fully connected spin
glass in 2D by going to dual
variables plus a constraints.
And what comes out
is then a triangle.
And the Hamiltonian that
I had in my original model
also had not a sigma extra.
I want to do quantum annealing.
And I might say
well, what I did now
was a classic transformation.
So what did you do
with the sigma x?
Well, we just sneaked it in
again into the new variables.
So we just added a sigma x term
in our physical new variables.
So this Hamiltonian
corresponds to this triangle
here because the
only requirement
is that they are so orthogonal
and you don't really
need to transform
their original sigma x.
We could transform it, but we
don't need to transform it.
And if you do it like this,
then we have only local terms.
So we have no multi [INAUDIBLE]
sigma x or anything.
We program our problem
with local fields.
And we have constraints
which are all local.
And I would like to show you
that this particular setup
actually allows you not just
to encode like two body terms
all to all, but actually
an enormous number
of different models.
So for example, if I have
all to all three body,
then my new qubits represents
the product of three original
spins because I have
now three body terms.
And there I have
more possibilities.
But it turns out that if I want
to implement a full three body,
then I need to go
to three dimensions.
So this is not very convenient.
But later, I will show
you that we can actually
also do this in 2D if
we have less than all
to all connectivity.
So until now, this
is a more or less
what I presented
last time in Siri.
Now I would like to show some
additional aspects, which
I think make this
a very interesting.
Lets look at other
special cases.
For example the bipartite graph.
If you have a bipartite
graph which means
you have two layers.
We have some local field which
I represent now as a bias
with-- as an interaction.
Then this translates into in the
parity scheme into a rectangle.
So I have exactly
the same Hamiltonian
as in the two body, three body.
The only thing that
will change is geometry
of tree of my blockades.
And the by product graph for
example, becomes a rectangle.
While it's also interesting here
is that the local filed terms.
So in the original model, I have
local fields and interactions.
In the new model they
all become local fields.
So they are now in
the same footing.
And this will be
interesting then
for the application
point of view.
Now if you want, I
have now a [INAUDIBLE],
or maybe I want to
make a deeper net.
No?
So maybe I want to
have more layers.
Than this actually
becomes a rectangle,
but in a stair case geometry.
So what we see here, is
this is the first layer.
And then the second layer would
be an interaction between B
and C, so I put this down here.
And then here I have some
connecting blockades,
which actually represent
closed loops that
go through to two layers.
So I can just put them below.
And then the next layer
will be between Z and D.
So this would be here and so on.
So this becomes
like a staircase.
And interestingly,
we can of course
also fill the square again.
And if we do this, we get
additional interactions
between additional layers.
We can also make
it think of what
happens if we start now with a
cognomen lettuce for example.
This becomes a tripartite
graph in the logical problem,
and so on.
So there is like
many graphs that we
can think of which have some
interesting representation.
What I really want to
emphasize is this work here.
This is from the Oxford
group around Simon Benjamin.
They looked at our
parity architecture
in a very general way.
And they formalized it
also in a very general way.
And they have a list
of interesting encoding
opportunities there.
The first one is I can take
the all to all two body
and just add l locals
to it very easily.
So all I have to do is add some
connections inside the graphs.
So I can, for example, here
this is one original blockade.
If I add a interaction
between these two guys,
then I have four
body terms in there.
Additional four body terms.
One can also make six body terms
or three body terms and so on.
Another very interesting
part about this paper
is how to make arbitrary k
locals out of three bodies.
So I can take our architecture
and add on the site
these cascades of
three body terms.
And this allows me to introduce
higher and higher k local.
So I can select any
number like 1, 2, 3, 4, 5,
and I can generate the
interaction 1, 2, 3, 4,
5 by making a cascade
of three body terms.
This also gives me then the
four body and the three body
on top of this.
And as a last point from
this paper that I also
want to mention, and
this is also something
that I like very much,
is the re-routing.
So if I have less than
all to all connectivity,
and I want to select
particular interactions,
then what they found out
is that one can actually
re-route the interactions.
So what does this mean?
What we see here is that the
triangle that we had before.
And the lines that you see,
so that the colored lines,
there are something like
the original qubits.
So this will be in the scrit,
or in this flux qubit picture,
this will be the lines
that we have to draw.
But now here, they are sort
of say an abstract object.
And because they're
an abstract object,
we can actually re-route them.
So for example, by changing the
interaction on this blockade
from four bodies from four,
four body to two three
body plus one six body, we can
actually re-route these lines.
This means we can select where
they actually hit each other
by just changing local fields.
So just by the software.
We don't have to really
on hardware level
change where these lines go.
And the example that
they give here is this.
So this would be a graph.
It's more or less random.
But so they said well, let's say
we want some connections that
are fully connected with 100%
connectivity, some nodes that
have 50, 25, and 12 and so on.
So this would be this graph.
And this translates to
this re-routing scheme.
So this is all in 2D.
And has less than all
to all, but it gives us
a very nice flexibility
in which qubits interact
with which other qubits.
And it also allows us to--
we are very flexible in which
three body and four body
terms we can add here
because of the re-routing.
So this, I think, is a very,
very interesting paper.
Now as a last encoding
aspect, I would like
to talk a bit about efficiency.
So there is the error correcting
code by Peskin and Paustovsky.
This is a classical
error correction
which corrects for spin
flip, uncorrelated spin
flips error that are
due at the readout
or at the very end
of my annealing.
What this means is,
or what they use here
is that for the
construction of our lattice,
they actually used some
of the closed loops.
But there are still all
the other closed loops.
Know for example, 1, 2, 2,
4, 1, 4, 1, 2 is still there.
And this allows me to do
a very clever readout.
So if I want to know
the value of 1, 2,
I can either just
read out 1, 2 or I
can read out every closed
loop that contains 1,
2, except for 1 2.
So if I know for
example what 2, 4 and 1,
4 is, I know what 1, 2 must
be because of the parity
constraint.
And from this, I have
an exponential number
of possibilities
to read out 1, 2.
And they do this
even more cleverly.
So not just majority
vote on this,
but actually I believe
propagation on this.
And if they do this for
uncorrelated spin errors,
then this gives an exponential
suppression of these errors.
Now Tameem, who
will talk after me,
they looked at this from
a Monte Carlo point a few.
And the result-- so they
used this error correction.
They did the Monte Carlo.
And the result is quite bad.
So if you sort of say
look at the graph.
It looks actually very bad.
So what they looked at in
particular was this protocol.
So we have the two terms.
One term which contains
the constraints
and the local field, and one
term that contains the sigma x.
And to compare this
to the same problems
with a minor embedding.
And it's relatively
large temperature.
And the conclusion was
that minor embedding always
outperforms the [INAUDIBLE]
so the parity problem.
So at this point, and so
if you see this graph,
you probably would
go back a bit.
But fortunately, so
Mathias Troyer's group,
Mario Konz is also here.
We were also looking at this.
And one can actually
solve this problem.
And the way to do this
is-- or what we did now
was to change the schedule
just a little bit.
So we have three terms here.
One for the local field and
one for the constraints.
And the constraints
actually contain two parts.
it And by doing this
for small systems,
we get up to 100% for 100
qubits, logical qubits.
So 5,000 physical qubits.
Up to 92% for
[INAUDIBLE] problem
compared to the unencoded
problem, unembedded problem,
which I think is
really fantastic.
There's no real
optimizations done yet.
So Mario wrote some
genetic algorithm
to actually improve
schedules and so on.
So this is just a
guessing-- some constraints.
And we get a
fantastic result. So I
think this is very encouraging.
Now let me come to
implementation aspect.
So I think this encoding aspects
are already very encouraging,
but in combination
with implementation,
it's even more encouraging.
Let's think first
about the flux qubit.
So why are flux qubits so
fantastic for annealing?
The reason is-- at
least that's what
I believe-- that you can
elongate the qubits, which
means in a condensed
matter of sense,
they're not really nearest
neighbor interactions more,
but they're really
so say long range
interactions in some sense.
Or next neighbor interactions.
So we have these long qubits,
and then you have the cuppers.
And then with the minor
embedding you can go on and on.
Now in the parity scheme,
you don't need any long range
interaction.
So you really only
need to interact
with your local neighbors.
And all interactions
can be the same.
And this opens the field for
all of quantum simulation qubit
platforms.
And this is something
that I really
like because we can
actually get a hold
of all different communities
into the annealing business.
And these are some
examples of people
that we are collaborating with.
So these are all setups
which have sort of say
this square lattice
structure, and which
can make the four body terms.
Just as an example,
maybe due to the time,
I will make this a bit shorter.
With Rydberg atoms.
So there is a whole
community on Rydberg atoms.
Mark Saffman, in
Madison, Wisconsin
with whom we are
collaborating here,
has a very nice experiment which
combines Rydberg and cesium
atoms.
And in our group,
Rick and Alex, they
worked out a scheme
how to do the parity
scheme in this setup.
And this is a very
natural set up.
They have this basically
already running.
So I think this could be
very interesting to do
some test beds real experiments
already in these systems.
Other implementations
include trans ones.
So here we have a paper how we
would do this with trans ones.
This is probably not optimal
from the number of [INAUDIBLE]
qubits that we need.
But it has some
advantages in life times.
And then there's also
flux qubits by Paul,
that we heard yesterday.
And how to do the four body
terms with flux qubits.
With Stefan Philipp, who is
also here, this, I think,
is a very nice or a
very natural set up.
But they looked at this fixed
frequency rotating frame
qubits.
There was the talk
also yesterday
in the [INAUDIBLE] scheme.
And what they have is
like in this scheme here,
two cupped qubits.
And the Hamiltonian
that they can get out
is contains xx,
yy, cc, x, and c.
So all we need.
And this is here worked
out for two qubits.
But what they can also do is
take an add additional qubits
and make n-way couples.
So these are not n body
couples, but n-way couples.
Which means you have
n parent direction.
So you have five qubits,
and you can get an all pair
interactions simultaneously.
And you get simultaneously
x and c direction.
And this means we have
a five way couples.
You can immediately make
the four body blockade.
So you declare one as an
[INAUDIBLE] and the rest
is the logical qubits.
And from this, with
the five way couples,
you can immediately
builds the parity scheme.
And what I would like
to emphasize here
is that we also
have the xx terms.
And they have the same physics.
No, so they have the
same constraints.
Which means we have n squared
nonstochastic terms which
we can also program.
So I want to make an
exclamation mark here.
Now as a last
point, applications.
So can we also think of
applications who we directly
profit from the parity scheme?
Let's think about the
restricted boards from machine.
We heard two to talks
yesterday by Ames and D-Wave
on the restricted
Boltzmann machine.
So I can make this very quick.
In the restricted
Boltzmann machine,
we have to [INAUDIBLE]
that layer.
We have already seen this has
a very natural implementation.
And in the unsupervised
learning, what learning
means is that we maximize
this marginal probability
for divisible layer.
Another suggestion
by many groups,
so I hope I've cited everybody.
But there were two
talks yesterday,
which basically said well,
in the Hinton update rule,
we look at the gradient
of our likelihood.
And this then
gives us two terms.
One which is simple,
and one that is hard.
Hard in the sense that
we have to sample it.
And this will be sort of say
these two paradigms of D-Wave,
one where we have
the optimization one
would have to sampling.
And in this case, we wouldn't
do the sampling on the annealing
and update our weights.
Now what I would like to
do is go back one step
to the maximum likelihood.
This is an optimization problem.
But the problem it is
an optimization problem
where I have to update
the weights, which
are interactions, and the bias.
And this is very unnatural
in physical systems
that we optimize
for interactions.
Actually, if we have the
spin glass picture, what
we would have to
do, we would have
to make the interaction
somehow dynamic.
Now in the parity scheme, the
interactions and the biases
are local fields.
So this means can we just
make the local fields
dynamical variables?
So I replace the local field
by an additional qubit,
which is now a variable,
which interacts with sigma c.
And then I have to give the
neurons also some dynamics.
And if I do this, then so here
I have an illustration of this.
So this is my restricted
Boltzmann machine.
The visible layer, the
input of my visible layer
will be the final state
in the c direction.
So this would anneal
into the final state.
And all the rest can
completely relax now.
And what we see here,
these are the neurons.
So they have the
four body terms.
And then the yellow
and the red part, this
is sort of the memory which
is now dynamically variable.
So this is this additional
local field variable
that I have introduced here.
And this is a back action from
every pattern that I learn.
So every time I learn a pattern,
this vector on the [INAUDIBLE]
changes.
And this is then the
learning mechanism.
So I can do with the
likelihood maximization
as an optimization,
by introducing here
these local fields.
And I think that's an
interesting application
for the parity scheme.
Another interesting scheme
is the Hopfield network.
Think I'm running out of time.
But let me just
show you one idea.
What I would really like to do--
So this is a bit semi-classic.
And so here in the
Boltzmann machine,
I have still individual patterns
that I have to learn it.
What I would really
like to do is
I would like to give him all
patterns at the same time
as a superposition.
But how do I create
a superposition
of arbitrary configurations?
I could use a help
field network.
The problem with the
help field network
is-- or the idea would be let's
make a help field network where
I learn the patterns.
And then anneal into
the final state.
If this is a degenerate
ground state, and I
have a superposition
of my states.
Now the problem is they
are not degenerate.
They are actually local
minims, but they are not
really degenerate.
And I can measure
this by looking
at the standard deviation.
Now by adding the three
body and four body terms
that I have available in my
parity scheme from the schemes
that we saw before,
I can actually
make them more and
more degenerate.
So what we see here is a
measure for degeneracy.
So 1 this bad and
0 would be perfect.
Degeneracy is the
logarithmic scale.
So this would be help field
network with only two body
terms.
If I add now three body
and four body terms,
this goes down dramatically.
And this copy-- so
to say the first step
to introduce something like a
superposition of configurations
that I can then give the
Boltzmann machine which has
the dynamically local fields.
So with this, I would like to
thank you for your attention.
[APPLAUSE]
SPEAKER 1: Great.
Yes, please?
AUDIENCE: I have a question.
So using cleek substitution,
we can turn an n body term
into a quadratic term
into a two body term,
with n minus 1 over 2
auxiliary variables.
So for n equals
4, a quartic term
can become a quadratic term with
only one auxiliary variable.
So really what I'm interested
in is turning quartic terms
into two body terms with
0 auxiliary variables,
or quadritizing higher
order, like five body,
six body, seven
body interactions
into two body interactions
with less than n minus 1
over 2 auxiliary variables.
So what I wonder is
for an n body term,
how many auxiliary
variables do you
need to turn that
into a two body term?
WOLFGANG LECHNER: So
what you're suggesting
is to reduce everything to
a logical two body term.
A logical two body problem.
Is this what I suggest to you?
And so you want to take a
logical problem with n body
terms and reduce it
to a two body terms?
AUDIENCE: The impression
I got from your talk
was that you need auxiliary
variables to-- you
need auxiliary qubits
to perform your scheme?
WOLFGANG LECHNER: Yes.
AUDIENCE: How many auxiliary
qubits do you need?
WOLFGANG LECHNER: So
1 per 4 body term.
AUDIENCE: 1 for
a four body term,
which is the same as
kleek substitution.
And for a 5 body terms?
WOLFGANG LECHNER: I
don't need five body--
so physically I have only
four body terms maximum.
AUDIENCE: OK.
Got it.
Thank you.
WOLFGANG LECHNER: Thank you.
AUDIENCE: Just a comment,
really to advertise my own talk.
But we already showed--
well, in fact, in 2014,
you can actually
do everything you
did with just two
dimensional Ising
interactions nearest neighbor
without any four body
terms or anything.
Without anything
beyond two body,
and entirely nearest neighbor.
So I'll talk about
that in an hour's time.
But I think I somehow I
think we post our paper.
And well, we were theorists.
We didn't probably make it
very accessible to people
who are trying to do
really practical things.
I'm not trying to say
there's obsolete everything.
Because our construction is
polynomial overhead, but very,
very inefficient.
I think there's an
interesting dialogue
to be had between what we
show is possible theoretically
in principle, and what
can be done practically
without ridiculous overhead.
AUDIENCE: I just want to
mention that here it's
about the fact that your
program in the local fields,
not in the interactions.
AUDIENCE: So Wolfgang,
fantastic talk.
Thanks for a super
interesting subject.
I was really intrigued by
the leaf propagation error
correction scheme,
and then Mario Konz's
techniques for using
genetic algorithms
to sort of program schedules.
Do you feel that there
is a future for being
able to find techniques
like that that
would be efficient to run,
to sort of correct errors,
so that you can boost
those success probabilities
coming out of the system with
the error correction schemes,
but having them be small numbers
of steps as posed processing?
WOLFGANG LECHNER:
Maybe, I don't know.
So it's a classical
error correction.
And I think we already
identified yesterday
that error correction will be
important at some point, no?
SPEAKER 1: OK, any
last quick question?
AUDIENCE: I'm really
intrigued by your idea
of approaching the
restricted boltzmann machine
training as an
optimization problem,
and treating the connection
weights and biases
as a dynamical variables.
But in that case, the solutions
to the [INAUDIBLE] problem
you would get would be
binary, not real valued?
So have you tried that?
Does that affect accuracy?
Does it work?
I'm curious.
WOLFGANG LECHNER: so that's very
preliminary, what I showed you.
AUDIENCE: It might work.
Some people in
the room have look
at binary classifier weights.
And found it--
WOLFGANG LECHNER: So I will
be very interested in this.
Thank you.
AUDIENCE: OK, then.
AUDIENCE: So you
didn't mention it,
but the gap on the spectral
properties of the system
optimum embedding
significantly changes.
So do you know under what
conditions you do not
end up with an exponentially
small gap after embedding?
WOLFGANG LECHNER: So
how much the gap closes?
How much more it closes?
So I don't know.
But so I said the gap is always
a property of the whole quantum
particle, not just sort of
say the embedding at the end.
And I think the n squared
sigma x terms would help us
a lot there.
SPEAKER 1: So I think that
question about the gap
is probably going to be
addressed in the next talk.
Let us thank Wolfgang again.
WOLFGANG LECHNER: Thank you.
[APPLAUSE]
