- Welcome to Understanding
Quantum Information and Computation. My name is John Watrous, and I'm the technical director
of IBM Quantum Education. The purpose of this series is to provide you with
a solid understanding of quantum information and computation, and that means getting
into the technical details of quantum information and seeing how quantum
computing really works, what it can do and what it can't do. If you haven't already
watched the overview video for this series, I encourage you to check that out. In that video, you'll find information about what sort of background
preparation is recommended for this series, as well as an outline of
the topics to be covered. Also, be sure to check
out the Qiskit textbook, which covers the same
material as this video series in a written form, and it also includes
interactive components and interfaces to hardware and software designed to help you to better understand quantum information and computation. You'll find links to the overview video and the Qiskit textbook
in the description. This is lesson one of
unit one of the series. Unit one covers the basics
of quantum information, and in the first lesson of this unit, we'll focus on how
quantum information works for single systems, meaning that we have
just one physical system or a device of some sort that
stores quantum information and we're considering how that
one system or device works in isolation. In the lesson following this one, we'll discuss how
quantum information works when we have multiple systems and that will allow us to describe interesting
and important concepts such as quantum algorithms that make use of multiple qubits and quantum protocols
involving multiple individuals that process quantum information and transmit it back and
forth to one another. But before getting into those discussions, it makes sense to start with the
comparatively simple setting of a single system in isolation, partly because it's good to start simple, but also because as we will see, the description of how
quantum information works for single systems in isolation leads very naturally and logically to the description of how
quantum information works for multiple systems. Here's a brief overview of the lesson. We're gonna start by discussing
classical information. Now, the purpose of this lesson is not to explain how
classical information works, it's to explain how
quantum information works, but to explain how
quantum information works, it's very helpful to begin
with classical information and to use it as a
familiar point of reference when we discuss quantum information. At a mathematical level, quantum and classical information actually have pretty similar descriptions with some key differences, of course. In fact, quantum information
really isn't separate from classical information at all. It's an extension of
classical information. The fact of the matter
is, at least in my view, that you really can't
understand quantum information if you don't understand
classical information, so starting with classical
information makes sense. I do expect that this
content will be familiar to some viewers, but even if you are familiar with it, I don't recommend that you skip it. In addition to highlighting the aspects of classical information that are most relevant to
understanding quantum information, we're gonna introduce the
Dirac notation in this part, which is a standard way
that we're gonna use to describe vectors and
matrices throughout the series. As it turns out, the Dirac notation isn't
specific to quantum information. It can equally well be used in the context of classical information as well as many other settings where vectors and matrices arise. We'll then move on to quantum information, and specifically, we'll
discuss the representation of quantum states as vectors, a simple type of measurement called a standard basis measurement, and unitary operations, which describe discreet time
changes in quantum systems. Again, all in the setting
of single systems. Before we get started with lesson itself, it will be helpful to clarify that there are actually two descriptions of quantum information, the simplified description, which is what we'll be
focusing on in this lesson and throughout this first unit and the general description, which is covered in a later unit, specifically in the
third unit of the series. The simplified description,
true to its name, is simpler and it's
typically learned first. In the simplified description, as I've already suggested, quantum states are represented by vectors and operations are represented
by unitary matrices. This description of quantum
information is sufficient for an understanding of
most quantum algorithms, for instance, so it isn't oversimplified, it's the real thing. However, as we will
discover as we go along, it does have some limitations. For instance, if we wanna
model the effects of noise on quantum systems, this description turns out to be lacking. The general description, on
the other hand, is more general and ultimately, it's more
powerful in a mathematical sense. In this description, quantum states are represented by a special class of matrices
called density matrices, and more general class of
measurements and operations can be described including
noise, for instance. It's entirely consistent with
the simplified description and in fact, you can essentially view
the simplified description as a special case of
the general description, and it also includes classical information as a special case. It's also really quite
beautiful in how it all works, so I strongly encourage you to learn about this general description when the time is right, but the simplified description is the more natural place to start, and so that is what we will do. We're going to begin by talking about classical information with an eye on the aspects
of classical information that are most relevant
to quantum information and the way that it's
described mathematically. Imagine that we have a
physical system or a device of some sort that stores information. We're gonna give this system the name X, but there's nothing
important about this name. We could use any other
name if we preferred, but just to pick a name,
we're gonna call the system X. We're gonna make an assumption about X, which is that there is a
finite set of classical states that X can possibly be
in at any given moment. Here, when I refer to a classical state, I mean a configuration of the system that can be recognized and
described unambiguously without any uncertainty or error. Really, this is something that you can think about intuitively. At a mathematical level, we simply define the
set of classical states, we choose it however we want to or in whatever way best
describes the device that we're working with. Let us give the name sigma to
this set of classical states, and again, let me emphasize
that we're assuming that sigma is a finite set. The set of classical
states of this system X is not infinitely large like
the set of all natural numbers. It's finite, and that's just an
assumption that we're making. For example, it could be that X is a bit, in which case, the classical state set is the set containing two
elements: zero and one. Sometimes we refer to this
set as the binary alphabet. Another example is that X is
an ordinary six-sided die, in which case, the classical states are the numbers one through six. Of course, we're talking
about an abstraction here. An actual six-sided die may
have many different attributes such as its precise
position, its orientation, its temperature, and so on. But with respect to the information that's most typically relevant when we're talking about a six-sided die, the classical states are
the numbers one through six indicated by the number of dots on whichever side of the die is facing up. If X is a switch on a
standard sort of electric fan that you might have in your home, then perhaps the classical states are the settings high,
medium, low and off. These are just examples. We could imagine systems having different classical
state sets than these, but hopefully, they convey the idea that this notion of a classical state is something that should be
familiar and can be understood in simple and intuitive terms. Mathematically speaking, the set of classical states
is just a finite set, and of course, this set must
also be non empty as well. There has to be at least
one classical state that the system can be in and there has to be at
least two classical states if the system is going to be useful at all for storing information. Now, in some situations, we might know that X is
in some particular state, but in many situations, that arise in the setting
of information processing, there may be uncertainty about the classical state of a
system at a particular moment so that each possible classical state has some probability associated with it. For example, if X is a bit, then perhaps it's the case that X is in the classical state zero with probability three quarters and it's in the state one
with probability one quarter. We're going to refer to this
as a probabilistic state, and we could express
this probabilistic state, as you see right here, simply by indicating what
the probabilities are for the different classical states. A more succinct way to express
this probabilistic state is by a vector, specifically the representation
that you see right here is a column vector, and this vector indicates
what the probabilities are for the two possible classical states. To be more specific, the first entry indicates
what the probability is for X to be in the state zero, and the second entry tells
us what the probability is for the system to be in the state one. This is simply the natural way to order the binary alphabet, or at least, it's the way that
we are trained to do this. With zero first and one second. Going forward, we're gonna use
the term probability vector to indicate a vector like this. Specifically, it's a vector whose entries are all
non-negative real numbers and where the sum of the
entries is equal to one, so it makes sense to
think about these entries as being probabilities. Here in this example, there are just two entries because there's just two
classical states of the system we're talking about, but in general, there could
be any number of entries with the understanding
being that there's one entry for each classical state of whatever system we're talking about. We're going to continue
discussing classical information, probability vectors and
so on in just a moment, but first, it's gonna be really helpful to introduce some notation
for describing vectors known as the Dirac notation. In fact, this is just the first
part of the Dirac notation. There are a couple of other
aspects of the Dirac notation that we'll see a little
bit later in the lesson. This notation is gonna be
quite central to the way that we describe quantum information, so it's essential to
understand how it works, but fortunately, it's very simple and it really doesn't have
anything specifically to do with quantum information, so we can introduce it now
in the familiar context of classical information. As before, we assume that we have a set sigma of
classical states of some system, and let's assume that we have an ordering
of these classical states, just like how we refer to an
ordering of the binary alphabet in the previous example. Another way of saying this
is that the elements of sigma are placed in correspondence
with the integer from one to however many
elements are contained in sigma, which is what this notation right here with two bars around sigma means. That's the number of
elements in the set sigma. So there's a first state,
a second state, and so on. The specific ordering or
correspondence that we choose isn't actually gonna matter all that much. What's really important is
that we have an ordering and we stick to it. For many classical state
sets that we'll encounter, there will be a standard ordering just like we have with
the binary alphabet, and if there isn't a standard ordering, we can just choose one. But whatever it is, the understanding is that we stick to it. Now, here's the notation
that's being introduced. For any choice of a classical
state a from our set sigma, we write this right here, which is read as ket a
to mean the column vector that has a one in entry corresponding to a and a zero for all other entries. For example, if we return
to the binary alphabet, which, as you might have guessed, is a very important example that we'll return to again and again. Then ket zero and ket one are the vectors that are defined right here. Ket zero is the vector
that has a one in the entry corresponding to the classical state zero, which is the first entry, and a zero for all other entries, and in this case, there's
only one other entry. Similarly, ket one is
this vector right here where we have a one in the
entry corresponding to one, which is the second entry, and a zero for all other entries, which, again, is just one entry. Here's another example. In this example, we have a
classical state set sigma corresponding to the four suits in a standard deck of playing cards: clubs, diamonds, hearts, and spades. In this case, there really isn't a
universally agreed upon ordering of these suits. For many card games, there is no ordering at all. They're just four different suits and that's all that matters, and there are different card
games that do order these suits in different ways, but it doesn't really matter. We can just choose an
ordering like the one that you see right here. This happens to be alphabetical ordering according to the names of these four suits written in English, Assuming that we've picked
this particular ordering, then we define these four vectors: ket clubs, ket diamonds,
ket hearts, and ket spades as you see right here, and these vectors correspond
to the general description that you see up here. Given that we've chosen
this particular ordering for these four suits. We can do the same thing for any classical state
set that we choose. Keeping in mind that classical
state set always means finite and non empty set. Vectors of this form are
called standard basis vectors, and it's a very basic fact about vectors that every vector can be
expressed in a unique way as a linear combination
of standard basis vectors. For instance, going back to the example from just a moment ago, the probability vector
we saw can be expressed as you see right here. It's basically just an alternative way of expressing vectors that's gonna be very handy for several reasons going forward. And with that notation now in our hands, let's return to the discussion
of classical information and probabilistic states, in particular. And let's consider what happens
when we measure a system while it's in some probabilistic state. We might not ordinarily
refer to a measurement or the act of measuring
something in a classical setting, but the term makes sense. In essence, when we talk
about measuring the system X in this context, we just mean that we look at it and we recognize whatever state it's in. Of course, when we look at the system, we don't see a probabilistic state, we see a classical state, and the particular
classical state that we see is one that we can
imagine is chosen randomly according to the probabilities. Now, you might object on
philosophical grounds to the idea that the classical state we see is somehow chosen at random at the moment that we measure or we look at the system, the system simply was in some particular
classical state all along and we just happen to have
learned what the state was, but for the sake of thinking about the mathematical
framework we're working with, it's okay to think about it this way and doing so will allow us to draw a parallel with
quantum information a little bit later. Let's suppose that the
classical state that we see is the classical state a, which could be any state in our set sigma. This changes the probabilistic
state of X in general, at least from our point of view. The probabilities no longer
have any significance because we now know what
the classical state of X is. It's a, and there's no longer
any uncertainty about this. So we would now say this
that the probability that the system is in the state a is one. We know this because we just looked at it and we saw that the classical state is a, so the new probabilistic state of X is one in which the probability of
being in the classical state a is equal to one. And that probabilistic state is represented by the
probability vector ket a. We have a one in the entry corresponding to the classical state a and a zero in all other entries. For example, if we again
consider the situation where X is a bit and we have the same
probabilistic state as before, then if we measure X, we can imagine that a
transition takes place. With probability three quarters, we see the classical state zero, and by measuring, we transition to ket zero
being our probabilistic state, and with probability one quarter, we transition to ket one. You can think about this as a transition of knowledge if you prefer as opposed to an actual
physical transition, but what's important for
the sake of this lesson is to recognize how the mathematics works. It's kind of trivial actually, but by recognizing this triviality, the analogous description
for the quantum setting might seem a little bit less mysterious. One final note is that to another person who didn't happen to see what
the classical state of X was when we measured it, the probabilistic state
naturally wouldn't change as a result of us having measured it. That's okay. Different individuals can
have different knowledge of a particular system and correspondingly choose
different probabilistic states to represent their
knowledge of that system. In the last part of this discussion of classical information, we'll talk about classical operations that can be performed on a system, starting with deterministic operations. When we perform an operation on a system, its state generally changes as a result, and in this context, the word deterministic means that the result of performing
the operation depends entirely on whatever classical
state the system was in prior to the operation being performed. In other words, there's
no element of chance when a deterministic
operation is performed, so there's no randomness
or uncertainty involved. In mathematical terms, deterministic operations
are described by functions. Every function f of the form
that you see right here, which means that both the input and the output of the function correspond to elements of
our classical state set sigma describes a deterministic operation. The classical state a is
transformed into the state f of a for each choice of a state a. For every function f of this form, there will always be a unique matrix M satisfying this condition
that you see right here, and that is that by multiplying
M to the vector ket a gives us the vector ket f of a, and that's true for every
choice of a classical state a. It's not too hard to write down
an explicit description of M given whatever function f
of this form we've chosen. It will always have exactly
one, one in each column with every other entry equal to zero. And here's the formula. The b, a entry of M is equal to one if b is equal to f of a and otherwise, it's equal to zero, and by this, we mean
this is the entry of M whose row corresponds to b and whose column corresponds to a. We'll see a few examples in just a moment, and we'll see why this formula works. Now, it might not be clear why we would want to take a function and express it as a matrix like this, but it does make sense to do this. One of the reasons, and perhaps, it's the main reason, is that if we have a system
in a probabilistic state and we perform a deterministic
operation on that system, then the resulting probabilistic
state can be obtained by matrix-vector multiplication, i.e., if our system is
in a probabilistic state that's represented by
some probability vector v and we perform the deterministic
operation described by M on that system, then the resulting probabilistic state will be given by M times v. Here, by the way, this arrow with a little
bar on it like this is just a common notation in mathematics for indicating how one
thing gets mapped to or transformed into another thing. You could just use an ordinary arrow, but this is conventional and it's recognizable and maybe it's a little bit more specific than just an arrow, which could mean many different things. Now let's take a look at an example or a collection of examples, really. Let's consider what happens when we take our classical state set sigma to be once again the binary alphabet. There aren't too many different functions of the form we've been discussing when this is our classical state set and to be more precise, there are just four
functions of this form. Here, those four functions are described by their so-called tables of values. The first table describes
the first function, which we've named f1. For each possible input on the left, we list the corresponding
output on the right, so f1 of zero is equal to zero, and f1 of one is, again, equal to zero, and that is to say that f1 is
the constant zero function. It always takes the value zero. The second function f2
is the identity function. The output is always equal to the input as you can see from the second table. The third function f3 is
described by the third table. f3 of zero is equal to one, and f3 of one is equal to zero. This function is better
known as the not function or logical negation. We sometimes also call it a bit flip because it flips zero
to one and one to zero. The last function f4 is,
again, a constant function just like the first one, but this one is the constant one function because it always takes the value one. And those are the only four functions from the binary alphabet to itself. Here are the four matrices that correspond to these four functions that are described by
the formula from before, which you can see right here, and if you're so inclined, you can pause the video and check this. Just remember that with matrices, the order of the indices is always rows first, column second. So the b, a entry corresponds
to row b and column a or the row that corresponds
to the classical state b and the column that corresponds
to the classical state a. So for example, if we look
at the first function, we have the f1 of zero is equal to zero and correspondingly, the
zero, zero entry of M1 is equal to one. Well, the one, zero
entry which is right here is equal to zero, and you can do the same thing for the case where the input is equal to one and similarly, for the
other three functions. You can also check that this
formula from before is true and you can just go one by one through all the different
possibilities to verify this. And in fact, if you think about the way that
matrix multiplication works, really you can just kind of eyeball this. When you multiply a matrix to a standard basis factor like this, you can imagine that
you're taking the input and dropping it into the
top of one of the matrices in whichever column corresponds
to the classical state inside of the ket, and the output that you
get is simply that column as a probability vector. So for example, M3 multiplied to ket
zero gives you zero, one as a probability vector, which is ket one. M3 multiplied to ket
one gives you one, zero, which is ket zero and so on. We'll discuss operations on
probabilistic states more in just a moment, but first, let's introduce the second part of the Dirac notation. This is gonna be helpful
for talking about operations and thinking about them as major Cs, and it's also gonna be a standard tool that we'll continue to use going forward. The setup is just like it was before. We have whatever classical state set sigma that we're working with and we assume that we have some way of
ordering those classical states. We then write this thing
that you see right here where this time the
angled bar is on the left rather than the right to mean
the row vector having a one in the entry that
corresponds to a and a zero for all of the other entries corresponding to all the
other classical states. So the difference between
this thing and ket a is that this is a row vector and
ket a is a column vector, but otherwise, the vectors
are defined in a similar way. We read this as bra a, I'm not sure if that's
supposed to be funny, but the idea is that the names bra and ket are two halves of the word bracket, and we'll have more to say
about that in just a moment. But first, let's take a look
at a very quick example. For the binary alphabet, we have that bra zero is
this row vector right here analogous to ket a, except it's a row vector
instead of a column vector and bra one is this vector right here. Now in general, if we multiply a row
vector to a column vector, just thinking about these as matrices that happen to have just
one row or just one column, then we get a one by one matrix, which we can think
about as being a scaler. Here, by the way, you should
think about these stars as representing arbitrary numbers. In particular, if we
multiply the row vector bra a to the column vector ket b, then there are two things that can happen. One is that a and b are equal, so they're the same classical state, in which case, the ones will line up and the product will be equal to one or it could be the case
the a and b are different, and so the ones don't line up and the product is equal to zero. A simple way of expressing
these observations is like this right here. And just to keep things tidy, we write this product like this with just one bar in the middle and it means exactly the same
thing as this right here. And now you can see how the
bra and the ket go together to form a bracket, which is
also called an inner product, and that's something
that's quite important that we'll come back to
in lesson number three. Multiplying a column
vector to a row vector, on the other hand, gives us a matrix as you can see right here. So for example, going back yet
again to the binary alphabet, if we multiply ket zero to bra zero, what we get is this matrix right here, and we can go through
the other possibilities to see what happens. Ket zero times bra one gives
us this matrix right here where the one has now moved
over to this position. Ket one, bra zero looks like this and here's ket one, bra one. What we see happening is that there is just a single one in a matrix that's otherwise all zeros, and the position of that one is determined by which
classical states we choose in the bra and the ket. More precisely, and
this is true in general, for any choice of a classical state set, the matrix that we get by
multiplying ket a to bra b is the matrix with a one in the a, b entry and a zero for all other entries. And now that we have both the
first and the second parts of the Dirac notation, we have a very handy tool for connecting operations with matrices. So let's go back briefly
to deterministic operations and recall that a bit
earlier in the lesson, it was stated that for every function f of
this form right here, we have a deterministic operation that transforms a into f of a for each possible classical state a. And we said that for
any function like this, there's always a unique
matrix M that acts like this on standard basis states. Using the Dirac notation, we can now very easily express this matrix like you see right here, and we can see how sometimes
it's possible to work with matrices entirely
within the framework of the Dirac notation without ever explicitly converting
to vectors and matrices, meaning rectangles filled with numbers. In this case, we can check that the
required formula is true by multiplying M to ket a. We substitute our
expression for M like this and we can remove the parenthesis and snap together the bra
b with a ket a like this. And that's because matrix
multiplication is linear, in this case, in the first argument and it's associated so we can remove the parentheses. And now, recalling that we have a fixed a that we're talking about as we sum over all of the
possible choices of b, this bracket right here is
always gonna be equal to zero when b is not equal to a, so there won't be any
contribution to the sum, and when b is equal to a, the bracket will be equal to one and so we'll be left with
this one term right here. That's the formula we wanted and so we have a very nice and simple way of expressing a function as a matrix. In addition to deterministic operations, we also have operations that
themselves introduce randomness or uncertainty about the
classical state of a system. We use the term probabilistic operation to mean operations like this, and to be precise, when we say probabilistic operation, we mean operations that
might introduce randomness, so deterministic operations are actually a special case
of probabilistic operations that just don't happen to
introduce any randomness. Here's a simple example where
some randomness is introduced. This is an operation on a single bit. The way that it works is that if the classical state
of the bit is a zero, then nothing happens. The bit stays as a zero, but if the classical
state of the bit is a one, then the operation flips the bit to zero with probability equal to 1/2. There's no special name
for this operation, at least not that I'm aware of. It's just an example, but you could imagine performing
this operation on a bit. Just like deterministic operations, probabilistic operations can
be represented by matrices and their actions on probabilistic states are given by matrix-vector multiplication just like before. This time, it's not necessarily the case that the matrices have exactly one, one in each column and zeros otherwise. Probabilistic operations are
more generally represented by stochastic matrices. These are matrices whose entries are all
non-negative real numbers and where the entries in
each column sum to one. That's equivalent to saying
that stochastic matrices are matrices where every column
forms a probability vector. That makes sense when you think about
the action of a matrix on a standard basis vector. You consider whatever
classical state you wish and you imagine dropping that state into the top of the matrix in whatever column corresponds
to that classical state, and that column tells you what
the probabilistic state is that comes out as a probability vector. The probabilistic operation
in our example, for instance, is described by this matrix right here. If we perform this operation
on the classical state zero, then the probabilistic state we get is given by the first column, which is, again, the classical state zero or equivalently, the probabilistic
state where zero occurs with probability one. If instead, we perform this operation on the classical state one, then we effectively just randomize the bit and correspondingly, we get
this probability vector here where the probability for
each of the possible states is equal to 1/2. In general, if we perform this operation on any probabilistic state, then the effect is essentially
just a weighted average between the two columns because that's how a matrix-vector
multiplication works. It's linear, so we just average the two
possible outcomes accordingly. When we think about probabilistic
operations in this way, it's natural to think about
them as potentially introducing or injecting randomness. We can just read the columns one by one and we can see the randomness
that they introduce for each possible classical state. You can also think about
probabilistic operations in a slightly different way, which is that they're random choices of deterministic operations. For instance, in our example, we can think about this operation as being equivalent to
flipping a fair coin and either performing the
constant zero function or the identity function
each with probability 1/2, and you can see that reflected
right here by this equation. That's always possible for
any probabilistic operation, and it's pretty intuitive. If you made random choices
as part of some process, you could always imagine making those random choices in advance and then hard coding those
choices into some collection of deterministic operations. It's sometimes quite helpful to think about probabilistic
operations in this way, and we'll see an example
of this down the road in a couple of lessons. The last thing to say
about classical information for this lesson concerns composing
probabilistic operations, which just means performing
one after the other. Let's suppose that we
have some system named X and M1 through Mn are stochastic matrices representing probabilistic
operations on X. Imagine first that we have
a probability vector v, which represents a probabilistic
state of X at some moment, and then we first apply the first probabilistic operation to X, which is represented by the matrix M1, and then we apply the second
probabilistic operation, which is represented by M2. If we do that, then the
probability vector we get after applying just the first
operation is M1 times v, and then when we apply
the second operation, the resulting probability vector is M2 multiplied to whatever vector we obtained after applying M1. So it looks like this. Now, matrix multiplication
is an associative operation, which means that it doesn't matter where we put these parentheses. So we could just as easily
put the parentheses like this. That's very simple, but it's also interesting because it reveals that we
can think about the operation where we first apply M1 and then we apply M2
as a single operation. In other words, the
probabilistic operation we get by composing the first and
second probabilistic operation is represented by the
matrix product, M2 times M1, and that's the same operation regardless of what probabilistic
state we started with. We don't need to know anything about the probability vector v to think about or to describe
this composed operation. Notice that the order
here is M2 on the left and M1 on the right, which is because the
matrix on the right, M1, is the one that gets
multiplied to the vector v, whereas M2 gets multiplied
to whatever vector we get after multiplying by M1. So we always have to keep in mind that the order in some
sense gets reversed. The operation performed
first is the one on the right and the operation that gets performed last or in this case, second,
is the one on the left. If we don't stop with the second operation and we apply all of them in
order starting with the first and ending with the last one, which is Mn, then the composition of all
of these operations together is given by this product
that you see right here, and you see that the ordering
once again is reversed for exactly the same reason as before. So in short, compositions
of probabilistic operations are represented by products
of stochastic matrices that represent them. Keeping in mind that this is
the ordering of the matrices in the product. You will always get a stochastic matrix by taking a product of
stochastic matrices like this, and sometimes we express this fact by saying that the stochastic
matrices are closed under multiplication, and the way that you
can think about this is that you can't get out of the
set of stochastic matrices by multiplying them because the set is closed. Getting back to the
ordering of the matrices in this product, it's important to note that the
ordering really does matter. Matrix multiplication is not commutative. If you change the ordering of
the matrices in the product, you might change the result, and we don't need to look any further than the deterministic
operations to see this. Here's a simple example of
two stochastic matrices, both of which represent
deterministic operations where the ordering matters. M1 represents the constant zero function. Assuming, we're imagining that these two operations are on bits, just like in the example from earlier. M2 represents the not
operation or a bit flip. If you perform M1 first
and then you perform M2, the result is this matrix right here, which represents the
constant one function. If you set a bit to zero
and then you flip it, it's the same thing as just
setting that bit to one. On the other hand, if you perform M2 first
and then you perform M1, this is the result right here, and this makes sense because if you flip a bit
and then you set it to zero, it's the same thing as
just setting it to zero. It didn't matter that you flipped it. Obviously, these two
matrices are not the same, and so we have a very
simple example revealing that the order does matter. Of course, this is not surprising at all. We all know that the order in which
operations are performed matters or at least, it can matter. For example, if you light a
match and then you blow on it, the result is very different
from blowing on the match first and then lighting it. At this point, we've talked quite a lot
about classical information and now it's finally time to
discuss quantum information. And what we'll find is that
mathematically speaking, quantum information works
in a very similar way to classical information
with some key differences. The first key difference
is right at the start, how we define a state, in this case, a quantum state of a system, and there is a sense in which this one choice how
we define a quantum state largely determines how
quantum information works. We'll also define how
measurements and operations work, and in the next lesson, we'll discuss how
quantum information works not just for single systems
but for multiple systems, but these things actually
follow pretty naturally once the notion of a quantum state of a single system in
isolation has been established. Here's the definition. A quantum state of a system is represented by a column vector whose indices are placed in correspondence with the
classical states of that system. So we're assuming here that
the system we're talking about has some set of classical states, just like when we talked
about classical information and probabilistic states. The entries in a quantum state
vector are complex numbers as opposed to the probabilistic case where the entries are
non-negative real numbers. And this time, the sum of the absolute
values squared of the entries must equal one as opposed to the sum being equal to one as we have in the probabilistic case. The complex numbers that appear
in a quantum state vector are sometimes called amplitudes and they play a role that's
similar to probabilities, but they aren't probabilities and they don't have the
same interpretation. Now, I can't give you a good reason for why quantum states
should be defined like this other than to say that
physicists have discovered that this definition
is physically relevant and it allows us to describe and model
quantum mechanical systems. In other words, we choose this definition
because it works, not because there are
any particular reasons why quantum states should
be defined like this. With respect to the
mathematics of this notion of a quantum state, the first step towards understanding it and working with it is
to recall this definition for the Euclidean norm of a vector, which you can think of geometrically as the length of a vector, just like you would think about the length of a two-dimensional real vector if you drew it on a piece
of paper as an arrow starting from the origin in the usual way. Specifically, if we have a
column vector v like this, which we assume has
complex number entries, alpha one through alpha n, then the Euclidean norm of v is defined like you see right here. This is the notation we
use for the Euclidean norm putting these double bars around whatever vector we're talking about. In this case, it's v, and the way the Euclidean norm is defined is that it's the square root of the sum of the absolute values squared
of the entries of the vector. So another way to define what
a quantum state vector is is that a quantum state vector is a column vector having
complex number entries whose Euclidean norm is equal to one, which is to say that it's a unit vector with respect to the Euclidean norm. That's because the sum of
the absolute value squared is equal to one if and only if the Euclidean
norm is equal to one. The square root doesn't change anything when the sum of the absolute
values squared is equal to one. So that's what a quantum state vector is. It's a column vector with indices that correspond to the
classical states of a system having complex number entries and Euclidean norm equal to one. What that means or what it implies or how we should interpret this
notion is a different matter and in some sense, the study of quantum
information and computation is an exploration of what
this definition implies, at least, in terms of
information processing. This is simply the starting point. As an aside, let me mention that there
are other so-called norms besides the Euclidean norm and this notation right
here with the double bars around a vector doesn't always
mean the Euclidean norm. In different contexts, this notation could refer
to a different norm. For example, the sum
of the absolute values with no squares or square
root is a different norm, often called the one norm. There are quite a lot of
different norms, in fact. Sometimes you'll see
this notation being used with a subscript after
the second set of bars that provides more information about what norm we're talking about. And when we do that, it's pretty typical that the number two as a subscript
means the Euclidean norm. But in this series, whenever we have a
column vector like this, this double bar notation all by itself means the Euclidean norm. Here are a few examples
of quantum state vectors and these particular quantum state vectors are qubit state vectors, which means that the
classical states of our system are zero and one. The word qubit is short for quantum bit, which is really just a bit
that can be in a quantum state. The first two examples are really simple. The standard basis vectors
ket zero and ket one are quantum state vectors. They're both column vectors, and the indices correspond
to the classical states is zero and one, and the entries of these
vectors are complex numbers. For these particular vectors, the entries are zero and one, which are real numbers, and in fact, they're integers, but they're also complex numbers that happen to have
imaginary part equal to zero. Each vector has one entry equal to one and one entry equal to zero. So when we sum the absolute
values of the entries, we get one in both cases. So the conditions
required for these vectors to be quantum state vectors are satisfied. The next two examples are very commonly encountered qubit states called the plus state and the minus state. They're denoted as you
see here on the screen, either with a ket plus
or a ket minus like this, and they're defined as
you can see right here. Again, the entries of these
vectors are complex numbers. This time, they're either positive one over square root of two or negative one over square root of two, and when we sum the
absolute values squared, we get 1/2 plus 1/2, which is one. By the way, putting a
plus sign or a minus sign inside of a ket like this
might seem a little strange because these aren't classical
states of our system, but this notation is used nevertheless, and we'll come back to this momentarily. But for now, in short, we can use the Dirac notation to put whatever name we want for a vector inside of a ket. The vector doesn't have to
be a standard basis vector when we use the Dirac notation. Here's a final qubit state
example for the moment, anyway. It's a quantum state vector of a qubit that doesn't have a special name, and it's not particularly significant. The entries of this vector are one plus two times i
over three and negative 2/3. These are complex numbers, and if you compute the
absolute values squared of these two entries, you'll get 5/9 for the first one and 4/9 for the second one. So the sum of the absolute
value squared is equal to one. And here's one last example. This time for a system
whose classical states are the four card suits. I don't know why we would have a system whose classical states
are the four card suits being in a quantum state, but it is possible in principle and it's just meant as an example. The entries corresponding
to the different suits are 1/2 for clubs, negative
i over two for diamonds, zero for hearts because it doesn't appear in the sum and one over square
root of two for spades. And here's what it looks
like as a column vector, assuming that we've ordered
the classical states as we did before, which is the order that
you see right here. Taking the absolute value
squared of these entries gives one quarter for the first one, also one quarter for the next one. The absolute value squared
of zero is equal to zero, so that entry doesn't
contribute to the sum. And finally, for the last one, we get 1/2. So the sum is equal to one as is required for this vector
to be a quantum state vector. Now just a moment ago, we used the notation
ket plus and ket minus to referred to two qubit state vectors that aren't standard basis vectors. And I'd like to return
to this point briefly and explain how the Dirac notation is used for arbitrary vectors and not just for standard basis vectors. As I've already mentioned, we can use whatever name we
want inside of a bra or ket to refer to a vector. Kets are column vectors
and bras are row vectors just like before. As an example, the Greek letter
psi is very commonly used inside of a ket to refer to some arbitrary vector, and here, we're using it to
give a name to the state vector from before that doesn't
have a special name. When we do this, the let our psi doesn't
necessarily have any meaning all by itself. It's just the name of a vector, and it's inside of a ket to help us to clarify
that it's a column vector. This can be a little
bit confusing sometimes, and there is a potential for ambiguity if the letter psi could be associated with a classical state of
some system for instance, but it generally doesn't
cause any problems, and you don't have to use
the Dirac notation like this if you don't want to. Using a lower case letter such
as u, v, or w without a ket is also a fine way to
denote a column vector or more specifically,
a quantum state vector. It's your choice what notation
you use to express yourself. You just need to make
sure that number one, the meaning of what you
are trying to express is clear to others. And number two, that you understand what
others are trying to express even when their preferences for notation aren't the same as yours. There is one very important rule for using the Dirac notation
for arbitrary vectors and that is that if you
have a column vector that you've decided to write
as ket psi, for instance, or it could be a different
name inside of a ket, then the row vector bra psi is understood to be
the conjugate transpose of the vector ket psi. And here, this is written as an equation where this dagger right here refers to the conjugate transpose. What that is specifically is
the row vector you get by, number one, transposing the vector, meaning that you flip
the vector on its side and you change it from a column into a row without actually changing the entries. And number two, taking the complex conjugate
of each of the entries. You can actually perform
those two operations, the transpose and the
entry-wise complex conjugate in either order or those
two operations commute. So for the vector in this example, given that we've decided to
call this vector ket psi, it's understood that bra psi
means this vector right here where we've transposed the vector by turning ket zero and ket
one into bra zero and bra one, and we've taken the complex
conjugate of each entry, which is why one plus
two times i over three turns into one minus two
times i over three right here. Here's what these vectors look like when they're written
explicitly as a column vector and a row vector. Notice, by the way, that
this rule is consistent with the notation we use when we have classical states
inside of the bra and the ket. In that case, the entries are
all zero except for one, one, and so taking the complex
conjugate doesn't do anything in that case. We've now seen how quantum states are represented as vectors, but it's not clear at this
point what the meaning or the implications are in terms of what you
can do with the system in a quantum state or how you can interact with it. The first thing we need to do to bring these issues into focus
is to discuss measurements. Intuitively speaking,
measurements provide a mechanism for extracting classical
information from quantum systems. When we look at a system
when it's in a quantum state, we don't see a quantum state just like we don't see
probabilistic states, we see classical states, and this notion of a measurement is what provides the interface. If we, as humans, want to know something about a quantum system, we have to measure it, and in doing so, we'll extract classical information about whatever quantum
state that system was in. There are different
notions of measurements. The difference is one
of generality really, and we're going to start with the simplest and most basic one, which is typically called a
standard basis measurement. We will generalize this
in subsequent lessons. We'll talk about so-called
projective measurements in lesson three, and then later on in the
third unit of the series, we'll talk about general measurements, which are also called positive
operator valued measures or POVMs for short. But for now, we'll restrict our attention to standard basis measurements. When a measurement is
performed on a system, there will be some set
of possible outcomes of that measurement, which are classical outcomes, and in the case of a
standard basis measurement, those possible outcomes are
precisely the classical states of whatever system is being measured. Each of those classical states will be the outcome of the measurement with some probability, and that probability is
the absolute value squared of the entry corresponding
to that classical state of whatever quantum state
vector the system was in immediately prior to being measured. We know that the absolute value squared of any complex number is a non-negative real number, and we know from the definition
of quantum state vectors that the sum of the absolute
value squared of the entries of a quantum state vector is equal to one. So this makes sense. Each classical state will appear as the outcome of the
measurement with some probability and the probabilities sum to one. Here are a few examples. First, suppose we have a
qubit in the plus state. If we measure this qubit with respect to a standard
basis measurement, we get either a zero or
a one as the outcome. The probability of getting a zero is the absolute value
squared of one over root two, which is 1/2, and that's the same
probability of getting a one. So if you measure a plus state, you'll get a uniform random bit. If the system is in a minus
state rather than a plus state, then measuring works in
exactly the same way. The probabilities are, again, 1/2 for each possible outcome. The only difference here is that the plus sign turned into a minus sign, but when we take the absolute
value, nothing changes. If we measure this qubit state, the probability to get the outcome zero is the absolute value squared of one plus two times i
over three, which is 5/9, and the probability to get the outcome one is the absolute value squared
of negative 2/3, which is 4/9. And finally, measuring
the standard basis state, ket zero gives the outcome
zero with certainty, and likewise, measuring the state ket one yields the outcome one with certainty. That's because the absolute
value squared of one is one. Similar to what we had in
the probabilistic setting. We can associate these quantum
states, ket zero in ket one, with the system being in
those classical states, and this example is consistent
with that interpretation. Now, just like we had in
the probabilistic setting, if we measure a system when
it's in a quantum state, then the state will change, in general, as a result of having
performed that measurement. In particular, and again, this is exactly like we had
in the probabilistic setting. If we measure a system and the outcome of the measurement
is the classical state a, then the new quantum state
of the system becomes ket a. So for this state right
here, for instance, we see the same kind
of behavior that we had in the probabilistic setting. If we measure then with probability 5/9, we obtain the outcome zero, in which case, the state
transitions to ket zero, and with probability
4/9, the outcome is one, and the state transitions to ket one. Sometimes this phenomenon is referred to as a collapse
of the quantum state, and it's the kind of
thing that keeps people that study the foundations
of quantum mechanics awake at night. But from a purely
mathematical perspective, it's really quite simple
and very much analogous to what we have in the probabilistic case. The source of tension here, in some sense, concerns the fundamental
nature of quantum states and what they represent
and how they differ from probabilistic states. But at a mathematical level, this is perhaps what you might expect. Notice, by the way, that if
you measured a second time, then you would get exactly
the same result as you did for the first measurement. So there's a limit on how
much classical information can be extracted from a quantum state, and we'll come back to this point soon in another lesson. We've talked about quantum states as well as measurements, specifically standard basis measurements, which provide a way to
extract classical information from quantum states. The remaining topic for
this lesson is operations, specifically unitary operations, which describe how
quantum states of systems can be changed. Naturally, given that quantum
state vectors are different from probability vectors, you would expect that set
of allowable operations on quantum states is different than what we have for
classical information, and indeed, that's the case. Whereas operations on probabilistic states are represented by stochastic matrices, operations on quantum state vectors are represented by unitary matrices. Here's the definition of unitary matrices. A square matrix U having complex
number entries is unitary if it satisfies the equalities
that you see right here. The dagger represents
the conjugate transpose, which we already saw for vectors when we talked about the Dirac
notation a few moments ago. Here we're performing the
conjugate transpose on a matrix rather than a vector, but it's essentially the same thing. We transpose the matrix, which just means that we
swap rows and columns, so the JK entry becomes the KJ entry, and also we take the complex
conjugate of each entry. Also, this notation right here
means the identity matrix. These two equalities right
here are actually equivalent. If you have one, then you
automatically have the other. They're both equivalent to
saying that you is invertible, and the inverse is equal
to the conjugate transpose. That's only true for square
matrices, by the way. If you have a matrix that isn't square, then one of those two
equalities might be true, but then the other one won't be true. But here, we're talking
about square matrices. So this is the standard
definition for unitary matrices, and it's nice because it's easy to check
if a matrix is unitary. You just multiply the matrix to its conjugate transpose on either side, and you see if you get
the identity matrix. There's an equivalent way to characterize unitarian matrices, and that is that a
square matrix is unitary if and only if it never
changes the Euclidean norm of any vector when you multiply. An N by N matrix U is unitary if and only if the
Euclidean norm of U times v is equal to the Euclidean norm v for every n-dimensional column vector v with complex number entries. And therefore, if v is
a quantum state vector, then U times v is also
a quantum state vector because quantum state vectors are simply the vectors having
Euclidean norm equal to one. In fact, we can say a little bit more, which is that the unitary matrices are precisely the matrices that always transform
quantum state vectors into quantum state vectors. That's a similar situation to what we have for stochastic matrices
and probability vectors. The stochastic matrices
are precisely the matrices that always transform probability vectors into probability vectors. So once we've decided that operations should be represented by matrices, which is the same as saying that transformations act linearly on vectors representing states, these choices for the sets
of allowable operations follow naturally, at least,
in a mathematical sense. Now let's take a look at some examples of qubit unitary operations. We'll see many more examples
of unitary operations in subsequent lessons, including unitary operations and systems having more than two classical states. But for now, we'll focus just
on qubit unitary operations. We're going to be seeing these
particular examples arising again and again, so it's definitely worth getting
to know these operations. The first collection of examples are the so-called Pauli operations. These are the operations that correspond to the Pauli matrices, which are shown here. They're all unitary, and you can check that for each one according to the definition from before. These particular matrices
happen to be equal to their own conjugate transposes, which is to say that they're
all Hermitian matrices. So checking that they're
all unitary, in this case, is a matter of squaring each one and seeing that the result
is the identity matrix. The names you see for these
matrices are pretty standard, and you'll also see sigma
x, sigma y, and sigma z called simply X, Y, and Z. Do be aware, though, that the
capital letters X, Y, and Z are also commonly used for other purposes, even in the context of
quantum information, but they are very common
names for these matrices. The sigma x or X operation
is also called a bit flip or a not operation, which we've already seen
in the classical context. And the sigma z or Z operation
is also called a phase flip. And here, you can see the
action of these operations on the standard basis factors, which kind of explains
where these names come from. Certainly, it makes sense to
refer to sigma x as a bit flip based on this action right here. It simply flips the bit from
zero to one or one to zero. It also makes sense to
call sigma z a phase flip based on this action right here. But if that's not crystal clear
at the moment, that's okay. We'll encounter this
operation over and over and the significance
of putting a minus sign in front of the ket one
basis vector and not ket zero and why that's called a phase flip will be more clear later on. The next example is
the Hadamard operation, which is represented by
this matrix right here, which is pretty much always named H. Checking that H is unitary is once again a
straightforward calculation, which if I step out of the way, you can see right here. Similar to the Pauli matrices, H is its own conjugate transpose. So we have this equality right here, and when we perform the multiplication, we get the identity matrix as is required. The third example is
really an entire class of unitary operations
known as phase operations. These are operations
represented by any matrix that takes this form
that you see right here where theta is any real number. So this entry right here will
always be some complex number on the unit circle. Matrices like this are always unitary, which I will leave to you to verify. This time, the conjugate transpose won't be equal to the original matrix unless this number here happens
to be a one or a minus one, in which case, we end up with
either the identity matrix or sigma z, which we've
already encountered. Specifically, transposition
won't do anything to this matrix, but taking the complex
conjugate of each entry changes this entry right here
to e to the minus i theta. These two particular operations right here are particularly important
examples of phase operations. For the first one, we take
theta to be pi over two, and we get this matrix right here. This is commonly called an
S operation or an S gate when we're talking about circuits, which we won't discuss in this lesson, but that's an important
topic that's coming up soon. The second one is this operation. It's a T operation or a T gate. And for this one, theta
is equal to pi over four. And so when we compute the exponential, we get this value right here, which is one plus i over
the square root of two. Here are just a few quick examples to see a couple of these
operations in action. Here's the action of
the Hadamard operation on ket zero and ket one. If we go through the
matrix-vector multiplication, we see that what we obtain are the plus state and the
minus state respectively. If we perform the Hadamard operation on the plus state and the
minus state, on the other hand, we get back to ket zero and ket one. So if we clean things up a little bit, we can see the action more clearly. The Hadamard operation
transforms back and forth between the zero state and the plus state and between the one state
and the minus state. Concerning these two equations right here, notice that this gives us a simple way to detect the difference between a plus state and a minus state. As we saw earlier in the lesson, if we measure a plus
state and a minus state with respect to the
standard basis measurement, we get a uniform random bit in both cases, which doesn't help us to
detect the difference. But if we perform a Hadamard
operation and then we measure, we'll see a zero if the
original state was a plus state and a one if the original
state was a minus state. So these two states are indeed different, and they can be discriminated
perfectly by the method that I just described, which is to first perform
a Hadamard operation and then to measure. Going back to the example of
a qubit state we saw before that isn't particularly special, we can see what the Hadamard
operation does to the state by converting to the forms
that you see right here and performing the multiplication. And here is the result
which we can convert back to the Dirac notation if we wish, and that's one way to compute
these sorts of actions. Here's another example that illustrates that you don't always
have to convert explicitly to a matrix vector form. You can also perform these
computations directly using the Dirac notation. This example concerns the T operation, and here it is right
here just for reference. This operation has this action right here on standard basis states. And if we want to compute
the action of the T operation on a plus state, for instance, we can start by expanding the
definition of the plus state and then use linearity
to express the result as you see right here. We can now just plug in
these expressions up here, do just a little bit of
simplification for the second term, and we obtain the result. If for whatever reason we'd like to apply a Hadamard
operation to the result, we can do a similar thing. First, we substitute the expression for T acting on the plus state and we use linearity like we did before. And now, if we substitute the
expressions we already have for the Hadamard operation
acting on ket zero and ket one, we obtain this. And now, we can expand the
plus state and the minus state to get this expression right here, which we can simplify just by adding, and here is the final result. There's nothing particularly
special about this example. It's just meant to
illustrate this alternative but equivalent way of
calculating the actions of these operations. You can use whichever
way is more convenient in the situation at hand. One final point about
unitary operations is that compositions of unitary
operations are represented by matrix multiplication just like in the probabilistic setting, i.e., you can compute the action of a sequence of unitary operations by simply multiplying
the matrices together. And what you'll get is
a single unitary matrix representing the combined action of the sequence of operations. Just like we had for stochastic matrices, the unitary matrices are
closed under multiplication, so you'll always get a unitary matrix when you compose unitary operations. You have to make sure
you multiply the matrices in the correct order. But the way it works is just like it was for
stochastic operations where the matrix for the
first operation you perform will always appear on the right-hand side
of the matrix product, and the last one will appear
on the left-hand side. So just like before, the order is reversed in the sense that you compose from right to left rather than left to right. Here's an interesting example that gives rise to an operation known as the square root of not operation. Suppose that we first
apply a Hadamard operation followed by an S operation, followed by another Hadamard operation. The combined action of
these three operations is described by this product. Here's the first Hadamard operation, here's the S operation, and here's the second Hadamard operation. If we perform the matrix multiplication, which isn't shown here explicitly, but you can do this for
yourself if you wish, the result is this matrix right here. It's a unitary matrix, and we can either check that directly or we can trust in the fact that the unitary matrices are
closed under multiplication. It has to be unitary because these three matrices are unitary as we've already seen. We don't have any particular
quantum state vector in mind here. We can imagine performing
this sequence of operations on any quantum state vector, and this matrix describes the action. The reason why this combined operation, meaning the one described
by this matrix right here is called a spirit of not operation, is that by performing it
twice, we get a not operation, or in other words, a
sigma x or an X operation. Performing the operation
twice is represented by squaring the matrix or
multiplying it to itself. And if you do this, you'll see that the result
is the Pauli x matrix. And that's kind of peculiar, and it gives you just a hint that you can do some interesting things with quantum information that you can't do with
classical information. There's no classical operation, meaning one represented
by a stochastic matrix that gives us a not operation
if we perform it twice. So it's a nice example that reveals that quantum operations
behave very differently from classical operations. And that's it for lesson one. In this lesson, we discussed how quantum information works for single systems in isolation, and in the next lesson, we'll talk about how
quantum information works for multiple systems. Thanks for watching. If you have any questions, feel free to leave them in
the comments section below.
