 ## Subtitles section Play video

• We talked a bit about the hardware, you know, people are working on the hardware of quantum computing, yep

• What about software? where do you start thinking about that?

• Writing software for a quantum computer

• In my opinion is actually not very very different from how we write software for just a normal computer

• and we think about

• software in terms of being able to write down instructions

• for the computer and the computer executing these instructions changing some internal state when I write instructions for

• any type of computer whether it be like a modern MacBook Pro or an old PDP-11

• In both cases in the end, we have an assembly code that gets executed that's changing the memory the disk

• The registers in your CPU and so on and it's not different with a quantum computer

• It's just like the question is what are we changing?

• And how do we change them? We can really describe these things

• in quite simple terms, if we were to do this in with sort of full textbook honesty, we would discuss things like

• finite dimensional vector spaces and in Hilbert spaces and

• Linear operators and unitary maps and all that stuff and all that stuff is very very important

• If if you're actually sitting down writing a program but to get an understanding of it

• I think we can do away with it. And actually just think about things in terms of simple probabilities. So the idea of a Qubit

• So Qubit is a Bit in a quantom computer

• Yep it is. Yeah. It's sort of the fundamental building block. It's like a it's like a bit and a regular computer

• The way I think of it is it's a resource in the computer. It's a resource that you can use to perform a computation

• So a qubit to me is anything it's sort of abstract. But anything that has two states of being and

• Some possibility or probability of those states. So for instance we can think about

• Photons and their polarization a photon can be sort of polarized left and right or it can be polarized up and down

• But if we're not looking then maybe it's it's possibly in one or the other. Maybe it's 50%

• moving and traversing left and right and 50%

• Moving up and down. This is just for photons

• Turns out there are lots and lots of different ways to construct qubits the qubits that that we work on in the so called field

• Of superconducting quantum computation. We use a device called a superconducting charge qubit

• It doesn't matter all the details, but it suffice to say that the two states there

• Are is their charge or is there no charge in this circuit?

• And then of course, we have the same thing. It could we could have a probability like maybe there's a 10% chance

• there's a charge or maybe there's a

• 90% chance there's a charge. These are called superconducting charge

• Qubits again, it sounds complicated, but the essence is the same two states

• but maybe it's in one or the other the interesting thing though is

• When we have multiple qubits, and this is really where the power of quantum computation happens

• We can actually think of it sort of simply

• Diagrammatically that if qubits if I just represent them sort of as a circle here, maybe we have three the idea

• Is that these qubits can interact this guy can interact with this guy?

• this guy can interact with this guy and these can interact with one another and every time we add a qubit if we were to

• Add a circle here. Let's say we added this fourth qubit right here

• We noticed that every single one of them can now interact with it. We have to draw lots of these lines

• It turns out that a quantum computer can deal with these additions of qubits in a very efficient fashion

• But like I said a qubit is something where it has two states

• So each of these guys can be in two states with a particular probability

• let's say the two states and our just 0 and 1, our qubit can be 0 or 1 or

• Possibly something in between. So if I write down these qubits with the probability, let's say we have three qubits here

• I'll call it Q0

• Q1 and Q2 what we have is

• That qubit 0 let's say it's this one right here 1 and 2, well qubit 0 could be in 0 or 1

• so it has some probability of being in 0

• Qubit 1 also has some probability of being in 0 and qubit 0 also has some probability being in 0

• maybe that's a 10% chance

• But now we have to painstakingly go through a write every one qubit 0 has a probability of being in the 0 state

• Qubit 1 also 0 and qubit 2 and we can write down all these possibilities

• Etc, etc until we get to the possibility that all of them are one and each of them has a probability. Maybe this is 5%

• Maybe this is 7%, maybe this is like 35%, maybe there's a very high percentage chance that all of them are one

• 8% and so on

• so every time we add a qubit the size of this table doubles the number of probability percentages doubles and it turns out that

• these probabilities right here are ultimately what a quantum computer is computing with when we do an

• Instruction on a quantum computer when we instruct it to do something in the end

• it's always about changing these probabilities to favor some computation that we're trying to do

• When we start up a quantum computer, when we flick the switch on

• it'll start as 100% in this state and everything else will be 0%

• We start off here, and we know that we start off here. It might be that when we apply a certain operation

• So for example an operation as is the so called

• superposition

• Initialization or we call it Hadamard initialization

• This is if we have any number of qubits, so starting off in zero, and maybe we want every probability to be equal

• So if we want to start off here

• We do something called Hadamard initialization where we do

• a particular instruction called the Hadamard gate and what happens is this 100% now turns into

• Let's say we just have one qubit

• It would be 50% chance in the zero State and 50% chance in the one state if we had two qubits Hadamard

• initialization would cause us to be 25% chance with both qubits being 0

