- You talked about some work
that was carried out at EPFL in Switzerland
and the title could have been
Entanglement For Beginners From Beginners,
because it all started in teaching.
As soon as IBM released the quantum experience online
we started to use it in our quantum computing
and quantum information in class.
And pretty quickly the students started to work
with the Q skit in evenings and at night.
And then we had the group of students,
not only from physics, but also computer science,
and actually the work was not any more teaching,
but actually starting to be research.
So I will talk about the subject
we wanted to investigate, entanglements.
So entanglement is a fundamental resource
be it for building quantum networks
or for some quantum computing algorithms
and we wanted to look at some of the behavior
of entangled states.
So there are two, particular one of multipartite
entangled states, that's GHZ and W states.
And they are interesting because they have very different,
but complimentary behavior.
And typically the GHZ states is fragile against loss.
And the W States on the contrary are robust
and they are used then for quantum memories for instance.
So how do they behave when we scale,
when we make them bigger and bigger?
So, first of all, we just looked at what was done
first with the IBM quantum computer.
And there were first experiments showing that it's possible
to build a such entangled states
with a large number of qubits.
So what we did was we were able to efficiently generate
these entangled states if we want to use them.
So we developed an algorithm to make them with logarithmic,
time complexity, and then we implemented it
and we characterized it and at the same time,
since we were still teaching,
we looked at what kind of tools
we can use to characterize this entanglement.
So this enabled us to build states, deterministically
compared to what can be done with optical computing,
for instance, and with a large number of qubits.
So to start, let's look at how we can generate same POG
as the states.
So typically we can do a linear extension
where when we want to add one qubit,
we just linearly extend with ancilla qubits.
And then the idea behind the very simple logarithmic
algorithm for the GHZ is that we can see
that we can rearrange the CNot Gates
without changing the outputs.
But what we can try to do is to make time slices
within which we can do the operation in parallel.
So if we look at this first time slice,
we see that we can operate this two CNots at the same time,
because two qubits are not connected.
So if we look in this simple case,
we go from one + five steps to one + four steps.
So if we start to generalize it for two to power M States,
this is the idea, we do these time slices
so that we can do steps in parallel.
And then if we want to do it for all N in the algorithm,
we just do it in a way that we remove some of the steps
and we end up that it works also for all type of N.
So overall for the GHZ States,
what the idea that we start to see
is that we can do it with N gates
and that the time complexity is logarithmic.
So now, if we look at the big more complicated W states,
we start with the building block
which is a building block that you would use
even for linear construction of the individual states.
And if, for instance, speed would be 100 feet
would be like a controlled under my gates,
and this we can easily implement using the U3 gate
from the IBM cube.
So then using, again the linear extension to make it,
we would just cascade the blocks
and we choose the probability so that at each step,
we will add the one of the W States.
And by using the same idea for the GHZ,
we can make time slices.
So here if we look at the simple case of N equal eight,
it's a simple case because it's two
to the power of something.
And also the portability is 1/2 everywhere.
So if we look at it, we also see
that we can have these times slices
where we can do the major block in parallel.
So it's the same idea as for the GHZ
and the complexity for the same reason is logarithmic.
And what is very interesting is that in fact,
we could identify your tree structure.
If we look inside is a different time slices,
we can extract what is a dichotomy tree,
which is the decomposition of a number
into N/2 + N/2 and using this tree.
So we can first do the dichotomy tree.
And then these dichotomy tree will tell us
which of the qubits needs to be connected
so that we can have the minimum number of time steps.
And in fact, this we could generalize for all N
not using perfect dichotomy tree,
but what we call best possible dichotomy tree,
where we look at the lowest bound and highest bound
of N/2 so in the end we don't have symmetric dichotomy tree
but we can do the same procedure
and build logarithmic circuits.
So here is an example for N equal six,
and we have the same complexity.
So as for the architecture, so we use the 16 qubit computer
and already some of the problem starts
when we started to hit N equal 14,
because the number of connections required our log N.
So that's also according to the IBM team.
We would love to use a 20 qubits computer
for making these experiments,
because as we see for the next step of characterization,
it actually makes a big change for the fidelity.
So once we implemented it, we wanted to look at the quality.
So the first obvious thing was to look at the tomography.
So here it's only the absolute value of the density metrics.
So here, this is for GHZ states, N equals three and four.
That's what we expect from the simulation.
That's a typical topography for the linear algorithm
and with the logarithmic algorithm.
But for now it's only visual characterization.
We did the same for the value state for low N
but then the issue is that the tomography is forceful
and expedition values to be computed.
So at the time we did this experiments,
when we started to reach N equal five it was about an hour
of computation time just for the tomography.
So we decided that this tomography was only for low N
and so it's not a good quantifier of how good we are doing
with logarithmic complexity versus linear.
So we started to use the fidelity
and to compute it from the tomography we used.
And it was our first characterization
of how the logarithmic algorithm doing in term of quality
when we generate GHZ on the value state.
And from this we see already that for even small N
we perform better in term of fidelity.
So next was how do we do for the GHZ States
when we go to large N, what other tools could we use
to characterize basically the coherence of a bigger
and bigger entangled state.
So we use the so-called parity oscillations,
which were used already in the past, in the community
with ions and the idea is to look at the parity oscillations
of going States.
So here, that's an example for GHZ States
small n equal 16, and then looking at the decay,
we just do this by decision
and we put an increasing delay time,
and we look, how are these oscillation doing over time?
And in fact, when we do this, we can look at the coherence
for an increasing N and we see that there is a exponential
decay and then we can do this for different time.
So what we say is that for a given N if we take an equal one
as expected the de coherence we can fill it with exponential
decay and then we see that the starting coherence
is worse and worse because the circuits to generate
larger entangled states is longer and longer.
So we can normalize this to the initial coherence
and look how does the coherence of a large entangled states
depends on the size of it.
And what we observe for the GHZ states
It that's it's a linear gross.
And this is interesting because when we compared it
to the literature, for instance, with ion qubits,
they have non linear dependence due to, for instance,
magnetic noise or, or other type of noise.
So that was very interesting for us to look at the scaling.
This was one of the main question we had,
and that led us
to this logarithmic step complexity algorithm.
So then for the W States, the parity decay,
the parity oscillation decay doesn't work.
So we decided to do partial tomography.
So what we call partial tomography is that the W States
with N qubits we expect to have N probabilities to be 1/N.
So we only look at this specific one, for instance,
if we zoom for N equal three we expect the three blue
histograms to be 1/3.
And then to quantify how would we do?
We use the Kolmogorov distance,
which is the distance between different histograms
to look at how we do,
sorry for the quality of the renderings.
And what we see is that for the logarithmic algorithm,
we can have Fidel deterministic creation of entangled states
for larger N because actually when we hit one,
we have basically no entangled states.
So as a conclusion, going from the teaching tool,
we were able to develop algorithm
to deterministically generate entangled states quickly.
And also interestingly for a network configuration,
we can do it with arbitrary N so if someone wants to come in
and be part of this entangled state, we can do it
still with the same complexity.
And so, just to mention that we were interested there so
in looking at the effect of quantum error correction
to see if we can perform better, but from the test we did,
it was just hopeless with the difference rates
that we experience.
So as a final words all of this was really student teamwork,
and this was a great adventure.
And so as a few other people said,
the tool to train the future quantum engineers,
Q skit is just wonderful.
Thank you.
(audience claps)