Welcome to the before last lecture of the quantum computing course and this will be

the second lecture explaining this quantum computer programming environment called CIRC.

So in the last lecture we discussed the basics for implementing an algorithm in CIRC and

simulating it and in this lecture and I want to build on that and apply this to do an implementation

of this quantum approximate optimization algorithm that we discussed in the lectures before considering

the CIRC implementations.

So I first install CIRC here in this interactive iPython notebook that you should have access

to on the web pages of the course and then I import a few Python packages, CIRC that

I just installed, NumPy for numerical operations, Sumpy because I will work with parameterized

gates and I want to use the parameter of that gate as a symbol and that is what Sumpy provides

and then Matplotm is a plotting library that I will need for the graphics output and this

print command is just a test that all the imports and installations worked and they

did.

Okay, so then before starting the things that I want to discuss in today's lecture, a brief

recap of what the last lecture was about.

So in that I introduced the basics of CIRC and in particular how our circuit is set up

that implements a quantum algorithm.

So this circuit is a bunch of gate operations acting on qubits that you have defined and

the way this is structured is that these gate operations appear in a sequence of moments.

So a moment is all the gate operations that you can do in parallel and that is typically

set up by the hardware so you cannot do two gate operations on the same qubit in parallel

obviously but determined by the crosstalk between qubits it might be necessary that

you only do gate operations in parallel that on qubits that are separated by more than

one lattice site.

And so all these sequence of moments then forms the circuit.

In the last lecture I discussed how you define qubits either by giving them a name or specifying

a grid on which the qubits live in one or two dimensions and then mentioned a sort of

a set of standard gates that are readily implemented in CIRC but also explained how you can define

gates your own and how you get access to the matrix representation of a gate.

You can build a circuit from gates either by specifying a list of operations and then

there is one command that turns this into a circuit or for an existing circuit you can

append gates at the end or insert gates somewhere in the middle.

And then an important thing in that context is the insert strategy so which determines

when you can apply a gate on a certain qubit and typically you would do this at the first

available point in time.

So here you can for example see this at least so this single qubit gate could act here anywhere

in this time frame on the qubit but the default strategy is that it would act as early as

possible.

So here this is slightly different here apparently the user has specified that the gate should

not act here but only at that point in time and that might be important to choose as well

depending how it works best on the given hardware.

So this is specified by this insert strategy.

Then I also discussed how you can decompose a gate that you would like to do into gates

that are available on a specific hardware and discussed how you would simulate a circuit

and there are two options for that.

So you can have as outputs just the measurement results so that mimics what an actual experiment

on hardware would look like or since this is a simulation there is also an option which

gives you access to the full wave function which is something that in reality you of

course never have.

So then let me start looking into things that I want to discuss today.