• 25% chance

• 0 1

• 25% chance being 1 0

• 25% chance being 1 1 the point is is that this particular instructions one instruction on a quantum computer?

• Allows us to change these probabilities in a way that we'd like and it might be useful for us to do something like this Hadamard

• Initialization with all the probabilities being equal because then from here we could do some operation that affects all these qubits and affects all these

• Probabilities sort of in the same way. But like I said, this is just one possible instruction

• So there can be an infinite number just like a normal computer it's not that they're an infinite number of instructions

• It's that they're an infinite of possible things you could do with the instructions

• So one of the greatest discoveries was that we can arrange these probabilities to be in whatever way that we would like

• Using five instructions total

• there are sort of five different ways that we can

• Permute these things and change them and there are this, one is called a measure instruction

• measure instruction is pretty important because while we're talking about probabilities

• we can't actually see these probabilities in the quantum computer

• They're just in there

• At some point. We do want to see are they zeros or ones? Like we need to answer that question

• So the measure instruction will take any list of probabilities and turn it into

• One of them will change to 100% So each of these is 25% chance. It'll pick one

• Let's say it's this one right here and measure is gonna make this a hundred percent with the other ones being zero percent

• That's one way of changing and then incidentally we also get to read out from the clunkier that it was a 1 0

• That's how we get our answers. That's the only way we get an answer. In fact from the quantum computer

• The rest of them are just purely ways of changing these probabilities. There are lots of different ways

• You can have instruction just like norm...

• Regular computers every single computer that's ever been built or every single CPU that's erver been built always has a different instruction set

• One possible instruction set is the following we have this Hadamard

• Is that named after someone?

• Yes, it's named after I think he was a mathematician

• He worked on a variety of mathematical subjects and there's a matrix that's actually one divided by square root of 2

• 1 1 1 negative 1 which is a so-called Hadamard matrix

• Incidentally this is also used to represent how these probabilities change so Hadamard is one instruction

• There's another instruction called Phase, again It just has the effect of changing probabilities around in a particular way

• There's another instruction called the T gate not very

• Creatively named there's another instruction called the CNOT gate and what's special

• about the CNOT gate is that all of these right here act on one qubit

• We say I want to do a measure on qubit 2 or i want to do a T gate on qubit 0

• It sort of affects only one qubit. It'll affect a lot of probabilities because even though we're operating on one qubit here

• it accounts for this entire column so it actually changes all the probabilities

• CNOT is special because we get to choose two qubits

• This is how we get this

• interaction between them so CNOT you can say I want to do this on qubit 0 and qubit 2

• For instance and this itself is an instruction in a sort of quantum assembly code

• Are these instructions a bit like gates?

• Yea, so they are like gates but there's an interesting reversal and for example a NAND gate is something like this where data is coming

• Into the gate and data comes out of the gate

• what's interesting about these gates and quantum computation is sort of the opposite you have data that's sitting there all these probabilities and

• You like apply the gate to the Machine and all the probabilities change. So you're not sending data into the gate

• You're not putting this gate on the chip like a NAND gate for instance

• Is a gate that you would actually etch into a chip

• Here it's an instruction that you apply to the computer and it changes these probabilities, but nonetheless

• They're both different operations that you do on data

• And how does what you do is code get changed into these operations of instructions

• Yeah, so like with normal computers you can write these instructions out as assembly code. In fact one example is

• Say I want the following probabilities

• I have 0 0 0 1 1 0 1 1 I want this I want it to be 50% chance to be 0 0 or

• 50% chance to be 1 1 this is called a bell state with a bell state. It's interesting because

• Theoretically let's suppose I have a qubit. Let's say close I could hold a qubit and

• Let's say I gave you a qubit

• it's 50% chance 0 0 or 50% chance 1 1

• so even if we travelled halfway across the world and I decided to measure my qubit with the measure

• Instruction and I determine that to 0

• Then I know for certain that you must be a 0 because there's a zero percent chance that were different, but somehow we determine this

• It's a 50% chance. It's not that it is already chosen literally is 50% chance. You don't know which one it is

• So we can write a program to construct a bell state

• I won't explain exactly why it works this way

• But you do a Hadamard on my qubit, qubit 0 we do a CNOT on

• My qubit and your qubit and we're done. This is a quantum program. You can write this out.

• Now there are higher levels of quantum programming where we don't want to restrict ourselves these instructions

• Maybe I want to more directly Express the probabilities and how I want them to change

• They all have to add up to 1 of course. I mean, we have a certain percentage chance

• It has to be 100% in the end, but maybe I want to shift the probabilities around in a particular way

• But not in any of the ways that's in our gate set

• I can write that down that can use something called a quantum

• compiler a piece of software that that converts what I want into these native instructions that gives me the

