- Good morning,
and thank you for joining
this next edition of Nano Explorations.
I hope those of you from MIT
had a chance to enjoy last couple of weeks
of possibly getting back into your labs
and resuming all of the research
that is waiting for us
back in those laboratories.
My name is Vladimir Bulovic,
I'm the director of MIT Nano,
and this morning,
I have an absolute pleasure
to introduce Morten Kjaergaard,
who he is a postdoc in the
group of Professor Will Oliver.
They're doing remarkable
explorations of quantum computing,
and I am very excited to
hear Morten talk about
the programming of quantum computer
with quantum instructions.
Just as in previous Nano Explorations,
I would ask you to turn off
your video, mute your volume.
That way, we will one,
increase the bandwidth for the rest of us,
and also not interfere with the voices
that might be in the background.
If you have questions for Morten,
please keep them towards the very end.
And at that time,
I will call upon you
if you raise your hand,
or you can send a chat message,
and I will relay your question
from the chat to Morten.
With that being said,
Morten, please take over.
- Thank you Vladimir,
so it's a great pleasure
to, firstly, be here today.
I don't know if that's a
euphemism that we use right now,
but it's a great pleasure
to be able to give this talk to you today,
and I hope you're all safe and well,
wherever you are.
So for the next roughly 25 minutes,
I'll tell you about some
results out of our group,
the Engineering Quantum Systems group.
Oh, and let me just make sure
that you can all see my mouse.
Vladimir, can you confirm
that you can see my mouse
so I can use it as a pointer?
- [Vladimir] Ah yes, I can see your mouse.
- Fantastic. Okay, great.
So I'll give some overview
of what we're trying to do in general
with quantum computers,
and specifically what we call
a super quantum computer,
and then in the latter half of the talk,
I'll dive a little
deeper into some details
of some of the experiments
that we've been working on, lately.
And normally, I'd encourage
anyone to interrupt me whenever you want,
but I'll keep the talk itself brief,
so there'll be plenty of
time for Q and A afterwards.
Okay, so with that being said,
I mean, what's the point about even caring
about building a quantum computer?
And so lemme briefly define
what a quantum computer is for you guys,
and I'll give a couple of details
that are typically omitted
when one hears a one-sentence
summary of quantum computers.
So the idea is to use
computations using quantum bits.
These are, essentially,
quantum two-level systems.
Now, these computations
have to be performed
in a highly specific way.
If you do that, these
quantum computers can provide
computational speedups
for certain problems.
And I highlight here in
red these two clauses
that are typically not
brought to the forefront
when one hears a brief
description of quantum computers.
So I wanted to spend a few minutes
talking about exactly what I mean,
let me just start my timer, here.
Okay, so what I mean by certain problems.
So if you ask a computer scientist
to lay out a map of the world of problems,
they would, at least, draw
part of the map like this.
So you can imagine if
I gave you some problem
and I asked you how hard
is this problem to solve,
you can kinda make a ranking
of the hardness of these problems.
And at the bottom of this rank,
let's just say some of
the more easy problems,
they're called problems in P,
and P has a rather obtruse meaning,
so I won't go into the
details of why it's called P,
I just hope you'll trust me
that we'll use the word P
to define problems that
are efficiently solvable
and checkable on classical computers.
Okay, so here are some concrete examples.
Is this number a prime number?
Turns out, the answer is yes.
Maybe you learned this
algorithm in grade school,
given some number,
you can pretty quickly
determine if it's prime.
And solving a Rubik's cube,
that's also pretty easy.
That's why, maybe you've
seen these videos on YouTube
of these amazing 9-year-old kids
that solve a Rubik's cube in 20 seconds.
That's because it's a
very specific algorithm
for any Rubik's cube,
they'll pretty quickly find it's solution.
And, of course, it's easy to check
that your Rubik's cube is solved quickly.
You know, just stare at it
for a second, turn it around,
and you can see all the
sides are the same color.
And finding the shortest path,
here's one in green, which
leads between two points,
that's also a P problem.
Now there's a much
larger class of problems,
which is a lot more interesting subject.
So this is called NP.
And again, the name's kinda obtruse,
so I'll just stick with the acronym NP.
So these are the problems that
are efficiently checkable,
but not efficiently solvable,
on a classical computer.
Okay, so here are some famous
examples from that group.
One is what I show as a cartoon, here,
called the traveling salesman problem,
and the problem here is, just so you know,
if their path connects with
25 larger cities in the US.
That's less than 6,000 miles, for example.
Now, it can be very
hard to find that path,
but once you have the path,
it's pretty easy to check.
It's less than 6,000 miles
and just go to Google Maps
and you'll see that you're all set.
Protein folding is another problem in NP,
and here on the right,
I show something called a clique problem,
which you may not have heard about,
but the idea is that
each of these nodes here
can represent a person,
for example, a Facebook user,
and you can ask, is there a
part of this network of users
where all the users know each other?
It's called the clique problem,
and you can imagine
that problems like this
have broad use in classical
data analysis of networks,
such as Facebook, Netflix,
and so on and so forth.
So these are all NP problems.
And now I wanna tell you about
this other class of problems
that's the one that relates
to quantum computers.
It's called BQP, again,
the name's obtruse,
we'll stick with the acronyms.
And these are the problems
that are efficiently solvable
on a quantum computer.
The amazing thing here, you'll notice,
is that BQP has some overlap with NP.
So some of the problems that are in NP
that are very broadly
interesting are also in BQP.
So the thing is, the problems
that used to be very hard,
essentially impossible,
as the problems become big enough,
become solvable on a quantum computer.
This is what I mean by certain problems.
Let me give three examples
of quantum computering.
So now let's take the same
number that we had before,
but I'm not gonna ask
if it's a prime number.
I'm gonna ask what are the prime factors?
That is to say, which two
prime numbers do I multiply
to get this number?
That's one of the things
that's much, much, much faster
to do on a quantum computer.
There's a thing known as knot invariance,
it's a really beautiful
mathematical theory
that tells you that these five knots,
although they look distinct,
they are, in fact, the exact same knot.
It's called the knot invariant.
And perhaps, most importantly,
and maybe most applicable in the new term,
is the notion of quantum simulation.
So here I've just taken a
picture of a bunch of spins,
they are on ladders,
and you could imagine asking, of course,
all kinds of questions about these spins.
Depending on how they're
coupled and so on and so forth,
you'll be able to do quantum
simulation of the large systems
that are essentially intractable
on classical computers,
and in fact, the proof
that quantum computers
can solve these quantum
simulations problems
exponentially faster was
developed by Seth Lloyd,
who's a professor here at MIT.
Okay, so with that kind
of brief background
on where quantum computers
fit into the landscape
of solving problems, I wanna turn to,
so this is just a one-liner,
that quantum computers
fundamentally change
what is computationally feasible.
So now I wanna change to showing you
kind of where we are now,
or at least in one aspect of
where we are now in the spring.
So late last year,
something known as a
superconducting quantum computer,
I've spent a little bit of time
explaining what this word
superconducting means in this context,
but this quantum computer outperformed
the world's largest
classical supercomputer.
Pretty phenomenal,
experimental demonstration.
So here is a picture, very
much a cartoon picture,
of the quantum processor that
was used in this experiment.
Each of these gray x's are
aluminum micro fabricated,
essentially capacitors,
we can imagine one of these x's,
you should think of it roughly
a couple hundred microns by
a couple hundred microns,
to give you a sense of the scale, here.
So this was supposed
to have been 54 qubits,
but one of them didn't work,
so this is a 53 qubit quantum computer.
And these blue guys are just couplers
that can turn on and off the coupling
between these quantum two-level
systems, these qubits.
And down here is just a cool picture
of the actual chip itself.
Where this black box right here
is where these nanofabricated qubits live,
and all these wires out here
are just control electronics.
So lemme show you this plot
that is, in some sense,
the first demonstration
of a quantum computer
outperforming the world's
largest classical computer.
Okay, so what's going on here?
So on the x-axis of this first panel,
you have the number of
qubits that are involved.
On the y-axis, you have the quality
of some calculation that was performed.
I'm not gonna go into the details
of what exactly was calculated,
but they calculated one of those things
will be expect to be
very hard, classically,
but quote-unquote easy
on a quantum computer.
So let's focus up here at 53 qubits.
This is where they used
the full power of the quantum computer.
Let me just move this over.
So here they used the full
power of the quantum computer.
So what they do is they
execute this program,
and then they try to simulate
using the supercomputer
the same quantum program
using classical resources.
And over here, it took
them roughly five hours
to confirm the quantum calculation,
and using the quantum computer,
it took roughly 200 seconds.
So now they can do is they can
extend this even further out
by slightly changing the program
that the executable quantum computer,
making it even harder for
the classical computer
to confirm the calculation.
And so what they end up with
is this estimate of roughly,
and I should really
emphasize this is estimate,
because, of course, they couldn't do it,
but if they used all the
resources on this supercomputer,
it would take roughly 10,000 years
to confirm the output
of the quantum computer.
And it took 200 seconds.
So here's the one line summary of that.
They used 53 supering qubits,
a specific type called a transmon,
in case anyone has heard about this,
and this is the result from
the Google Quantum AI team,
and they took roughly 200
seconds to do something
that's expected to take
between 10,000 years
but, in fact, all the way
down to just a few weeks,
because, of course,
after this initial
experimental demonstration,
there was some theory
follow a work by other team,
who maybe were a little bit jealous
that showed that you can, in fact,
speed up the classical
simulation somewhat.
But even in the most pessimistic case,
you're still doing
something in 200 seconds
that is expected to take
between two and three weeks
on the world's largest classical computer.
So this is kinda state-of-the-art.
So where is the field now going?
So this'll be almost my last intro slide,
and then I'll begin a few more details
I've already been doing.
So quantum computing using supering qubits
is kind of built on a foundation
of these four pillars,
which is classic control, that is to say,
we have to deliver some signal
down to a quantum computer.
This is typically a dilution refrigerator.
So for those of you who don't know,
these are refrigeration units
that cool down to just a few
millikelvins, essentially.
These are, of course, big beasts,
and they have to be
very carefully shielded,
both thermally and electrically.
And so delivering the classical control
to the qubits themselves
is a rather hard task.
We're also working on improving
the physical qubits, themselves.
We're working on improving
the readout of the qubit.
That is to say, when you ask a qubit,
are you in a zero or a one state,
the quality of that answer is, in fact,
itself a very large research direction.
To basically push up our
confidence in these numbers.
And finally, we're working on
improvements to native gates.
And this means that when we try to do
a logical operation on
your quantum computer,
so you're trying to
flip a bit, for example,
we call that a gate, or a logical gate.
It's a nomenclature from
electronic engineering.
And the notion of native gates
is just what's the easiest gates
for the quantum computer to use.
So we're trying to improve
all these four things,
essentially, each of
these boxes are large,
independent research fields, essentially.
But, built on this foundation,
there's kinda two tracks
being pursued simultaneously
in the world of supering quantum computer.
And I should say several other
quantum computing architecture, as well.
So one is this idea of something called
a fault-tolerant quantum computer.
And the idea here is that
if you take some of these,
let's say noisy qubits,
so I should say that
the state of the art error rate for qubits
is roughly one in a 100.
Something like that.
So this means that actually try
to perform some calculation,
every, roughly, this is very rough,
one out of a 100 of your
logical operations will fail.
Now, just to put that into context,
if you pick up your mobile phone
and you ask how many errors do I get
in my processor on my phone,
you're looking at roughly
one out of a 10 to the 15.
So I guess on the order of
one in a billion billion.
And on quantum computers,
we're looking at one in a 100.
So errors are abundant.
And so there's this idea
that you can put together
many noisy qubits
into one larger qubit,
it's called a module qubit,
which will, essentially, be error-free.
So this is it's left pathway.
But then there's other
path, here on the right,
which is also interesting.
And this has the kinda nickname
noisy intermediate-scale
quantum computers,
and the idea here is
even though your qubits may
be noisy and have errors,
if you really bend over backwards
and stretch all the
resources as much as you can,
maybe by improving the native gates,
maybe by some fancy
connectivity between qubits,
or maybe you find some way
of getting rid of noise,
you can build a tailored-
this is what we're trying to
show with these Tetris pieces,
you put these Tetris pieces together and,
ultimately, you're able to
perform some calculation
using a quantum computer
that's outside the reach
of classical computer.
And this experiment I
showed on the previous slide
is an example of this,
where, you know, they really eked
every little thing they
could on every component
and they were able to
execute this algorithm.
Okay, so now I wanna take a step back
and tie it in to some of the
research that we have done.
So I wanna ask the question
how are quantum computers programmed?
Okay, so here, again,
this is data from before,
where we saw this point
out here using 53 qubits
and sequence of 20 gates on each qubit.
So how is this actually programmed?
So here's, again, the processor.
So let's just now focus in on the example.
There's a little grid here.
Five qubits and four of these couplings.
So here's another figure from this paper.
It's just a blow-up of this
little section right here.
So here's the quantum device itself,
and remember, these gray x's
are basically aluminum x's
that are roughly 200 by 200 microns wide,
so this cutout, here,
is on the order of a
couple hundred microns
by a couple hundred microns.
So here on the right is what's called
a musical score for
programming quantum computer.
And each of these black lines, here,
represent what happens to each qubit.
And the x-axis, here, is time.
And these little boxes indicate
something that happens to the qubit.
I won't go into the details
of exactly what happens,
but this, for example, logo right here
means that you're
performing some operation
on this specific qubit,
and this guy indicates an
operation from this qubit.
So if you go read the paper,
you'll see that one of these cycles
is on the order 50 nanoseconds.
So this means that this
sequence we're looking at, here,
is roughly, let's say,
500, 400 nanoseconds.
So this is some kind of a musical score
of instructions about what to do.
You can see these couplers,
here, for example,
green guy, he couples
this qubit to that qubit,
just as I promised,
and this is now what's called
a two-qubit native gate.
So here are a couple of qubits.
Okay, so this means that
here are quantum hardware.
This is the actual qubits, themselves.
And here, you have a classical instruction
about what to do on that
quantum hardware, right?
Because these boxes, right here,
you can think of them just
like this is an array,
if you like to think of classical program,
just an array of instructions
about what to do,
for this qubit,
which is just an array of instructions
about what to do on that qubit,
it's, of course, easy
to write down 53 arrays
that each have, let's say, depth,
or number of cycles n equal to 20,
like this is totally trivial
to write down on a classical computer.
Okay, so this is how you interface
with the quantum computer.
So now, I want to go a
step even further back
and talk about a very,
very fundamental property
of classical computers.
In fact, it's so fundamental
that one barely even thinks about it
when just interacting with
a computer on a daily basis.
So there we turn to this picture.
I should say that this is
the hand of Barbara Liskov.
She's a professor and
(indistinct) here at MIT.
She was one of the pioneers
of classical algorithm theory
and classical data abstraction theory.
And she's holding, here, a punchcard.
So this is an old way to interact
with some of the earliest computers,
and roughly speaking,
the way that these punchcards would work
is that some section of the punchcard,
let's say, for example, left
side, would contain some data.
And the right side would
contain some instruction
about what to do with that data.
So you could imagine
that this data over here
is some number, 1 million 256,
and this sequence over here
tells the punchcard computer
what to do on that data.
Maybe this is exactly the sequence
that means take the
logarithm or something.
So now what would happen
if you took this punchcard,
flip it around 180 degrees,
and stick it into the machine?
The punchcard machine would
still try to read the data.
It would just read the
instructions as data,
and then it would read
the data as instructions.
But in principle, the computer
can't know the difference.
So this means that data
instructions of classical computers
are basically part and parcel,
they're somehow the same thing.
This has a fancy name in
classical computer science,
it's called homoiconicity.
The slightly more informal
version of this word is
code is interchangeable with data, okay?
So this is very, very basic property
of essentially all classical computers
in many, many programming languages.
Okay, so at a slightly
more abstract level,
what's going on here?
You can imagine how some instruction set
defined by some function,
which could be some bit string,
then you feed this bit string
into your control layer,
and the control layer will say
okay, if I get three zeroes,
that means that I do
nothing to the first bit.
If I get one one zero,
then that should be part of an and gate,
and so on and so forth.
And so, you have an
instruction on what to do,
you feed it to a control, here,
it says okay, I have to execute
the sequence of classical logical dates,
and then if you actually
wanna apply this data,
for example, this has to
be the logarithm function,
well, here's your data.
You feed it into the function,
and you get some new number out,
also representative of the binary number.
And again, here you can see it clearly,
with the instructions,
the language of the instructions,
is the same as the language of the data
of the algorithm you're trying to find.
Okay, so here the code is classical.
And the data is classical.
So I'll just look at this
example I showed before,
of how to program a quantum computer.
So let's just focus, for example,
on this panel right here.
So this is just a very
basic quantum computer
with a single qubit inside.
And I just want to perform
one operation on that qubit.
Now, I will still have to
tell my classical computer
to send some signal down
some wire to hit this qubit.
You can imagine you are
sitting in a classical lab,
all the labs at MIT are classical,
you sit in this lab,
and you wanna generate
some electric signal
that gets delivered to the qubit.
That's a classical interface.
And so here, just as a cartoon,
I just showed this bit stream
right here, just an example.
Maybe this corresponds
to performing this specific
operation with the qubit.
Nevermind what this actually means,
it's a material for this example.
So then what happens when
these boxes still gray,
gray means classical computer,
that finally, this electrical signal
gets delivered down to
the quantum device itself.
So here, I now change the
color of the box to blue.
So this symbol represents
some quantum state
that's fed into your function
and now call on function u,
because that's what we
do in quantum computer,
and the function gets applied
with something called a Hamiltonian,
which is essentially just the interaction
between your qubit or
the signal in your qubit,
and the parameters of this Hamiltonian
is given just by the classical
bits that you program.
I can see here are the bits,
and they were a bit of a classical,
and now they're being
fed to the Hamiltonian,
and that's when they become quantum.
So here's just an example
in the multiqubit example.
But the idea is the same,
just looks more intimidating.
So here, the code,
that is to say the
instructions, are classical.
You use a classical
computer, python or whatever,
to generate these instructions.
But the data itself is quantum.
So you can ask yourself,
can I come up with a scheme
for quantum computering?
Where both the data,
but also the code itself,
is quantum, right?
So essentially, restore
the symmetry that we had
in classical computing.
Okay, so the answer is yes,
that's why we're here today.
And so I'll focus on one experiment
we performed in our lab
to show how you can restore this symmetry
to quantum computers.
Okay, so let me unpack a little
bit of what's going on here.
It'll be a little bit of math, here,
but I'll try to keep it as
unintimidating as possible.
So this box right here
is an algorithm called
Density Matrix Exponentiation,
and the idea here is a fall-in.
It's a fixed protocol
that implements some quantum operation
that's only dependent on the setting
of what I'll call the
instruction state ro.
So ro, here, it could
be a qubit, for example.
Just some qubit that
you have on your device
which is a quantum object.
Now you take in-copies of these,
so you can imagine you have
a long register of n
of these qubits set in,
you execute this algorithm,
and you get this operator out.
E to the minus i ro theta.
Theta is just an angle, so
we can ignore that for now,
but the point here is that ro,
what used to be a quantum state,
which used to be the quantum
data that we operated on,
now became a quantum operator.
So just like in a few slides back,
where I had this Hamiltonian operator,
now, up here in the exponent,
now I have a state up here,
a quantum state appears in the exponent.
Okay, now some error
associated with algorithms,
I won't bore with the details
of where that comes from,
but this algorithm was proposed,
in fact, also by Seth Lloyd,
a couple of years ago.
So what does that mean conceptually?
It means that taking this algorithm
allows us to load a program
into a quantum state,
which I'll call the instruction state
or it's called called a quantum program,
or the noted by this Greek symbol ro,
and we can execute that quantum program
on another quantum system, right?
So this means in some terms,
we're kind of back to the
state to do what we wanted,
where the instructions about what to do
is stored in quantum state,
let's say it's a quantum object.
So you could say okay,
why care about doing this?
You know, maybe it philosophically
feels kinda nice to
restore this deep symmetry
between classical computering
and quantum computering,
but there's a really
appealing practical reasons
for doing this.
So it turns out this
protocol is very efficient
for generating quantum instructions.
And so it means that this algorithm
I showed in the last slide
very, very quickly can generate
these quantum operations.
So I won't go into too many
of the unworthly details,
and please ask me
questions in the Q and A,
I'd be more than happy to go into details.
But I'll just give a brief highlight
for those who are maybe
a little bit interesting
that it turns out that there's
an exponential reduction
in resource requirements
over what's called any
tomographic strategy.
So let's just spend one second
to explain what that means.
So you can imagine, you know,
if I had given Vladimir n
copies of this density matrix,
of this quantum instruction state,
maybe he could just measure it
and he could just see what the state was,
and then generate his
own quantum instructions.
But what's amazing about this algorithm
is that I can send Vladimir enough copies
that he can run the algorithm,
but not enough copies that he can learn
what the quantum state is,
because as this experiment I
talked about previously showed,
if you take enough qubits,
it's essentially impossible
to classically wipe down
the components of that state.
So that's one reason why
this algorithm is baffling.
And another reason is that
the run time of the algorithm,
that is to say,
how many of these logical gates
do I need in this musical score?
How many do I need to
execute the algorithm?
And it turns out that you only
logarithmically many gates in
the size of instruction state.
So this means that if, again,
we'll turn to this example
with the 53 qubits from before,
it's essentially impossible
to classically write down
the state of that system.
The matrix is simply too big.
But if you use that state as
a quantum instruction state,
the shortcut for doing that
are the number of lauded steps,
it's still surprisingly small.
So this means that density
matrix exponentiation
and the use of quantum instructions
has found quite a broad
range of applications,
both in foundations of quantum computing
and surprising ways of using
private quantum software,
and so practical protocols
that are also being pursued
in other labs right now.
But please ask any questions
in the Q and A about this,
and I'll be happy to expand upon it.
Okay, so let me give you one slide
about the physics of what's going on here,
and then I'll turn to some of our data.
Okay, so let's unpack
this thing one more time.
So here is now n copies
of my instruction state,
remember, these are, for example, qubits.
These are two-level system, so n of those.
And now I've also introduced
what I'll call a target state,
and basically, I just want to implement
quantum instruction stored in this state
on that target state.
So what you do is you run this operation,
it's called a delta swap,
and this'll be one of the few
equations in my talk today,
so please forgive me if this gets
a little bit in the weird for some people,
but I wanna make sure that
there's a little bit here
for the experts, as well.
So basically, this delta swap operation
swaps the state of this
qubit and this qubit
by some amount to delta.
Here is the matrix that
represents that operation.
So one illuminating case
is if I put in pi over two.
Then I get this very simple matrix out,
which is one on the zero
zero and the one one points,
but that's off diagonal
in this little sublock.
And the interpretation of that,
if you're a quantum computing person,
is that it just swaps the
state of the two qubits, okay?
So I won't go into the process
of how to read these matrices
in case you're not
familiar, unfortunately.
Okay, please ask questions,
I'll be happy to expand upon.
But then what you do
is you throw away this version
of the instruction state.
Then you take your next instruction state
into another of these small
swaps by some amount delta.
Throw it away, do it again
with the third version,
sort of how can you keep doing
this, some number n times?
And what you get out in the end
is this operator e to the minus i ro,
and this is exactly what we wanted,
but ro is living up here,
for those in operator that's
acting on a target state sigma.
And over here it says algorithmic error,
that I mentioned before.
Okay, so that's what we're
gonna be trying to do in a lab.
So here is a picture of our device.
Now it's a real FEM picture,
and this gray color
right here is aluminum,
a couple hundred nanometers thick.
And here's a scale box.
Now you actually see the
couple hundred microns
that I was talking about before.
So here's three qubits,
laid out like this.
The blue lines are for
breeding out this other qubit,
and the red and orange lines
for controlling the qubits.
So here's the target qubit.
This is the guy we're
gonna wanna interact,
or we're gonna want to apply
the quantum instructions on.
And this is the instruction qubit.
And the interesting thing here is
when you choose one instruction qubit,
or physically one qubit,
but it'll play the role of all n copies.
So here were the original
algorithms before,
and now lemme show you
how we turned that into an algorithm
that just uses two qubits.
So I still have my target state sigma
and my instruction state ro.
But now we're doing is instead of having
n copies going down like this,
we'll have n copies going along like this
by approximately resetting ro.
We resetted using a specific date
that we call synergy quantum measurement.
I won't have time to go into
that exactly what it does,
how it works,
but what it does is that it
resets the state of the qubit.
So you can imagine we're
doing a delta swap right here,
so lemme put up these red boxes
so you can see the structure,
so we delta swap these two ryes,
and then we approximately reset,
and so that leaves us at the
same state as right here,
where we have almost a
new copy of this guy,
ready to be delta swapped one more time.
So we go along with this.
And so here we throw away
ro after each interaction,
and here we just approximately reset ro
after each interaction.
So here we're just using two qubits.
Okay, so there's no such thing
as a free lunch, unfortunately,
so this new technique was
developed comes with a price.
And so what happens is
you're gonna look at more
error in your algorithm.
And again, we have proofs
of this in the paper,
but I'll leave that unspoken for now.
Okay, so lemme just show you some data
of how this actually looks in real life,
and then I'll be happy
to take any questions.
So here's an example of this algorithm,
let's fix some toggle
state, let's call it plus y,
and please forgive me if
this is a little bit obtruse
for those who don't know
about quantum notation,
but unfortunately, I could
find no way around this,
so forgive the math here.
But let's fix some state
pointing along the plus y interaction.
And that's execute density
matrix exponentiation,
where we fix the instruction
state to be plus x,
the number of steps to n,
and the total angle
that we wanna try to implement
in this quantum instruction
to be pi over two.
Okay, so just sit down and do the math.
This is a pi over two
rotation around the x-axis.
So here's what the algorithm
actually looks like.
Here are the delta swaps, as I promised,
the approximate reset,
and there's four of those.
We're gonna run the algorithm,
and we're gonna get something
called state tomography.
This is a technique that
lets one look visually
at what the state looks
like as it comes out.
So here's the data.
So first, let's just look
at the first section,
so I grayed out this part.
So let's just look at
the first section here.
So the top row, here,
is the state of the target qubit,
and the bottom row here
is the state of the instruction qubit.
And as I promised, a tiny qubit
points along the y direction,
and this globe, this sphere
that's called a block sphere,
and the instruction qubit
points along plus x,
just like I promised.
All right, here's just a projection
looking down the x-axis
for both of these stilts,
and this is just showing
explicitly x, y, and z components.
Just take the first step in the algorithm,
and you'll see that this
state started to move up,
the target state started to move,
just like it should.
And instruction qubit stayed nearly fixed
along its initial axis,
because it was reset by this algorithm.
Let's do a few more steps, like that.
And what you see in the end
is that this target qubit moved
from pointing along the y direction
to pointing along the z direction.
And if you take the right-hand rule
and you point your sun
in the direction of x,
your pi half-rotation,
like the half is 90 degrees in radians,
and so you see you get this state rotation
by exactly 90 degrees.
And meanwhile, the instruction state
stayed nearly unchanged,
it's going in, like this,
into this sphere, that's not physical.
At the end I'm also
happy to talk about it.
So this is an example
of a rotation of a target
qubit around an axis,
given by instruction qubit.
Okay, so lemme just drop
this little math here
to show here what's going on,
and just show you one last example
of programming these quantum instructions,
then I'll be happy to take any questions.
So let's just run this
algorithm one more time,
but now let's change the
quantum instruction state
and confirm that the program
that's executed is changed
according to the instruction state.
So let's put the instruction state
in what's called a zero state
that corresponds to pointing
along the north and the south pole here.
Let's take eight steps, in
this case, instead of four.
Let's try to do a full rotation of pi.
So if one sits down and does the math
of what this corresponds to,
you're looking at a pi
rotation around the z-axis.
Okay, here's the algorithm again.
So the only thing that changed now
is that the instruction
qubit is in the ground state,
or is in the zero state.
The delta swap is now pi over eight,
and we're doing eight of those in total,
and here's the approximate reset.
Okay, I'll dispense with the animation
and just show you the result. Here is!
Again, the target qubit starts
by pointing along the plus y direction,
and this is a little bit easy to look at
if you're stare down the z-axis,
and there's a projection looking down
from the top of this sphere,
and you'll see that this
thing did a full pi rotation,
that's to say, 180 degree
rotation around the z-axis.
And again, the instruction qubit
stayed approximately where it should,
not withstanding going
into the block sphere
a little bit like this.
Okay, so how I've convinced
that you can execute a program
that's stored in a quantum state?
Specifically by putting
this instruction qubit
in either the zero state or
over here in the plus x state.
You modify the quantum operation
that's applied on another qubit.
This was exactly what we set out to do.
So with that, lemme just leave
you with this outro slide
and say that this
property of homoiconicity
can be restored to quantum computing
using this density matrix
exponentiation algorithm.
We've demonstrated a
proof of principle version
of this algorithm using super qubits,
and this gate construction
for approximately resetting a known state.
I'll spend 20 seconds
just mentioning some of
the collaborators here,
particularly one
highlight, Mollie Schwartz,
who's a research scientist
out at Lincoln Lab.
We've had a wonderful,
fruitful collaboration on this.
Three amazing graduate students,
Ami Greene, Gabriel
Samach, and Chris McNally,
that have played a material
role in this project.
There's Bengtsson,
who was a graduate student
at Chalmers in Sweden.
He's now at Google.
Iman Marvian is a theorist
who was a postdoc here,
now he's working as a professor at Duke,
and then, of course, head honcho, Will,
who was the PLM for this project.
And so, I guess, with that,
let's open up the Q and A,
if there's any questions.
Thank you.
- [Vladimir] Morten, thank
you so much for this.
You have opened our eyes to
a very different dimension
of what we typically talk about,
so thanks a lot. (chuckles)
Pleasure with this,
what I would like to do
is open the floor to any questions.
Of course, lacking any questions,
I'll be asking you a few.
So to start things off, and again,
you can send everyone a chat or just me,
and I'll relay the question to Morten.
Alternatively, you can raise your hand
and I'll make sure I call upon you.
I guess the very first
question to just ask, you know,
as you were showing us the
pi over two and pi rotations,
the length of the vector diminished.
- [Morten] Yep. Yep.
- [Vladimir] Is this
reminiscent to the diminishment
of the strength of a signal?
Is that the way to think of this?
- [Morten] Yeah, that's kind
of the way to think about it.
So what's going on here
is that these qubits have a finite memory.
So that's to say if you take a qubit
and you put it in the one state,
so you can imagine just
taking a two-level atom
and putting the next notation in there.
After some time,
that next notation will
go out of the system.
And we call that a coherence time,
or a subversion of a coherence time.
And so what's happening here is, in fact,
that the qubit, as we're
executing this algorithm,
it's losing its memory.
And so if we kept running this algorithm,
we'd get a smaller and smaller
and smaller vector,
until, essentially, it
would just be stuck in here,
in the middle of the block sphere,
which is signifying that
we've essentially lost all
information about the state.
So this is a reflection of
memory loss in the system.
There's also a reflection
of one more thing,
which is I mentioned this
roughly one percent error rate
in these quantum logical operations.
So we have two sources of error.
One is a quantum memory,
which is essentially
exponentially decaying,
and we have logical errors
from the gates, let's say.
So when we try to do
some specific rotation,
that will have some little
error rate associated with that.
- [Vladimir] The amount of error
very much depends right on
the speed of computation,
I would imagine, right?
'Cause your coherence
time is only so long, so-
- [Morten] That's exactly right.
- [Vladimir] What determines
the speed of your computation?
- That's a great question.
So that speed is essentially set
by the coupling strength
between the qubits and,
essentially, if you couple
your qubits too strongly,
you can't turn off the coupling.
If you couple them too weakly,
your speed of your logical
operation would be too slow.
And so a huge part of this project
I haven't even talked about in this talk
is optimizing these
logical gate operations,
and, in fact, what we had to developed,
executing this algorithm,
is what's currently
the world's lowest error
rate quantum operation,
with an error rate of .3%,
and so, to the best of our knowledge,
this is one of the lowest in the fields,
and we simply needed
this because otherwise,
we would be completely dominated
by the errors of these operations.
- Now my question is to you, actually,
a mix of my own thinking
and a lot of help from online chat, here.
So I'm gonna ask another extension
of everything we've
just been talking about,
which is, of course,
as the dephasing of your signal-
- [Morten] Right.
- [Vladimir] Keeps happening,
Is there a way to refresh
that and start anew?
- [Morten] That's a great question.
So there are a wealth
of techniques that try,
it's called echoing out,
and the idea is that we
can kinda have some error
that rotates you in this plane.
If you know what that error is,
maybe you could flip your state over,
and the error would
somehow cancel itself out,
so it's called echo technique.
And this echo technique
exist for quantum algorithms.
In fact, we are working
on a follow-up paper now,
with Gabriel Samach,
who's one of the grad
students on this project,
showing exactly when you can
do some echoing techniques
and when you can't do some
of these echoing techniques.
It turns out it's quite
a fascinating subject
for new-gen quantum computing.
- [Vladimir] But reading off the state
and then simply replicating it,
'cause you just read it,
would that be an option?
The way you would do it digital logic?
- [Morten] No, unfortunately not,
because quantum computing has this
very, very, sometimes annoying property,
that if you measure the quantum computer,
you lose all of its quantum coherence.
And so that would essentially stop
all the quantums in its tracks,
and there would be back to
a purely classical world,
and then you have to go back
and restart the quantum calculation.
- [Vladimir] A question, again,
this is from Mary Kentle.
You mentioned using quantum instructions
reduces the needed resources.
- [Morten] Yes.
Does your algorithm lower
that requirement further?
- [Morten] No, it does not.
So what our algorithm does-
Well, lemme answer it
slightly differently.
So what our algorithm does
is it trades the use of a single qubit
to supply all of these n
copies that I talked about,
these many copies of qubits,
and you just load that into one qubit.
Now, it adds a little bit of an error
to the algorithm itself,
which we have a surprisingly lengthy
mathematical proof for this error rate,
but nonetheless, there's
some additional error
in your algorithm.
So sometimes, it lowers
the resource requirements,
but at a precision price,
we call that the price of
introducing another error model,
or error node.
- All of your measurements
are done at cryogenic temperatures, right?
To maintain the coherence lifetime?
- [Morten] That's right,
that's exactly right.
- [Vladimir] So in the present
system that is optimized
always uses aluminum capacity
of structures, because-
- [Morten] That's right,
so some folks are, in fact,
using niobium as well,
and there are some,
I think tantalum is another superhard
that's recently been
used in these settings,
but aluminum is by far the
most widely used material.
- [Vladimir] Okay.
And so the scale-up of this
technology to beyond 54,
in this case, 53 qubits
is gonna very much depend on
the next set of
polyfabrication techniques,
to some extent, or possibly
new material discoveries.
- [Morten] Very much so.
- [Vladimir] Are there
any insights you can give us there?
On what is expected, what is needed.
What can MIT Nano do? (chuckling)
- Right on, there. A lot.
That's the short answer.
So there's a really fantastic community
of essentially overlap
between material science
and quantum computing,
what's called applied quantum
computing, in this case.
And it turns out to be an
extremely subtle issue,
exactly what's causing this
memory loss in these qubits.
Of course, we know of the
first five tallest poles
that lead to this memory loss,
but since we solved all those poles,
so now we're down to near the sixth pole,
trying to figure out what's
the next limiting factor.
In fact, there was a beautiful
experiment at our own lab
that I was not involved in,
where they showed that
background radiation,
you know, there's the ambient
radiation in the universe,
in fact, impacts the lifetime of qubits
in some limits right now,
because we've really pushed it out so far.
- I have one more question
that talks about the following.
How do you represent operations
that correspond to statistically
next state for a qubit?
- [Morten] That's right.
So preparing a mixed state, in general,
if you, for example,
take an entangled state,
there's a protocol for
entangling two qubits.
I guess I don't quite know
which level of technicality
to answer this question,
so I'm so sorry if I end up
shooting a little bit in the dark, here.
But essentially there's
definitely a protocol here
for generating entangled
qubits, obviously.
This is what gives the
quantum speedups, in general,
or a part of what gives quantum speedups.
And the remarkable thing
about this algorithm
that I'm (indistinct)
is that it works just as
well for entangled states,
that is to say, a version of mixed states.
So this algorithm does not care
if you input a single qubit,
like I did in our case,
or a entangled state, or
a general mixed state.
- [Vladimir] Okay.
Morten, I'm gonna ask
you one last question,
then unfortunately we're gonna
have to stop, given the time.
But the last question I have is
regarding the size of the qubits that,
in your case, are 100 microns, why so big?
We're used to much smaller things
than when we think spartan,
nano opportunities.
- That's a great question, yeah.
And so I should say you should look at,
for example, something called spin qubits,
which is a lot popular platform
for building quantum computer.
They really are quite small,
they're on the scale, let's
say, 10 to 50 nanometers.
So they really are a nano(indistinct).
So it turns out that having these large,
they're essentially capacitor plates,
in fact, makes you insensitive
to noise arising from the
charge jumping around.
You can make a very
small island of aluminum
and one charge jumps on there,
it'll dramatically
change the energy, right,
going from 10 to 11 exotations.
But if you go from 1 billion exotations
to 1 billion plus one exotation,
well that's a very small
change in the energy.
So this is, in fact, one of the ways
in which the field has realized
you can increase the
lifetime of the qubits,
just by changing the
geometry of this layout.
- [Vladimir] All right.
Morten, again, I can't thank you enough
for providing us such really pedagogical,
insightful, careful way of
thinking about quantum computing.
I think you have made a whole
bunch of extra converts.
You might find yourself
not being able to accommodate
all the grad students who
really wanna work with you now.
(laughing)
But again, I will one more time thank you
for a fantastic talk,
and I will invite
everyone to join us again
this coming Thursday for
the next Nano Explorations.
'Till then, thank you.
- [Morten] Thank you
very much everyone. Bye!
