- All right, so okay.
People asked for references.
This is what I think
are the best references.
So, you will see,
you will see a lot of people
giving you this reference,
Szabo, Ostlund,
but I actually think this
is not the best book.
This is what I think it's really the one
that helped me the most.
So Helgaker, Jorgensen, and Olsen.
And then this other one, it's more,
it's not a chemistry book, it's more from
learning the creation and
annihilation operator,
antisymmetrization,
and that kind of stuff.
I like these books because they are,
they have more like a math feeling,
which some people may
not like but I like it
and they're very compact.
So, I think these books
explains in a few pages
what this other book
takes in like two chapters,
or something like that.
Sorry for the handwriting,
I'll try to make an effort.
And also, I've seen a lot
of people in the chat,
I guess a lot of you are confused
about the fact that these guys
are not bosonic operators
and I knew this kind
of question was coming.
I also made a comment
on Twitter about that.
So what happens, this
is kind of like a bit of
an historical problem because historically
A and A dag operators
have been used for bosons,
oscillators.
And I guess you have seen this
notation from Zlatko's talk
and usually, historically,
condensed matter people
have been calling the creation
and annihilation operator
for electrons C dag and C, okay.
But in this talk, I'm still using A dag, A
to label fermionic creation
and annihilation operator,
this is a bit of a new notation
that has been picked up by
the quantum information community.
So I hope that that
clarifies the mismatch.
So I'm not talking about oscillators,
I'm talking about fermions,
but still I'm using
the same notation.
And yes, another question is that
if we were talking about bosons,
could that be in more than one particle
sitting in each mode?
In fact, the number of
bosons that you can put
on every mode that's not bounded
because there's no exclusion
principle for bosons.
Okay, so I hope that,
I think that addresses
a lot of the questions
that I've seen in the chat.
Let me go back quick to the
slide where I was, one second.
Okay, so we were here and
I was telling you that
even our molecular and energy operator,
or Hamiltonian can be written
as a linear combination
of products of creation
and annihilation operators.
In fact, this is how we do it.
This Hamiltonian, who has undergone
the Born-Oppenheimer Approximation,
so again, we don't have this
guy, this guy is a shift.
So this Hamiltonian
we can now write it as a product
of that kind of operators
that I was telling you before.
So this term becomes what
we call a one body operator.
This term becomes a one body operator.
This term here also becomes
a one body operator.
By the way, some of you may wonder
why we call them one body
if it's a product of two
creation and annihilation operators.
And the answer to that
is so we call it one body
because they remove one electron
from side J and they put it in side I.
So the action is defined
on just one electron.
That's why it's one body.
And this guy is a two body operator.
So this guy here is what
makes our problem hard.
But if we just had this
part of the Hamiltonian,
then everything would be easy,
so actually we would be able to solve
any and everything in linear time
but it's this two body term
which makes things really nasty.
So the interaction of
electrons between themselves.
So you have to think
that one electron moves
and it influences the
position of the other electron
which in turn influences the
position of the first electron
so it's some, like, messy situation.
Anyway, what we're interested in is
at the end of the day, any Hamiltonian
can be written with these
creation and annihilation operator
that I show you, this message.
So, to have such a description
of our molecular Hamiltonian,
we have to do a classical computation.
We have to compute these
one and two body integrals.
This is my best handwriting.
What is this?
So this is a computation which
is classically efficient.
So you take your favorite, you know,
take your favorite classical program, app,
for computation of integrals
and you compute these integrals where
these guys here are the fermionic orbitals
that I show you before.
Once these integrals are computed,
then we plug them back
here in our Hamiltonian.
Our Hamiltonian is fully specified.
So it is classically efficient
to do this computation
and, again, the chemists will know that
I think some very optimized computation
for Gauche orbitals to compute these guys
scaled with the fifth power,
in terms of the number of fermionic modes
that you have in your system.
But, anyway, this is
efficient classically.
Okay, let's move on.
There is other manipulation
of the Hamiltonian
that we can do before starting
to map this object to qubits.
So one of them is the freezing and removal
of fermionic orbitals.
Suppose that the spectrum of
our Hamiltonian looks like this
and we have something like five particles.
And remember that we are interested
in retrieving the lowest energy state,
the ground state energy for our system.
Okay, so these orbitals, sorry,
this is not the spectrum
of our Hamiltonian,
this is the single particle energies,
these are the single particle energies,
which means,
yeah let's not, okay
let's not dive into that,
this is just single particle energies
that are not interacting particles.
If the situation looks like this
and we have, like, five particles,
so what we have is very
low, low energy orbitals
and then we have high energy orbitals
and we have a bunch of
orbitals in the middle,
then what we can assume
is that some of the
electrons are just gonna sit
in these low energy orbitals and not move.
Okay, so suppose that we have,
I don't know, eight particles here.
And if they're just gonna sit there
and don't move and don't interact much
with the rest of system,
basically the idea is
that we can just, like,
take them out of the
game that we are playing,
which is computing the lowest energy state
for the big Hamiltonian.
So we can assume that some
of these eight particles
are now sitting in these
low energy orbitals
and they're not moving,
they're not interacting much
with the other states
and we will see that this
can result in a saving of number of qubits
when we try to map this
problem to a quantum computer.
Actually, this is something that chemists
also do every day.
So this is nothing but
quantum computing, here.
And the same idea we can
apply to high energy orbitals
so we can assume these orbitals empty.
They're empty because we think
we're not gonna get any contribution
to the ground state energy from them.
And then what we really need to address
is kind of like active space.
So we're gonna get a reduced Hamiltonian,
which, it's gonna live in
this active space here.
So we had eight particles
at the beginning,
eight electrons, so what
we're saying is that
four of them are locked
into low energy orbitals
so there is still four remaining electrons
and so the four electrons
are gonna live somewhere in this,
live somewhere in this active space, here.
And then our goal is to find
what's the state of these four electrons
in this active space.
Why I'm telling you all of this,
because if you want to tackle
the lithium hydride challenge
at the end, you're gonna
need these concepts
and also I'm gonna go, in my lab,
I'm gonna go through some
of these simplifications
to get a more compact qubit Hamiltonian.
Yeah, very briefly,
mathematically it means that
if the,
so if our ground state,
if we don't freeze and
remove any electron,
any orbital from our system,
then we can write, we can write,
we can write its ground state
with something like this.
So let's suppose that we
have a system of M particles.
So as a,
as a linear combination
of slater determinants
and the condition on these
slater determinants is that,
if you want, the number of ones
in these slater determinants,
so the number of electrons,
non zero occupied orbitals,
is gonna be M, okay, this
is what this condition
is telling us.
So if we freeze a couple
of these orbitals,
what we're gonna have is that
our ground state, for example,
let's suppose that we
freeze the two lowest
energetic orbitals, then we're
gonna fill them with ones,
so these are filled with two electrons
and then our wave function is
gonna be something like this
so we're gonna take a sum
on states which have now M,
M minus two particles, right,
because we froze two of them.
Okay, so this is the
assumption of wave function.
And you can see, you can check
that by making this assumption
on your wave function,
the Hamiltonian simplifies.
Okay, I'm not gonna go exactly through
how exactly this Hamiltonian simplifies
but these are, for example, some rules,
so the rules will take a while
so I'm not gonna do that.
But you can see that, for example,
if alpha and beta orbitals
belong to this set F,
which is the set of orbitals
that we want to freeze,
then some two body interactions
turn into one body interactions
because you can think of those
two electrons being there
and not interacting with the other ones
so effectively, they're
like static potential
for the other electrons.
A take home message for you is
if we freeze two electrons,
we freeze two orbitals
we're gonna need two less qubits to map
that Hamiltonian to a bunch of qubits,
that's gonna be useful as well.
Okay, so finally, now that
I made this introduction
about how we write molecular Hamiltonian
in a second quantization formulas,
let's start thinking,
let's start to think
about how we want to map
these objects, these
operators, these states
to qubit and state operators.
Okay, so I told you that the Fock space
has size two to the N
but also you know,
you must know by now, I
guess if you paid attention
in the previous classes,
that the Hilbert space of N qubits
has also size two to the N.
So you can see here that this is opening
the possibility for a mapping
because at least we
have, on the qubit side,
a number of states which
is high enough as to encode
all the states in the Fock space.
So a mapping
is possible
between the Fock space
of N, big N, capital N,
fermions, sorry, fermionic modes,
and a Hilbert space of N qubits.
And so to realize this mapping
we're gonna need two ingredients.
First of all, we have to define
a mapping between states.
So, a mapping of slater
determinants to qubit states.
And then, that's not enough,
we have also to reconstruct
the fermionic algebra.
So the fermionic algebra is the algebra
of those creation and
annihilation operators
that I told you some slides ago.
So those anticomputation
and computation properties,
we want to recover them
in the qubit language.
All right, let's see how to do that.
Well, first of all, mapping states,
it's easy.
Okay?
Why it's easy, because you have seen that
states in the Fock space,
slater determinants,
can be described by bit strings
and we also know that qubit
states, qubit base states
can also be described by bit strings.
So this is the easiest mapping possible.
It's just one to one mapping between
slater determinants and qubit states.
So, for example, if I have this state here
on a Fock space,
okay, so this is a
state of three electrons
on one, two, three, four,
five, six, six fermionic modes.
Then we just pick the same
state for a bunch of qubits
and then this will be a state
of six qubits
and three of them
will be excited in the one state
and three of them in the ground state,
so we can do this just one to one mapping.
Okay, that's easy, too easy.
What's not easy is mapping the action
of the fermionic creation
and annihilation operators,
so these guys, here.
In general, it's not easy
to reconstruct this action
but we can make it easy if
we just look at one qubit.
Okay, so on one qubit,
oh sorry,
on one qubit this is still easy.
Why it's easy, let's have a look.
So one qubit, we know that
if we only, sorry, if we
only have one fermionic mode
the creation operator on a fermionic mode
which is not occupied will
make it, will fill it,
will make it occupied.
The action of the same
fermionic creation operator
on a mode which is already
occupied will annihilate it.
Similarly, for the annihilation operator.
So an annihilation operator on the
unoccupied mode will annihilate it
and its action on the
mode which is occupied
will bring it to the unoccupied state.
Okay, so I think you kind of
like, you kind of like getting
a feeling for what's going on here, right?
The solution is easy.
We can just map this guy to one qubit
and then act with the
lowering and raising
operators on one qubit.
So if we do this mapping,
so sigma plus and a sigma minus,
now these guys act on one qubit,
then we have solved this problem, right?
Because sigma plus and sigma
minus, the action of them
on a qubit state is
exactly this action here,
the fermionic creation and
annihilation operators.
This is easy.
What is not easy is
what happens if we have a
bunch of fermionic modes.
So what happens if we
have N fermionic modes?
Okay, so to find that out,
so to find out how we map in that case,
let's write again the Ith
fermionic creation operator
on a generic slater determinant which has,
which is in the state NI
for the Ith fermionic mode.
So that action is something
like that, something like this.
Let me write it again.
We had a minus one
to this power
and we had the occupation here.
Okay.
Now, the problem here
it's really this phase here.
Because, so this action of
annihilating and creating
and switching the occupation
of the Ith fermionic mode
is perfectly captured by sigma
plus and sigma minus operator
so we can say A plus I,
there is a component, there
is a sigma plus component
in mapping this operator,
acting on the Ith qubit
but the problem is reconstructing
the action of this phase.
But we actually know how to,
this is not really a problem, right?
We know how to get phases
out of qubit states.
So what this phase is doing
is multiplying by minus one
so every time,
every time the occupation
of the fermionic mode MJ
is one, okay.
So if it's zero, it
just multiplies by one.
If it's a one, it multiplies by minus one.
So it's a minus one every
time a fermionic mode
or it is in the occupied state
or a qubit is in the excited state.
So what is the operator
that, a qubit operator,
that gets us minus one
if the qubit is excited
and one if the qubit is not excited, easy.
Sigma Z operator,
the sigma Z operator
as this action, right?
If you want just minus.
Okay, so it give us minus if we have one
and plus if we have zero.
So, an operator that has the same effect
of this global phase here,
is just the product of
sigma Z operators on all
the qubits that proceed
the Ith qubit of our system,
with this trivial mapping
that we have devised.
And, okay, so what we've done here,
let me change the color of
the marker to emphasize this.
Sorry you have to go through this.
This is, what we find here
is, this is nothing else but
the Jordan-Wigner mapping.
Okay, so we have derived
the Jordan-Wigner mapping
just by taking the simplest correspondence
between slater determinants
and qubit states,
write down the action of a
fermionic creation operator
on the slater determinants
and just look at that
and look at that action and reconstruct it
on a qubit space, that's it, very simple.
By the way, this is something,
this was found out in the 1920s, okay.
So this is not really
anything fancy and new.
So, Brian, I think this is
a good time for questions
because this is a key moment, right.
So we are switching
from fermions to qubits.
- [Brian] Awesome.
So, really quickly I just
want to address something
that I saw posted.
Because of how Crowdcast is set up,
the bottom left corner of the slides,
probably like an inch and a
half by an inch and a half
in the bottom left corner,
our video bubbles are over that
so people aren't able to
see what's written there.
- [Instructor] Okay, so I'm not,
I'm not using the bottom left, okay.
- [Brian] Thank you, thank you, yeah.
So, a few questions from
the chat we have here.
What would happen if we apply
the annihilation operator
on the zero state?
- [Instructor] I think
I wrote that before.
Annihilation on the zero
state, it just annihilates it.
So it gives zero.
- [Brian] Perfect, okay.
Another question we had here,
sigma X is a rotation
over the X-axis, correct?
- [Instructor] Sigma X is a
rotation around the X-axis,
is that the question?
- [Brian] Yeah, they're asking if that is
what sigma X is.
- [Instructor] No, no, it's actually not
a rotation, okay, now you're getting me.
No, well.
Okay, it's specific
rotation around the X-axis
for a specific angle of that rotation.
I never using my X I think.
What I use is sigma plus and sigma minus
so these are raising and
lowering operators for one qubit.
I think so far I never used sigma X.
But of course sigma plus and sigma minus
can be written as a
linear combination of XY,
if that helps.
- [Brian] Cool.
And then one more question for now.
How do you determine how
many orbitals per mode
that you need?
- [Instructor] How many orbitals per mode?
- [Brian] Yes, so the full question is
how do we know how many orbitals or modes
there are or that we need?
- [Instructor] Yeah, maybe there
is a bit of confusion here.
All that I am explaining, a
fermionic mode is an orbital.
It's the same, they are
interchangeable expressions,
at this level, for what
I'm trying to convey here.
- [Brian] Perfect, okay.
- [Instructor] Yeah, we can
get more involved maybe.
For example, I can tell you that sometimes
if you want a fermionic mode,
maybe it's written as a
linear combination orbitals,
if you use a basis which
makes this orbitals,
but it's not, I don't
think this is useful for,
the message that I'm
trying to convey here.
- [Brian] Gotcha.
All right, well then
let's move right past it
and go back to your lecture.
- [Instructor] Yes, thank you.
- [Brian] Thank you.
- [Instructor] All
right so we have derived
the Jordan-Wigner transformation.
Let me get back to the black color, here.
Okay, let's double check things now.
Let's see that with this transformation
we actually recover the
anticomputation property,
the anticomputation algebra
for our fermionic operators.
Okay, and specifically,
let's see if we recover,
sorry, this.
Okay, so we should get one
because they act on the same mode.
So imagine that I have a
four
mode system
and then with the Jordan-Wigner
mapping, what I have is
A dag four is now sigma one.
There's four sigmas, three Zs and one plus
and then the annihilation
operator is something like this.
Okay, now let's do this calculation here.
Let's do A dag four, A four,
plus A four, A dag four
and let's see that this is one.
First of all, you know
that sigma Z times sigma Z,
if they act on the same
qubit, they're just one.
So all the poly operators,
if you square them, have one.
So if you multiply these two guys,
the operator on the first three qubits
is gonna be one, the identity,
and we're just gonna be left
with sigma plus four sigma
minus four and same on the other side,
for this other term, just
with the order inverted.
Okay, and let's see what is this.
So let's actually write
down the sigma plus matrix
that's for this guy, here.
So this guy raises a qubit if it's in
it's ground state and it annihilates it
if it's in the excited state
and same for this operator
but the opposite action.
So we just have to do
row by column product
of these two guys.
So sigma plus sigma minus,
let's do this together.
So, to get this right, this
row, this column is one.
This row, this column it's zero and so on.
We get two zeros here
and sigma minus sigma plus,
we have this row, this column, zero
and zero
and we only have one here.
So the sum of these two guys, guess what?
It's the identity.
Okay, identity.
Okay, so we have shown that, indeed,
using the Jordan-Wigner mapping
we can retrieve the algebraic properties
of these fermionic creation
and annihilation operators.
Okay, so let me write again
the Jordan-Wigner mapping.
There is a problem with this mapping
and the problem is that
the number of Z operators
that we have here
scales linearly with
the size of the system.
So imagine that we have
a system of N fermions
that writing A dag N
will be something which
will have a locality,
so locality which will scale
linearly with the size of the system.
Okay, that's bad.
It's bad for a number of reasons
that maybe you're gonna
see in the next talk
but, anyway, this is something
that we want to avoid.
It's a very local,
so very local object in
the fermionic language
has now become a very non-local
object in the qubit language.
And this has a bunch of bad consequences.
For example, that you're
gonna need many more
two qubit gates if you want
to simulate this operator
or if you want to use it in a context
we will need many more measurements
to get an estimation
of our molecular energy
if our system scaling size.
Okay, so this is bad.
Can we avoid this?
And, again, the answer
is yes, we can actually.
What we can do is we
can use another mapping.
What I showed you before
was the trivial mapping
between slater determinants
and qubit states, right?
I just, was just looking
at a slater determinant
and put a qubit in an excited state
every time I was seeing a
fermionic mode which was occupied
but we can change that.
So, how do we change that?
So, think about how much information
a qubit is able to carry, right?
In terms of its base state, okay,
not in terms of position states
but so a qubit only has two
possible configurations.
So, in terms of base states,
it carries a battery of information.
Now, there is, kind of like a gain here
in which we want to take
a slater determinant
and we want to encode the information
in this slater determinant,
which is N bits of information,
if you have N modes, and encode them
in N qubits, which also
contain N bits of information.
So, what we can do is that
we can scramble things up.
We can scramble the information.
So, if I had a fermionic
slater determinant
identified by this bit
string, here, for example,
M1, M2, M3, M4,
let me now devise a
different type of mapping
to encode this bit string
into a qubit bit string.
For example, can I have qubit one
encode how many qubits are in
the fermionic mode number one
and the fermionic mode number two
and the fermionic mode number three?
So, can I do that?
No, right?
Because this, this is
one bit of information,
this is one bit of information,
and this is one bit of information,
so it's three bits of information
and this is just one bit.
So I can't really compress,
in a general case, I can't really compress
three bits of information into one.
But there is something I can do, right.
I can encode in qubit one
whether the sum of these bits
is even or odd, okay, I can do that.
And mathematically to do this encoding,
what I do is just, I just sum module two
and one and two and three.
So, let me do that.
So Q1 it's gonna be the sum module two,
this is my way of writing it,
module two sum of M1 plus M2 plus M3.
So, for example, as
this is one, one, zero,
I will get one plus one two plus zero two
but module two it will be zero, right?
Okay, so let's do that.
So in this way we can scramble information
from a fermionic slater determinant string
into the qubit one
and let me assign, let
me start assigning, like,
random scrambling of information.
I'm gonna use different colors to do that.
Again, it's gonna be involved process.
So I want to assign, for example,
qubit two to these two guys and then
qubit three, for example to these two
and qubit four to these two guys.
Okay, I can do that.
And the result of that
is that, for example,
if we take the string,
I don't know, one zero zero one
then the map string in
terms of qubits will be,
so qubit one is gonna have the
parity of the first two guys,
so one plus zero one, so we have one.
And then qubit two is gonna have
the parity of the middle
two guys, so zero.
And then qubit three is
gonna be one plus one two,
module two zero.
Qubit four is gonna be one.
Okay, so actually I accidentally choose,
I accidentally choose a trivial mapping,
let me change that.
I think that's a non-trivial
thing to achieve.
For example, if we assign,
if we give qubit three
the parity of just that guy,
then we have a one here.
Okay, so, this set assignment,
it's a way of having
a non-trivial mapping.
And then one may ask, is any
combination, is any
assignment a valid assignment?
The answer is actually no, okay.
So to have a valid mapping
between all fermionic slater determinants
and all qubit states,
we need a mapping which is invertible.
Okay, so which assigns a
given slater determinant
to a given qubit string
for all the possible slater determinants
and for all the possible qubit string
and we want this association
to be invertible,
so to work in both senses.
What is an assignment that
satisfy, that is invertible,
that it satisfy this constraint?
It is what we call the parity mapping.
Okay, so a compact way
of giving assignments
of fermionic parities to qubits
is to use a matrix,
which is gonna be defined
on a finite field.
So a finite field means all the operations
are gonna be module two operations.
So let's define a parity
or passage matrix.
So for our four fermionic modes
it's gonna be a four by four matrix
and it's gonna be this matrix
here, one, two, three, four,
one, two, three, one, two, one here.
So this is a,
it's a upper triangular matrix.
Now you can see that the
effect of this matrix
on the generic fermionic bit string here
is to assign to the first qubit
the parity of the orbitals
of all the four orbitals,
a, b, c, d.
To the second qubit we're
gonna assign the parity of
the three I guess lowest
fermionic orbitals
and so on.
And so yeah, this is the idea.
Now, one question, I ask one question,
so if I have M particles in my system
and you realize that the information that
this qubit has
is the parity of the number of particles
that are in my system
because no matter which slater determinant
I'm gonna put here,
it's gonna have the same
number of particles.
So it's gonna have the
same number ones in there
and so this is the parity,
which means, sorry,
parity of the total number
of particles in the system.
Parity means even, odd.
So if the question said
is the number of particles
in my system even or odd, right?
So this qubit, it's gonna
encode that information.
And, again, this matrix
has to be invertible
on a finite field algebra.
So just say invertible
with operations
module two.
Okay, so this is a way
for us to get away from the
trivial Jordan-Wigner mapping
and start devising more
complicated method.
And one advantage of doing this is that
we can optimize the
mappings to achieve the,
some objectives that we have.
And guess what is one objective
that we want to achieve,
we want to reduce the locality
of the map qubit operators
from a locality which scales
linearly with the size of the system
to something that scales more,
that retains more (mumbles).
So the Jordan-Wigner mapping is O N local.
The parity mapping that I show you,
sorry, my handwriting is,
I'm giving up 2D coherence
as this time goes by.
So the parity mapping is
actually also O N local.
So a smart mapping that we can devise
is actually something
Sergey Bravyi and Alexei
Kitaev came up with
in, I think this was roughly 2000,
so it's still 20 years ago.
And this mapping is actually O log N.
- [Brian] Hey, Antonio, I want
to just jump in really quick.
A lot of people are
asking when you say local,
can you clarify what you
mean by local, please?
- [Instructor] Oh, local, it means
how many operators, how
many single qubit operators
there are in the map creation
annihilation operators.
So, you remember for the
Jordan-Wigner mapping,
so the question is how
many sigma Zs do we have
for a generic system of size N?
So the number of sigma
Zs, so the number of
single qubit operators
that I need to describe
a creation operator
for a fermionic system,
is it worse, scales linearly
with the size of the system.
So that's the definition of local.
Again, so the Bravyi-Kitaev mapping is
O log N local and how do we get it?
We get it by define a binary matrix,
like similarly to the parity binary matrix
but a more involved binary matrix.
And this binary matrix is gonna be defined
is a recursive way.
Okay, so we got a, like, bit of a tension.
So for one qubit, I'm
gonna define this matrix
as the identity, okay,
one, just one element.
And for number of qubits,
which is two X plus one,
so the matrix for number of qubits
two to the X plus one,
it's gonna be related to the matrix for
two to the X qubits in this way.
So I'm gonna define two sectors,
I'm gonna put the matrix for
two to the X number of qubits
in each of the varying sectors
and then I'm gonna fill
this row with ones.
Okay, that's the definition.
It seems a weird definition
but there's a lot of structure behind this
and the structure is actually
given by binary trees
and things like that.
So, if you want, the idea is that
the parity information that each qubit
possess,
it relates to the parity information
of the occupational information
of the slater determinants
with a binary tree.
Okay, so that's the idea
and also that's why we have
this recursive structure.
And so let's give a little example.
A matrix for one qubit, it's this one.
Two qubits, it will be this, right?
And four qubits, it will be like this,
so we have to repeat this guy twice
and then put ones here.
You get the idea, so it's
a recursive structure.
Somebody can say it's a fractal structure.
Okay, this, I'm not, I didn't,
I'm not gonna write
this because it's a lot
but so I had it pre-printed on this slide.
Given these binary matrices that allow us
to pass from one
representation to another,
from the Jordan-Wigner to the
parity or Bravyi-Kitaev one,
we give one of these matrices
and then we can derive the action of
the creation and annihilation operators
by just looking at those matrices
and find out three sets of qubits,
which are the parity set, the
update set, and the flip set.
The definition, it's written here.
For the parity set, it
tells us the set of qubits
that encode the parity of fermionic modes
with index less than I.
And the parity set will
give us the global phase
in the sense that you see,
so the parity set is actually, sorry.
The parity set is PJ in
these expressions down here.
The update set is UJ
and the flip set is actually FJ
but what you see here,
it's actually a set,
the remainder set, which is ROJ,
which I think it's, if
I'm not mistaken is,
is related to the flip set,
I think it's the parity
set minus the flip set
or something like that,
but maybe you should double check that.
Brian, can you still hear me?
- [Brian] Yeah, sorry,
I can still hear you.
I did turn off your video for a second.
I didn't want to interrupt you,
just to allow people to see
the bottom corner of the slide.
- [Instructor] Okay, cool.
Okay, no problem.
All right, so.
Okay, so here you have a recipe,
what I'm trying to tell you
is that here you have a recipe
to construct creation
and annihilation operator
given a certain passage matrix,
given one of those primary matrix.
The way you do it is you just
use these expressions down here.
So you act with an X
operator on all the qubits
that belong to the update set.
Of course, you act with X on Jth qubit
if you want to map the Jth equation,
fermionic equation operator, and so on.
So with these formulas you
can reconstruct the action
of creation and annihilation operators.
And if you are lazy, if
you don't want to do that
or you don't want to learn that,
a Qiskit does it for you.
So there is a,
there's a Qiskit implementation,
there's a Qiskit function that gives you
these three sets for the parity
and Bravyi-Kitaev transformation,
so you can go there and look it up
if you don't want to derive it by hand.
All right, is there any question, Brian,
because now we move to kind
of like more involved topic.
- [Brian] Sure.
I've got a few lingering questions.
- [Instructor] We need
to take a break, right?
- [Brian] Yeah, I think we'll
answer two questions now,
we'll go on break, and
then we'll come back
to get to the end of your lecture.
- [Instructor] Okay.
- [Brian] So these are
just general questions
about more so the entire topic,
not particularly what you
were just talking about,
but the first is is the ground state,
and we're talking about the atom here,
is the ground state the balance
between the strong nuclear
and electromagnetic force?
- [Instructor] Um, wow,
this is interesting.
The balance, I wouldn't know
if I call that a balance,
maybe it is.
Yes, if you want it's,
it is kind of a balance.
So the idea is that,
so all the eigenstates of Hamiltonian
are very stable configurations.
So it means that they
don't change with time.
So if you are in a state
of the Hamiltonian,
which is not an eigenstate,
that will evolve under the
action of that Hamiltonian,
of those interactions.
But yeah, I guess that's a fair statement.
A ground state, any eigenstate,
in particular ground state,
it is kind of balanced
in the way that it
doesn't change with time.
So I would say the answer is yes.
- [Brian] Cool, thank you and then
one more question for now
before we head to break.
More so about the work you've done
here at IBM and other (mumbles)
Could you share the
largest molecule to date
that IBM has tried to calculate
on a quantum computer.
- [Instructor] Um, yeah,
so certainly we did
a six qubit molecule
back in 2017.
I think that's, yeah,
that's the largest molecule
that we have done on
hardware, a published result.
