 I'm Andrew Cross. I'll talk today through the components in our software stack and talk to the IBM Quantum Experience and the language that we use to communicate with it. And I mean, before I begin, what I'd like to do is give some bounds on the problem that we're interested in solving, you know, the scope of the software that we're trying to write. And, you know, so where we are today, we're sort of in this realm of simple demonstrations on small numbers of qubits. And we're moving in this direction toward larger systems. And these are systems on which we can run small circuits. We can do approximate computations. But we're very far from, you know, a universal fault-tolerant quantum computer. So our goal is to write software that targets this kind of space. And the purpose is to enable research so that we can continue to move forward and to look for advantage where there's advantage to be found. So solve problems with these small quantum processors. Okay. So in a little more detail, our goal for this software stack, we're going to plan for continued improvement of these devices. You know, right now we have five and 16 qubit devices. You've heard other announcements. And so we're planning for these to increase in size and capability and fidelity. And we want to build software tools so that we can continue working with these devices in the near term. So we'd like to look at things such as short depth circuits, investigating algorithms, looking for advantage. And we're going to be in this era of pre-fault tolerance. So we'd like to explore ways to mitigate the errors that we see in these systems. So we need a framework so that we can conduct experiments, can run simulations, and we can analyze the data that we get back. We'd like this interface to be independent of the back ends, because again, we're going to see new back ends in the future. We're going to see new simulation methods. We're going to see new ways of analyzing the results. So we'd like to be able to grow into that. We'd also like to create an infrastructure for rewriting the algorithms that we send, the circuits. And at the very least, you know, if this is meant to be back in independent, we need to take the algorithms and schedule them and map them on to the hardware that we have. So we need an infrastructure for that, and we plan to include that. And then over time, from where we are now to where we plan to go in the coming years, we'd like to expose lower level control interfaces so that you have more control over pulse timing. You have more control over the process of mapping onto the device, more control over the pulse shapes. And we'd like to also move in the other direction as well, so expanding in both directions, introduce some higher level abstraction so it's easier to program. All right. So as a touchstone for this whole talk, I'm just going to keep coming back to this block diagram. So what this is, this is, you know, this is not exactly what's going on, but it's a high level organization of the pieces of the software, as we would imagine them. And it's modeled after how you would think of a quantum compiler. Okay, but we're really going to focus on the right hand side, the lower half of this process. All right. So, you know, on the left, you have the quantum algorithm. You have some high level description of it. You have the results you'd like to get. And at some point, you generate quantum circuits, and these are stitched together by some kind of classical control. At the moment where we have a limited set of classical control, I'll talk about that later, right? But these quantum circuits are then transformed in some way, and they are sent through an API. On the back end, on our systems, these are, you know, converted to pulse sequences. They were on in the experiment. There's a set of controllers and whatnot. And these process results come back through this API. And you can request those results and then analyze them and then continue on. So, of these components, right, the quantum experience is everything behind this API. So, the hardware, right now, the, you know, the software that takes the circuits and maps them to pulse sequences. And then there's the API. There's our open interface language. This is something that will be familiar to people who have been in quantum computing. You know, it's a list of gate operations that you can apply to our system. And then this quiz kit software is built around the circuit abstraction so that you can write circuits and transform them and send them to the back end and process the results. All right, so I'll keep coming back to this picture as we move through these pieces. And I'll start from the right and move to the left. Okay, so I'll start with the quantum experience. And so just to say, so the quantum experience went online about a year and a half ago. And in that time, we now have more than 60,000 users registered. They've logged in from all seven continents, from many universities and colleges and learning institutions. People have run almost 2 million experiments on the devices that are there and have posted many papers to the archive as well investigating the system and what it can do. For example, just to explain what's in this picture, right, these highlighted regions are regions where people have logged in and used. These are countries where people have logged in and used the quantum experience. And the dots I think are learning institutions, educational institutions. So as part of the quantum experience, we've been trying to create, trying to engage with a broader community of educators, developers, students, researchers who are interested in using these devices and learning from them. So we've been traveling and engaging with students. This is an example at USQIP at the Institute for Quantum Computing. Chris Wood is working with students to run examples on the quantum experience. This is a community like a forum that's available on the quantum experience website where people from the public who've requested accounts and researchers, I mean everyone can ask questions and answer each other's questions and we also do our best to moderate and answer questions that come up as well. And here's an example from, I believe from last year on the MIT edX quantum computing course run by Ike Chuang. Where one of the extra credit exercises was to go and look at mapping circuits on to the quantum experience, the five qubit device. All right, so I'd like to say a little bit about what the hardware is that you're controlling. I'm only going to talk about, I'm just going to highlight a few things. If you want more detail, definitely come to Micah Takati's talk this afternoon or at one of the breaks corner and experimentalist and ask them questions. So what you see here is, this is a four qubit device and in these pockets are the single junction transmon qubits and just to give you an idea, right, the qubit transition is five gigahertz. The second excited state is slightly offset by this anharmonicity. Just to give you an idea of the kinds of parameters that are in these systems. And these devices are coupled by coplanar waveguides. So those are these blue and other colored features here. The blue resonators act as buses that couple neighboring qubits and the yellow act as input and output, you know, readouts and drive lines. All right, so the devices that are used in the quantum experience, again these are single junction transmon devices. T1 and T2 are about comparable. They're about 50 microseconds. In fact, you can see all of this if you go to the quantum experience you can look online at the interfaces. But these are the single qubit and two qubit gate fidelities around, you know, error around a percent to five percent. These are the measurement fidelities. And all the devices are some kind of planar geometry. So the five qubit device looks like this bow tie and these are the interactions that are available. Here's a picture of it. And this is the 16 qubit device. So it's a dual rail, two lines connected by edges. This is a picture of the device as well. So these are the five and 16. The five qubit device is available on the graphical interface. And the 16 you can access through this software stack through the API. All right, so good. All right, so I just say a few more words about what the gates are in the system so that when we see them later, you know what I'm referring to. All right, so we need single qubit. We'd like to have arbitrary single qubit gates and then some entangling gates so we can implement universal digital computation. And, I mean, here's how these are implemented. So generally we want to apply something in SU2, some single qubit gate that's arbitrary. We decompose this into Euler angles. So z, y, z rotations. And it happens that these z rotations are easy to apply by adjusting the phase of a carrier. So they are very accurate and fast. So it helps us to decompose the pulse sequence into something of a form where we have this z rotation and then we have some single calibrated gate that we apply in between these phase changes. So that's how these are implemented. If you just want a z rotation, then you can apply this gate. That's instantaneous and there's no pulses, right? If you want to apply something that's a power 2 rotation, then you can apply this gate. That's one pulse. And then if you want to do something in general with two pulses, you can apply that, right? The two qubit gate is a what's called a cross resonance gate. And, I mean, for this talk, what's important about it is that it's directional. So there's a control qubit and a target qubit. And there's one direction where this gate is faster than the other. So that's why we do that this way. And in practice, if you're interested, I mean, this is implemented by a sequence of pulses that correct for some slow fluctuations, right? So this stands for this frame change, this z rotation. This stands for a drag pulse. And this stands for a flat top Gaussian pulse, something that's stretched out. All right, so that gives you an idea of the one and two qubit gates in the system. All right, so if you go to the quantum experience website and you don't even have to log in, actually, but if you look at the top, each of the back ends, the devices are listed there. This is the latest back end in the sense of having a new topology, a new layout. All right, so this is the 16 qubit device. This is the picture of the mask. Now you know these are the CNOT directions. And what you can also see is the last time the cali... No, I grabbed this in October, but this is calibrated in the morning and evening, I believe. Maybe it's calibrated once a day. Anyway, you can see the latest calibration there. And then the results of that calibration is characterized by randomized benchmarking. So there's a single qubit gate error across here. This is cutoff. There are 16 qubits. Readout error for each qubit. And then the multi-qubit gate error. So these numbers are consistent with what I said a few slides ago. If you want even more information about each of these back ends, it's all available on GitHub. So you can go to this URL. And what you can find are, you can find each device. You can see who's contributed to this device, its history, information about, say, in this case, how the readouts are multiplexed, how the gates are implemented. And over here is an example of how the... how the crosstalk is characterized in the device. Okay, so please have a look at that if you're interested. All right. So those are the devices that are available on the Quantum Experience. And now we'd like to think about programming them. So we've chosen an intermediate representation of our circuits that is, you know, it's based on a Quantum Assembly Language type description. This will be, I think, familiar to many people. The model is that you have some register or registers of qubits. You have some set of classical registers. I'll say these, just conceptually, these registers are somehow close to the machine so that you can interact with them and feedback from them eventually. That's what... These aren't meant to represent all the classical memory you're ever going to use in your Quantum Program. They're meant to represent something close. This is a picture, by the way, from the Quantum Experience, from the composer where you can take gates and drag and drop them and construct a circuit and then run it. So I'll just say, you know, here are these U1, U2, U3 gates, the single qubit gates. And this is the two qubit gate. And the rest of these are constructed from these or from doing nothing. And there are some other instructions for... Well, I'll come back to these later, right? There's a measurement and there's a way of controlling the timing. Okay. All right, so a little bit more detail. Since this is a tutorial, eventually I'm going to get to the point where I'm showing you lots of code. So we'll kind of start going in that direction. This is an example of a program that's written in open chasm. So it has these features, right? It has Quantum and classical registers. It has some way of including definitions of gates. And then, right, it's just instruction after instruction, together with what it acts on. And what it... So there are a couple of things that I can point out that are maybe interesting or different from other assembly languages. One is that it has a way of hierarchically defining gates. So here's a Toffoli gate. It's defined in here, right? And it's put here, but that's constructed from, you know, C-nauts and T's, as you'd expect, and those are constructed from U's, right? And it has a mechanism for measurement and feedback. So measurement says where to put the result, and then based on the values of some register, you can apply operations afterwards. Now, at a high level, what this is meant to express is data dependency. You know, do this, then do this, then do this, and here are the inputs I need to do the next step. There's no explicit timing here. The timing happens later at a lower stage. Philosophically, we want to separate Quantum and classical processing as much as we can. This is meant to describe all the quantum computing, and the classical processing should be sort of encapsulated elsewhere. So right now, that's very simple. There's just this if. But in the future, this is sort of the way we'd like to think. And we'd like the language to be agnostic about the hardware that's on the back end. So just a general circuit description language. We are open to discussion, extension. This is open chasm. So, you know, please let us know if there's something you don't like, you want to change. We can talk about it. The specifications are all online. All right. And maybe, yeah, I'll just say, I'll just highlight a few more things, right? This is how you make gates hierarchically from other gates that you've already defined. There are some syntactic things like, you know, in some algorithms, it's quite natural to apply Hadamard and parallel to many gates. So there's a way to do that. This applies to every qubit in this register. And there's this, so this barrier instruction says, you know, it says don't cross this line, right? So if I have an optimizer that's walking through this circuit, what it's going to do is it's not going to combine these two x's into identity, right? It also affects timing. All right. So that's chasm. And now I'd like to start moving to quiz kit. I'll start first with the API itself. So I'm also going to focus mainly on the Python implementations of these components. So I'll talk about the API and then I'll talk about the SDK. All right. All right. So the idea is that, so there's a web API, it's a REST API, and you submit requests to it like the back end I want to use, the set of circuits I want to run. These right now are given as chasm circuits. And how many times to run each of them? It's pretty simple. So you submit this request, right? It's processed, sent to the appropriate back end device. It gets processed further, right? The experiment runs. It comes back. There's queuing. There are other things here that I'm not going to talk about. And after some time, the result comes back to you and you can request it. And it includes the probability that you see each outcome string, how long it took, other kinds of information. One of the important pieces, though, is that it gives you a collection of data that corresponds to the calibration, the most recent calibration before your experiment, which is always good to have and be able to combine with your results. You can also make requests like, you can ask for a lot of information about each back end and some information about the queue. This is all authenticated based on tokens. You go to the Quantum Experience website, you ask for a token, and then you use the token to access this. I'll give an example in just a little bit. So now some code. So this is what it looks like if you just want to use the API. So bare minimum, I want to run something on the device. I want to talk right to the API. So in Python, you can import this module that has the methods in it, construct an API object. You give it the token, you give it the configuration. So this is the URL of the Quantum Experience. I'll show it to you later. And this is some long string of characters. Once you've created this API, you can say what back ends are there. And it's going to send back a dictionary of back ends. You can look at the names of these. So for each back end, let's look at its name. As long as the back end is available. So back ends may become unavailable if they're being calibrated or if they're taking down for some other reason. So you can check that. And this comes back and it tells us that two devices are available. This is 5 and 16. And there's an online simulator. And if we want details, we can go into this back end dictionary and look up one. And we get all the information that's available for that back end. For example, one of the more important pieces of information is how the qubits are connected. So this has pairs of qubits on which you can do a two-qubit gate. So now if you want to directly use the API to run a circuit, here's how you would do it. You need to generate the chasm code. So here it is. This is code that makes a bell state. I have two 5-qubit registers. I apply Hadamard to one of the qubits, a controlled knot between that qubit and another one. And then I measure them both. Specify the back end, how many times to run this experiment, and then it goes. And you get back a blob of data. And I mean, this has a lot of information in it, but what's important to follow up now is the ID of this job. So you can grab this, put it in this call, and check whether or not it's done yet. So that's it. And then when this is complete, you can go and retrieve this, and this will contain all the information. It'll contain what was run, when it was run, calibration data, everything. And among all that data, one of the things you can ask for are these counts. So for each time through this circuit, we get a string, an output string, so the value of this register C. And so this is returning the value of that register C and how many times we saw it out of the total number of shots we requested. All right. So that's great. So you can run quantum circuits, you can run them through the API. Maybe you don't want to work with the API at this level. What if you want to do something that's more complicated? What if you want to optimize your circuits first and send them in? What if you want to use a higher level language to construct your circuits? It's not very easy to program to this API. We'd like to build on top of this. And so that's what we're doing here. We'd like to... Yeah, I'll just continue here. So let me go into some of the details. All right. If you're interested in downloading this and trying any of this for yourself, everything's available starting from here. So if you go here, you can follow from these links to any of the information you need. So just to point out, all open source, it's on GitHub. There are tutorials, documentation, and a link to the quantum experience directly from here, as well as how to get started. Now, I'll go through this in more detail in just a couple minutes. Let me highlight a few of the places you can go from this landing page. So there is documentation for this software. It includes how to get started using it, as well as documentation of the code itself. So whatever level you're interested in looking at this code, you can do it through the documentation. And we've included some of our thinking in terms of how we have currently organized the code. The software is developed openly. It's all on GitHub. You can see our process. You can see who's contributing to this and the things that are currently being worked on through pull requests. We've been very fortunate that people outside of IBM have been interested in contributing as well. The flow is essentially, if you want new features, you would open an issue and we would discuss it. You can submit your code on your own fork through pull requests. This is a relatively standard way of doing this. You can see some of the files in the project for more details about how to contribute. Now, I've focused, and I will continue to focus mainly on the Python, but in this project, you can also see we have a Swift implementation of this code and a JavaScript implementation as well. So if you're interested in using other languages, you can. All right. All right, so the SDK is, the Qwiskit is organized around a quantum program object. And this program object is a collection of quantum circuits that are all somehow related. So the way in which they're related is that the quantum program has a set of quantum and classical registers associated with it. You create those. And then you build circuits. And then you can run those on some backend, get the results, and bring them back. Okay. In the process, you may rewrite them to run on some target backend if you have a limited connectivity. All right. To do that, there is a component that, that rewrites the circuits. We've taken to calling this a trans compiler, and the reason we do this is that we want to emphasize that our goal is not to go from a high level language all the way down to the lowest level code that can run on our system. We want to rewrite chasm to chasm, sort of going horizontally. So limited scope right now. We want to take our input circuits and we want to make sure they run on the backend and we want to make sure we eliminate as many gates as possible before we do that. Okay. Among the back ends it includes simulators as well. So this is, the simulators we have are also part of this project. All right. So how do you get started? All right. So you can, you can get two, two components from the repository. One is a set of tutorial Jupyter notebooks. So you can grab these directly from GitHub and download them. And then there are two ways that you can download the, or if you're interested in, in writing code or looking at the code, you can, you can grab it from GitHub. Or you can simply run pip install and you'll get the latest stable version of it. Okay. So then if you want to get started, if you have, say, Anaconda installed and Jupyter installed, then you just install quizkit and then start Jupyter. And if you want to use an online device, so if you want to use one of the quantum experience devices, there's one other step you have to do. You need to go to the quantum experience website under your account and get the API token there and then substitute it here. So you put in your token and put in the quantum experience URL. Okay. These are also in a file called Qconfig in the, in the repository. You can fill them in there if you like to. All right. So now I'll walk through in the last, in the last part of the talk, I'll go from start to finish and a couple ways of looking at what comes out of that example. All right. So the first thing we need to do is make this quantum program object that will encapsulate everything we're doing in this experiment. All right. And this has methods that are generally, you know, they're in the category of, you know, constructing these circuits and manipulating them. It lets you import and export to this space with backends, obviously. Anyway, so this is what it looks like to get started. So you make this program, you create a quantum register or two or three. This is the name that will appear in the chasm text and this is the Python object to manipulate it. Similarly with the classical registers. All right. So then this is what it looks like to create a, build a basic circuit for a bell state. So make a program, create a two-qubit register and create a classical register for the results. Now we have all the objects we need. Now we can create a circuit bell that we'll use to build up the circuit. And on this object we can apply gates that, so these gates live here, they live in something that we call the extensions. And you can, if something's not there you can add new extensions and they add new methods on to these circuit objects. All right. I'll say more about it in a second. But this had a hard C knot as you'd expect to make this state. Now we'd also like to measure it and we may want to measure it in several different ways. So let's begin by measuring it in the Z basis. So we'll make another circuit. It uses the same quantum registers and here we just measure all of Q into all of C. So let me just say the extension. The short answer is that everything that is in the, if you click advanced on the quantum experience all the gates that are there are in this extension. It's more or less what you would find in a quantum computing textbook. So the single qubit gates that you familiar with like Clifford plus T these are the U gates that are fundamental in our system right now. Two qubit gates. Toughly, measure, reset. Reset is not supported on the hardware right now. And then there are a few other construction methods and this will grow. Right now it's relatively basic but you can take a gate, apply it and then invert it. And you can add classical controls to the gates. This will work in the simulator but again not on the experiment. So that gives you some idea of what's there. I believe the three qubit gate the three qubit gate should work through the through quiz gate. So because it will be I'm sorry? Yeah, I believe it should. So it should be mapped down to two qubit gates and single qubit gates and then those should be mapped onto the hardware. Alright, so we've constructed these circuits. How do you get some more information? There are some methods to access this right? So you can say what circuits do I have in this program? What registers do I have? What classical bits do I have? Things you might need to know. And if you want you can ask for those circuits back in chasm form and they come back in essentially the same way that you program them. They're not rewritten in any other basis. Okay. Alright, so for this Bell example you want to measure in more than the Z basis because you want to see that these qubits really are entangled. Alright, so to do that you may want to measure say in the X basis. So we can create a new circuit to measure X apply Hadamard to that register and then measure it. And now we can take these pieces and compose them. So there's a plus operator that acts on circuits so you can begin to stitch together more complicated circuits from these basic pieces. So now we build the two circuits we're actually interested in running. Make the Bell state measure it in the Z basis make the Bell state measure in the X basis. Okay, now we want to run it. So we say well what back ends are available. If you just type this without setting up anything what you would get back is the list of local back ends. So on my machine this is two Python simulators and a C simulator. Okay, and if you set the API and you make the same call add it to the list. This list will be all of the online back ends as well. So the simulator that runs remotely and the quantum experience devices. You can ask for the ones that are the online back ends. So now let's run the Bell state example. We set up the API again. Now in this step we're going to say is how are the qubits connected. So give me this map of couplings. So ask for the back end configuration get the couplings. And now we say run the Z measurement circuit and the X measurement circuit in one job. Put them all together and send them through the API at once. And here's how the qubits are connected on this QX4 device. Run this a thousand times for each circuit. And this will go through the API, it will come back. This call is blocking, but there are other calls that will submit everything and you can come back later and check. And so after a while you can ask this result object for the results for each circuit. So in this case measuring in the Z basis we see some output like this from this 5 qubit device. And in the X basis we see this. What you can notice is that most of the outcomes are 0, 0, and 1, 1 as you'd expect for a Bell state. And these in the middle, these are errors. Similarly in the X basis you see something just like that. So you see them correlated regardless of the basis you measure it. All right. So I mean I alluded to this earlier but this instruction we wrote down from 0 to 1. But the hardware, this gate direction has to be from 1 to 0. So what happened? I mean what happened is that when you called execute it called some code that rewrote the circuit for you. So in the original chasm there was a Hadamarder C knot from 0 to 1. And now the 1 and 0 labels just got flipped over here. And the relabeling happened on the measurement. So that's an example of this rewriting that we're working on. Again the goals for this piece are to map the circuit on to one that can run on whatever back end we have in the future or now. And also to try to eliminate instructions so that we have more accurate results at the end. All right. So now we can run the experiment. We can look at these histograms. Oh sorry go ahead. You have a question? Yes. It usually is more complicated. Yeah. Does this actually do a graph getting or does it do something to the future? Yeah. I'll say a few more words about what it does but yeah it's right now. Right now what's there is not close to optimal but it works for any layout graph. I'll say more about it in a second. All right. In the experiment let's run a simulation. Now in the simulation of course we can ask for the state. We don't have to take shots. So if you'd like to do that what you can do is you can take the same circuit you don't have to do any of that again but you can just change the name of the back end. And whenever a shot is set to one here it will just compute the state vector or the unitary or whatever the mathematical object is that you want from that simulator. And then you ask for the results and in this data in this case for this local simulator it will give you an array that corresponds to the quantum state. This is 0, 0 and this is 1, 1. You can do the same thing if you want to know the unitary operation that you applied. So in this case it's very easy to read but it's there. Both of these Python simulators they'll work for small circuits. We have coming quite soon some C simulators and at the moment if you also need a very fast simulator you can use the online simulators as well. So there are there's a tools module in QuizKit that includes some plotting and includes some other useful functions and we'll be extending this but let me just give an example from here. You can construct the density matrix corresponding to that quantum state from the previous slide and then plot it. There are a couple different ways you can view it but this is a pretty standard way of looking at this. This is the city plot. So you can see the main diagonal of the density matrix 0, 0 and 1, 1 and then the coherences. All right. So I'm going to take two slides just in case you're curious just to know what's underneath what's behind this there are four representations inside QuizKit for quantum circuits and we move back and forth between them as we need to and in the future I'll say what these are first and then I'll make my comment. So the main input representation is chasm text and when this is input it's parsed. You get some syntax tree corresponding to the grammar of chasm and then from here it's a project. And this is just a hierarchical list of gate objects. It's not too surprising there are instructions and there is a hierarchy of objects so that we can manipulate each of these instructions. When we want to rewrite the circuit it's very natural to take the circuit and express it as a directed graph. So something like this you have a bunch of input qubit nodes you have nodes for each gate and you have output nodes to express the circuit when you need to rewrite it. Right now we move back and forth between these as we please in the future our focus is going to be to go to this representation stay here and move over to this representation or others that we may need as we rewrite the circuit. And just to comment on what's underneath this mapping process right now this is what's here this is what passes it's just four simple passes and it gives you a circuit that will run on the device this can be improved but here is what is there so we take the input chasm we expand all these gate macros so now it's written in terms of C knots and these U sub J gates this goes to swap insertion algorithm it uses a randomized greedy layer by layer algorithm to apply the permutations between these layers and then this introduces some redundancy so we try to clean that up a little bit we remove runs of C knot gates and then we optimize runs of single qubit gates that come from this and that's all we do this last method attempts to minimize for each run of single qubit gates give you the minimum number of pulses to implement that gate the way we're moving hopefully you'll see this in the coming months we have a more modular framework something that we can build on and extend and use for our research alright so in the last couple minutes just want to talk about some more advanced things you could do with quiz kit alright so if we wanted to characterize the state coming out of the experiment one way to do this is with quantum state tomography and in that case we need to append many different measurements after building and of course we're doing this in a higher level language like python so we can just write the functions we need to automate all of this and put them into our set of tools so some of these tools have already been written for you you can find them again under here there are tools for quantum characterization and validations example here is state tomography so you can use these methods say what qubits you want to measure build some state tomography circuits for your bell circuit and right it's going to create this array of create the bell state and then do the measurement that you need underneath right this is all python scripts you can look at the source code to do this alright so if we run on the so here we're running on the simulator right but we can take these tomography circuits and just run them and ask for the counts and these are all the results we get from running those tomography circuits each one a thousand times or something like this and then there are methods here that will let you put that data in a form that can be processed and then put it into a fitter the details of which are in this code you can look and obtain an estimate of the density matrix and then plot that you can do this just as well changing the back end to the experiment alright so there are many other examples that you can find online not just a bell state and it's possible to run relatively complicated things through the API to help you with this there are some tools that are part of the SDK they include things for visualizing states and analyzing them they're helpers for optimization and quantum chemistry QCVV and there's a collection of 24 jupiter notebooks at this site and they illustrate how to use the SDK they illustrate ideas from verification and validation near-term applications and quantum games there's some things you can do I guess I'll highlight one of these you can measure T1 for yourself you don't have to believe what comes out of our calibration you can measure T2 you can violate bell inequality just to conclude this is our interface for experiments and simulations our goal is to enable our own research, enable your research enable educators and students and we're looking at applications in this time period before we reach fault tolerance so that is our goal right now we have a growing software stack we're going to keep building tutorials, keep adding examples and plan to use this for quantum experience and access to other devices it's a completely open source process so you can expect to see new releases periodically and we have ongoing projects right now to improve pieces of our infrastructure improve our simulators visualizers change our back end interfaces things like this so if you're interested now or at any point in time you can go here and have a look if you'd like to contribute code and if you'd like to participate in discussions that help us define our next steps with this we have a Slack channel that you can join it's if you'd like an invitation you can go to the quiz kit landing page and there's a link right at the top that you can click to join and come talk with us on this community alright with that thank you is the simulator purely unitary or does it include noise and decoherence? yeah so the question was does the simulator include noise and decoherence so the current simulators that you can find online are ideal simulators but very soon we will be making available a simulator that includes noise such as de-polarizing noise and T1, T2 yeah unitary errors yeah there's a question here what's the circuit size limitation? yeah so I don't have off the top of my head the hard limitation I I mean I've run benchmarking experiments with many hundreds of single cubic gates through the API and I do know that near 42 cubic gates I was able to run through the interface as well but I don't know the hard limits to that we could try to talk offline other questions? can you say something about gate parallelization and the barriers and the timing and stuff? so right now I believe that when you submit a circuit and it's scheduled the goal is to maximize the volume so two cubic gates that can run in parallel will that may not be always what you desire but I believe that's what happens other questions? let's thank Andrew again for the tutorial