• next level of abstraction in the code

• we can go all the way up to using a full-blown library for writing this stuff one library that

• We've constructed is something called "PyQuil"

• Which allows us to actually write Python code to express quantum computations in Quil is actually this instruction set here

• Quil stands for quantum instruction language, which lets you write down this assembly code

• But hey, who came up with this things?

• is this a commercial thing or is this like...

• Yeah, yeah so quil was originally this particular type of instruction set

• Was a paper that I actually wrote a while ago

• The idea of gates and everything was very well known for many decades previous to that

• So this is a particular encoding of gates as instructions PyQuil is a library that's open source, it's free

• There are no restrictions really on using it to construct these programs, but it does allow you to actually connect up to

• Rigetti Computing's real quantum computers if you if you so pleased to actually run your programs

• But if you don't want to connect up to the quantum computers and you just want to simulate on your own laptop this can connect

• Up to a an open source

• Simulation tool that we have if you just kind of want to see how these probabilities change and so on

• Not quite you still have to express a quantum computation so a quantum computer doesn't print things out it's

• it's manipulating these probabilities so at some point you start to express things as

• Quantum instructions, so definitely if you wanted to make a bell state writing the bell state program you could do that

• But could you write "Hello world?" No, and this goes back to the fact that the quantum computer is a coprocessor

• Just like saying you don't write 'Hello World' on your GPU generally

• You don't express any particular computation and you also don't compile Python Into code on your GPU

• You write special code within Python that gets run on your GPU and it's the same thing with quantum computing

• and i know you said there are certain stabilty issues do you get hard answers outta this?

• So, yeah, so when an answer comes out when you measure you do get definite answer out, however

• since there's noise what we have to do is write our program get an answer out and store that and actually

• Rerun it multiple times

• We have to gather statistics about the answer and it turns out that the more you do this the more

• Accurate your answers become and that is to account for noise in the quantum computer currently

• So when we're talking about setting these probabilities, what you want them to be

• and i understand kind of running operations and gates to do

• just sounds like you know the answer

• Yeah, no, you don't know the answer

• You just show that

• If you were to do this series of operations that you'd get the right answer on, the answer might be different depending

• ofcourse the answer will be diffrent depending on the problem that you have

• so for instance one of the

• Main questions the quantum computer can solve is the same question that you can get from something called the Fourier

• Transform where you can find if you have like a sound wave and you want to find what frequencies it has

• you know that if you run the Fourier transform

• Proven using mathematics and so on that the answer will be the set of frequencies that make up that sound

• Likewise here. There's actually something called a quantum Fourier transform where if you run it

• you know that probabilities will accumulate on the

• Answers or the frequencies. Maybe that your that your sound wave has

• So, you know just by the construction of your program that you'll get the correct answer

• Not that you know the correct answer itself at the front-end, and that's the same with classical computing in my opinion

• You rarely do you know what the final answer is

• You just know the computation or the program that you've written will produce the correct answer

• You need more than one qubit to make this work

• You can use a qubit

• if you have a normal qubit your table is gonna look like this you're gonna have prob and

• Maybe it's like 50% in your states are just 0 and 1

• Except they're just not very many useful things you can do with a single qubit

• the power really comes from multiple qubits because you get this nice scaling law where if you have n qubits the number of

• Probabilities that you get to work with is 2 to the power of n so every single additional qubit you're doubling the number of probabilities that you have to work with

• How do you know how to do that for a regular computer though

• Well, I suppose with a regular computer if you're if you're adding numbers together

• Yep something comes out. Mm-hmm. It's the same thing at the quantum computer

• Your input is a bunch of probabilities which you know at the very start and all these gates change those probabilities in a controlled way

• You know exactly how Hadamard or Phase or T or CNOT

• you know exactly how it's gonna change those and you can write down exactly how it'll change those so you can

• Mechanically do the computation in the same way that we can mechanically do it with adders or ale use or whatever

• Just turns out that the most basic type of computation is actually a really it's a really large one

• It's actually equivalent to a big matrix multiply. If you were to write this out your probabilities as a column vector

• 50% 25%

• Whatever 7% etc, etc

• Every operation in a quantum computer is actually specified as a matrix. You have a big set of matrix elements

• Maybe it's like 1 0 0 0 0 0 0 0

• 1 1/2

• 3/4 whatever I'm making it up as I go along of course, but you know with certainty 100% certainty that this operation

• Maybe this is like Hadamard on qubit 0 and Hadamard on qubit 1 or something like that

• it's not but you know that this operation is gonna change his probabilities and I could if I wanted to

• Manually go and compute this matrix multiplication. The thing is like I said this vector right here grows

• doubles in size every time I add a qubit so it's better for a quantum computer to do it as opposed to me