Fred Chong: Closing the Gap between Quantum Algorithms and Machines with Hardware-Software Co-Design

it's a lot yeah so that what I'm going to talk about today is a sort of pole system and in particular you know we're looking at building a very optimized domain-specific language software stack to go from algorithms to machines and this is this the emphasis of this project which you've got the the acronym right it's a and it's really sort of exciting collaboration between theory people at MIT computer scientists at Chicago and sort of device people at Chicago and Duke alright so since this is I'm guessing a fairly quantum friendly crowd I'm not gonna do my cell of why do we care about quantum computation but I will start with you know we're in this pretty exciting time right which i think is i think john fresco was right that it's a sort of a historic time that we're gonna have these machines you know which these are all still being tested really but we're gonna have these machines that are of a scale that we can't simulate right on classical so we're definitely gonna have a lot more understanding machines work and hopefully they're also going to be of a scale in which we can actually solve interesting problems and so it you know as a as a computer scientist and computer architect i often look back at the 1950s in computer science and so that's except essentially where we are in quantum computation so it's a really fun time okay that being said so the emphasis of this our project and i think of many people around the world is this issue that you know we look at the algorithms that we traditionally care about and the machines that we can expect into the next you know sort of five or ten years there's quite a large gap between if we just looked at you but now right in terms of what you need and so you know luckily there are some algorithms that might be interesting that require much more modest number fits but still there's a pretty substantial gap maybe three orders of magnitude between you know these algorithms being usefully run and the machines that we expect so you know what we believe is that we can with a sort of careful design of the software stack and maybe some redesign of the hardware make the mapping from these algorithms to these machines much more efficient and so you know we're gonna look at this fairly traditional software stack of software hardware stack and we're gonna actually look at you know the way that we're actually going to be more efficient is actually by breaking through those layers of abstraction and those layers of the stack and actually expose much more of device properties up to the languages software and we have this pretty aggressive goal in our project which is sort of what God asked the expedition which is to say we're going to get a hundred to a thousand X more efficiency sounds pretty aggressive but actually you'll see I'm gonna give you a whole bunch of examples of things we've done and we plan to do and I hope that people help us do that will give us that greater efficiency and the sort of the punchline of having that greater efficiency is that amounts to about 10 to 20 years of building better machines right and so if we can actually get a hundred to a thousand X greater efficiency we can run these algorithms on these machines much sooner than if we didn't right and one thing I should clarify is when I talk about greater efficiency you know I've sort of shown this in the sort of easy way of just number key bits but it's actually number of qubits and number of gates and the reliability that you need from those cupids in things right so those are the three dimensions upon which we focus in terms of all our authorizations to get this great okay so now I'm gonna give you a whole bunch of examples okay of things that you can do if you break through that stack and you make you make the Machine more visible for the software and how much more efficiency you can get okay so the first one is compiling programs directly to control pulses now I showed you that stack so on the left side of this picture is sort of the way we used to do things right sort of the way that most people do things and what what we do is we take a program in our case is written essentially in C with some special call instructions and we compile it down to essentially quantum gates or some logical set of quantum gates which we call quantum assembly and then we compile that down to a machine specific set of gates right and then we compile that down to a series of control pulses in this case microwave control pulses for receiving vector machine but it could be you know laser pulses for a cat polish right so this is the old way okay so the new way is basically we're going to take a set of quantum assembly set of gates and we're going to group them together and to say a ten qubit operation like a 10 cubed function whole bunch of things at once and this is this aggregated instruction and then we take that and we feed it to the grape tool which is a gradient descent rule which basically treats the function as a start state and an end State in a high dimensional space and it basis basically searches for the shortest pulse sequence it can to get from the start state so here's an example right so here's a simple optimization for QA Oh a and we break it into these three pieces and then if we just look at this middle piece here if we took each gate and we translated it separately into pulses it would look like this right if instead we take this and we feed the whole thing too great it looks like this right so it's about 3x shorter in time and it's a simpler okay so this is an interesting thing right it's basically sort of just we pay the cost of not having this nice common interface which is the quantum assembly or gate quantum gates instead we have to expose the pulse interface which interestingly iBM has exposed as something called open pulse and then we try to program and yep it's automated in fact so today I'm okay so I should get back this is have this past pause so s+ is a conference paper appears there and on the archive and so in fact this separation is actually our contribution this the ability to do this sort of existed in this tool great but it only scales so what you have to do is you have to do this in a smart way and there are a number of things that have to happen you have to be careful about parallelism and you have to be careful about you can optimize things like that so the compiler actually does a whole bunch of things to get those blocks okay so once you get those blocks then you can do a nice job of this and I'll just give you a little bit of a summary here since I'm the interesting thing that we found was so these graphs are you start with the old way which is every one and two qubit gates right and we aggregate to the right which is we make bigger and bigger blocks okay and then this is the speed-up from the base case so how much faster are we as we go to the right now what's interesting if you take a look at these mostly arithmetic circuits and some chemistry circuits what you find is that some of them are more parallel in their execution and some of them are more serial and the more parallel ones actually tail off quicker right because what happens is when you get blocks that are too big you you accidentally sequential eyes the circuit okay so if you had a lot of parallelism then that's going to hurt you and then your speed-up sort of bottom self but on the right there you have the circuits that are more serial and this approach actually works better because you can use bigger and bigger blocks and it's scales which it does eventually tail off part of that is also because the rape tool cannot find a good solution okay so I think this is what actually one of the approaches I think I'm most excited about is this directed pulse thing it's interesting because it breaks the extraction of this gate abstraction which we as architects think is the instruction set architecture it gives us about 6x decrease in latency in what we looked at up to 10x it's especially useful this was done on Dave Schuster's machine at at the in British Chicago and it uses a lot of swaps on that machine and the swaps actually get optimized really well into the pulse sequence and we're planning to run this on IBM machines using their open pulse interface probably this summer and eventually when we get a trap ion machine that can support arbitrary pulses without hand programming we will also so that's the first example and like I said what I'm gonna do today is show you how much of examples of like sort of five to ten x increases in efficiency which we haven't really composed yet but we hope to in the life of the project yeah yep yeah that is an interesting question probably now a little depends you could but probably not in the sense that this also this pulse opposition can also include like the noise model and the communication so it actually it's nice because it could optimize as many things at once right it's also bad because it's complex it's very tense in fact the next I don't have it on here but the next thing that we're working on is a way to incremental e compile because this is like 1 to 10 hours of compilation for one write it but if you look at an iterative like a DQ e variational algorithm you're going through thousands of iterations where every time a few parameters came and so we're working on like partially compiling that and then fixing up the parameters all right so here's another example of exposing the machine to the software and in upper layers of the stack right what this work is is it's optimizing for a specific machine right a specific number of key bits specific connectivity and the quality of the qubits and the quality of that of each connection on that day right so if you look at the IBM machines they calibrate actually twice a day they publish their data once a day and you look at the calibration data you can see that the quality of the qubits is like four cubits varies every day right and it's not even the case that the same qubit is always the worst although the orange one is pretty bad and the blue one is bad but so so these are you know so the variation in qubits this is variation in two qubit operators so the coupling bits you can see once again like different ones have much different error rates writes to the gate error rate up is bad so what you see is day to day it varies a lot and it's very different for different qubits and different connectivity's or couplings so this is once again another s+ paper that just appeared which you can find on the archive and what we're gonna do is we're gonna use a generalized solver so it's a SMT solver which is satisfy building modular theory solver which is sort of a Sat solver generalized and constraints and so we express all this in terms of constraints and then we run it through the solver ok so what does what what will the solver do what it will do is it will avoid bad links and bad qubits so we're given this so this would be a mapping of this circuit on this machine physical machine without worrying about the bad links which are the red X's and the bad qubits which are these great guys all right and here's a mapping which avoids all of those and so the result is here this is compared with the native IBM software quits good and then we have two versions of our software one which optimizes for time so shortest death number of time steps one that optimizes for reliability and what you see is that okay up is better that's the success rate meaning you take a thousand shots machine how many of them have the correct answer right and you see that's substantially better right in the native IBM software average about 3x right up to about 18x better reliability at the moment it doesn't yeah or that version of it doesn't scale very well so you could have up to about 500 qubits which is actually but but at some point you know the SMT solver is high complexity right and it's gonna it's gonna run out of compute time but it is the case that it turns out that scalability is for optimizing for the Global's reliability of the circuit if instead you optimize for every time step independently locally you get about the same result actually and then you can improve the scalability so that could be fixed and then there's actually a follow-on paper this this work was done with Princeton and Princeton is doing has actually it's going to appear in has a new paper which is running this system on both here and the Righetti and I think the result is basically that you know this method beats all of the native software of all three although it it's not 18x better because the Kapton machine is essentially more reliable it's like more consistent right what this adapts to is variability I think it's pretty small it's norbert ran the experiments i'm not on this paper i think it's oh well that's a different like great great yeah we haven't done great on that it's true that's right we could just run great except that Norbert won't program in our defenses I asked him he's like but I would have to program in like hundreds of things so that that experiment is waiting for probably junk science machine yeah how do we yeah yeah yeah this yeah right right that that's right they published that every day we would need to have that I mean the whole point of this particular work is to adapt to the irregularity or variation in the Machine right so we have to know what the variation is huh we this is it's somewhat stable for the day you know there's some there are some sensitivity results in the paper where you know it's actually not that stable they like if we calibrate it more often it would be better but this is just sort of the first-order result that if you adapted versus not enough okay next one this one sort of neat this is another thing where we're going to expose the machine and what we're gonna do is we're gonna use putrid instead of two bits right so this this paper actually came about because I think I was at Yale and Michelle Dever I said and and then one of my students was like did you know this multi control gate and it's like really expensive okay so then essentially what happened was they decided oh how do we control support things like multi control gates takes a lot of it Sylla how do we do it without insula we're gonna use cute Ritz instead okay so essentially what we're gonna do is we're going to borrow the third state in some devices so we're not gonna have more devices in our machine but we're gonna borrow the third state in some of the devices to store an insulin sort of so what this work does is it takes circuits that are 0 and Sylla and it makes them much lower depth and so it goes from linear depth to log depth if you have 0 n so it's actually the case if you have a few in Scylla you but it's pretty interesting right now in the NIST era where every bit counts right and so if you don't want to pay extra and so low you can really do pretty well and the gate count so this is the depth the gate count is still linear but the constant is way smaller and so what is this right so if you look at this circuit right the generalization of qubit circuits is that this is a control on this gate right and the two basically means you have to be in the second state for that control and this is basically the generalization of an ex gate but it's like modulo modulo 3 right so you increment and so you can build circuits like this which essentially they look a lot like the insula based circuits of for example multi control topple II and you would basically build a tree event Sullivans here instead you built a tree of few traits and so it's really interesting because cute traits traits in general have been an area of speculation in classical computing for a really long time and they really just haven't taken hold right and that's really because there's just an information density argument right it's like you get a little bit more information in HQ turret than you do in each qubit and there's a lot of complexity with dealing with the future at operators and things like that but in this case because the ancilla are so critical to the depth of the circuit it ends up being a very profitable thing to do okay without carrots it would it would look a lot like this but you would the the version of this would be basically twice as many you have to have n and so uh to build the same thing and we're just basically stealing in and so uh what's interesting is we're stealing it from Putra it's not boil at like two ports right so they initially did this paper with Q quartz and I'm like oh come on that's just like having right and then they were able to do it this way okay but the main thing that's interesting is that if you have cute writs you have to go into a higher energy state and that actually costs you because it's greater error so besides coming up with these circuits one of the things is to do a lot of some noise modeling to figure out is it profitable to use a third state and before I show you that here's some other circuits here's an incrementer and then these are just applications of the multi control so these are some of the benchmark needs circuits that we use okay so this is sort of a punchline right what's the fidelity of the circuit once you add and so we ran it through a whole bunch of superconducting and trapped ion models and the models basically look at you know what's the increased error rate of the third state and so like in superconductors you basically have a higher photon number so you have the greater chance of photon loss and this these different ones are basically this is sort of the baseline model and these are great better t1 time better gate time better t1 and better gate time basically you can't even run some of our circuits because the baseline model can't handle that depth so so for example here this fidelity is very low for the qubit version and so what you see is essentially the fidelity is a little bit a lot better than the no and so a version because the depth is so high and a little bit better right then the the linear insula version so the result is basically we don't have linear and so a number of devices is like factor of two less but the fidelity is pretty good actually quite a lot better in some cases right that was interesting in the trapped on world once again trapped ion machines are pretty good so the the difference isn't as much right like you can see it's already in the Indy and silver version we have about it 89% fidelity and the drift key trade is using a special encoding of the last error okay so so this is really pretty cool in terms of you know if we expose the machine interface so that we can use higher energy states we can store more information we can restructure the circuits we can get asymptotically better circuit depth under depending upon what assumptions so it's really nice resolve it's like and it's appearing in our there it does it does consider the control there's a model in a paper which is basically it's about it an order of magnitude greater gate error because you have more possible possibilities three states so there's basically counting argument okay one more so now we're transitioning to not quite done yet this one actually the most recent results but okay so here's another way to reduce the number of qubits and as a classical person this is basically amounts to garbage collection of qubits and what's interesting about this is that well it's most effective for arithmetic classic arithmetic implemented on on quantum machines so the main thing that comes out of this is that since the bridge that you cut to be reversible you have a lot of insulin and since its classical we can actually reuse the insula after we do a computation but we have to uncomputable are no longer related to the result okay so this is a classic trade-off between saving qubits and using gates right and our metric is basically going to be gates times qubits right it's like a quantum volume kind of argument and so so this is where the results are a little bit old these are four very large benchmarks that we had are the days but if you look at the large benchmarks what we see is that we can save a lot of qubits that's the red that's a fraction of qubits you can reclaim but this is the amount of computation you need to incur this is how much more computation you need to get those back right to compute those things and you can see that you know we get you know almost 80% here but then we have to pay about 80% we're gonna yeah we have to it's there it's the untangling part you basically have to uncomputable you can reuse that and sew it for the next next function with your results yeah that's right exactly exactly so this is this is the original codes were written in such that they didn't always reverse the computation and so they they weren't maybe like sort of algorithmic not they weren't necessarily written in a safe way and it's like you don't do anything with the insula it's okay but you know these codes were written like even with nested structure functions that you know you keep calling them and you just have more and more insula and then if you wanted to reclaim them you actually have to you know basically increase the number of double yeah yeah so that's I think I think that I think that your point of view is that you would always unconfuse right yeah we can show you so you know I think that probably the original codes would be viewed as a sort of a somewhat unsafe way of doing this but this is if you wanted to get those back you would do this and then if you take the spacetime product where you multiply those together what you see is that for some applications it's beneficial right the space-time product it's times gates is lower and for some of them it's not so essentially what we did is we wrote a compiler that dynamically decides well not so much dynamically but decides adaptively for a program how when to and so because this is the extreme case of on computing everything but we could just uncuff you don't take a lot of people so you get a lot of cupids back it's also the case that this problem gets much much harder which is when you when you reclaim in and Scylla it's actually in some physical location on the machine and the next person next function to use it is in some other physical location you may want to optimize the distance between those and so that is also in this next this study that we just did and so this is basically a bunch of heuristics to try to balance all of these in fact this was related to this mapping problem right in general we're always having to map our circuits or graphs to the physical machine right we're trying to minimize communication and it's a really interesting problem because from my perspective and in my experience as a classical architect there's sort of two approaches that people take right one approach is to take to treat the computation as a for the whole length of the computation as a single static graph if you treat it as that graft and you can use some nice partitioning techniques spectral techniques to give you a fairly globally nice solution right but that ignores what happens at every given time step temporal locality and now the other hand people use greedy approaches which only pretty much think about the locally optimal control behavior and so the two have sort of been in opposition so we recently just did something actually where we tried to take a whole bunch of slices each one and then also try to keep the distance between the slices in terms of permutation so there's some middle ground here that's interesting but this gets a lot more complicated for example if you have as we looked at just earlier irregular physical constraints that connectivity that isn't just a regular 2d mesh right if you're bad links and bad qubits a lot of these techniques don't work well with too many arbitrary constraints right like the spectral partitions don't work well reading reading ones work pretty well because they're just step-by-step heuristics anyway so that's interesting and then this this issue that I just mentioned which is you know there are lots of other phases of our compiler or our authorization which affect the map right for example this qubit reviewed so reclamation happens at certain locations so we have to decide we have all these decisions that happen they're all coupled together and at some level when we started looking at this problem anew in the last few years where we looked at instead of larger machines very small machines we got very interested in well we can just optimize lots of things together and get a much better solution but even at this small size once you sort of conflate a whole bunch of layers of authorization together and so it's an interesting problem to sort of decide how which things to do together you know which things to maybe iterate right our compiler is like a layered sort of past based thing or so you do one operation to the next and do the next you know they you might loop back but they sort of don't inform each other so that's a sort of this issue cross layer optimization is a very traditional classical issue right and it quickly blows up so this is one of those places okay here's another one you're probably aware of like there's there are a lot of nice ways like IBM as these nice papers where they looked at essentially statistically creating better results you know factoring out noise right and then they're on the other end they're like some very extreme cases where people use learning to adapt to device noise and get like better fidelity and devices control signal but the problem with these approaches is that they require too much measurement and so some of the work that we're trying to do now is there's in the classical world there's there is a sort of fusion of learning and control algorithms and so learning allows you to approach a very high complexity problem but at pretty high time cost and data cost right to learn that problem and then the idea is to learn initially and then create sort of Patrol algorithms that will adapt dynamically to changing divisions and not have to recalibrate and this has worked pretty well in classical systems not clear I mean we're still at the beginning of whether this is going to work well okay so now I'm going to switch gears for a little bit I have mostly talked about performance right efficiency right and how to fit programs onto missions but actually a fairly large part of our expeditions project and a big concern of ours is how do we get this right okay and this really comes up because we're in this fairly ridiculous bootstrapping situation here right where you know we're gonna have machines that barely work and are pretty small and we and we can't simulate them on classical machines and we could have software that we've cobbled together but we pretty much not really had a chance to test right so gonna run our program on our machine and we're gonna get some errors and we're not even gonna know you know did that come from the algorithm from the compiler right and so you know in the classical world we've had these formal techniques and technologies for trying to verify software but they're really not that popular because in classical world you can always punt and say oh that's sort of hard we're gonna just test it right but we're basically not going to be able to do that here right and so it's in some sense it's for better or worse it's the perfect place to use more formal but there's a very fundamental issue here right and that is that you know if we are checking for properties that are too similar to the actual computation right we're essentially reducing the problem to simulating a good competition and we know that at least for algorithms that we care about that's gonna be really hard to do and so fundamentally the question is can we define properties that are not too similar to the concentration that we can check in sort of polynomial or at least exponential with very small constant or something like you know something practical that is useful to the to giving us some information about whether the the program or the software you know we're still in the beginning of this I mean sort of there was a long ago there was lots of work in this like we can check for no-cloning that's not right but much more subtle things you know we have to find properties which many of which actually just require simulation of quantum state and there's some nice things so there's some nice assertions that we can do actually I think Princeton is just coming out with a paper on some sort of statistical search so anyway but this is a big area you know I think going into the future of an hard area yeah it's it's both I think it's there are many aspects of this right the one that we're sort of focusing on is let's assume for the algorithm is correct someone has an algorithm how do you express it and then how do how do you compile it and optimize it down to something the machine can read so that tool flow has a lot of steps and so verifying that that's right and so if you had some confidence that the code you're running on the machine is correct then you can you know then also ask the question of how does that compare with the actual and when I first started this work I really wasn't that interested in quantum simulation but in the end I had to go there right and and you know quantum simulation is really interesting because you know at one level it establishes the baseline for quantum supremacy right so basically the bigger the simulation we can do on a classical machine the harder it is to build a physical machine that we can claim quantum supremacy for right and that's and there have been a number of techniques out here so there's this Intel quantum simulator which they ran on large supercomputers that got 45 qubits of general simulation which sort of defined some baseline and then there are some approaches which essentially focus on the quantum supremacy problem like shallow random circuits using tensor contraction or Fineman path sampling which can get you a fairly large number of qubits right in maybe larger I think this paper says they can get 280 if you spent like 10 million dollars it's like they actually did a financial calculation how many samples would it take so scaling out yeah we have some work with Argonne where we've actually used data compression compressed the state vector so we can fit it onto their largest machines and then that can actually run about fifty nine cubits right now with some fidelity loss so this is our whole area which is both interesting from this as the standpoint of quantum supremacy but also from the standpoint of testing your code right so we can run non-trivial size rivers algorithm we can sort of actually test it a little bit right it's not formal correctness at all but it gives us only some means to test that behavior that we expect of course this gets a lot more complicated if we want to simulate noise none of this does this right so along those lines I think another interesting direction is you know developing tools to help the program and actually for many years I used to go ask my favorite algorithms people can we come up with some tools to help you create more algorithms and they would basically say no that doesn't sound too reasonable or useful but eventually I figured out that the hard part in terms of tools was if you have the algorithm which is you know sort of typically more of a theoretical sketch of the implementation it takes about a year or two to write to implement that algorithm on a machine right and so it depends but so so and we find that that process is extremely variable and so just taking sort of a kernel or a core algorithm and turning it into an application is a big deal and so there's some notion of you know we should create tools to make that easy and so one notion might be visualization and maybe visualization of resource usage entanglement qubit you said those might give some feedback to the programmer in terms of how their implementation is doing more sort of practically you know we might expect more specialized libraries and building blocks which I think you know sir sort of industrial efforts are good examples of that and then she's sort of a more crazy out there idea is that in I'll talk about the idea of program synthesis which is basically from a sketch of a program or a specification automatically generating which is hard to do but maybe not harder than writing correct code to verify so this is a little visualization that one of my students created which is for h HL so over time for different functions parts of the circuit how much pairwise entanglement was there in those qubits okay so like one it's like they're all a little bit it's interesting so when I saw this I thought two things one is I thought maybe it would be higher right so it's but then I thought well actually it's it's pretty high right like you know you're mostly in this sort of 50% range which basically says if you try to simulate this it would be hard you know what is interesting about this is maybe if it shows maybe a little bit of promise in terms of approaches that might maybe cluster not everything is interacting with everything but so the there number of implications here but one of them is maybe you know also looking at this might tell you something about whether you wrote the program this is a whole bunch of things like that let me just show you one last crazy thing which is this is something in the classical world which came about in about 2006 which is this idea that you can just sort of specify what your program wants to look like and then you just simply randomly generate programs and then you test them to see if they meet the specification you just keep going and then out comes the program right and they actually have improved this quite a lot since 2006 they use sort of the verifier has some knowledge in it essentially of what the program should look like and they use that to guide the synthesizer it's just not just totally random what it generates and this actually works really well for special small domain-specific languages for example they use it for network protocols or security protocols like little policies they want to write they can synthesize correct programs without having to implement them so the idea here is in the quantum world this might be interesting it gives it one we are a very small domain-specific language right and what's interesting is this is essentially an exponentially complex thing to do but verifying quanto programs is also an exponentially complex thing to do right so so the idea is maybe it's easier to go forwards and synthesize a correct program than to have a person write a program and then go backwards and verify that it was correct maybe so I had a student play with this it hasn't really done this for communication protocols were easier they did this for the television and what was interesting was he generated a product allocation protocol that was something that no human would write right it's like strange fractional and and so he was interested in this because he thought oh maybe I could generate a new quantum algorithm I don't know I think it's interesting just if you could have a correct path from from specification but it does allow you to maybe experiment with you know things that people all right so potpourri things in the end I think where we really are right now is trying to figure out what are the right abstractions and in this sort of system stack and what are the right things to break and so where we are is we have some abstractions already right so we have people use this proof language specified program to see if they're correct we might even use a fairly physical model of what programs should do and try to verify that we have a whole bunch of programming languages out there already we have most people use some sort of quantum gate set which is some form of quantum assembly which now is somewhat standardized I could misspoke because I VM but if basically all the chasm dialects look pretty much the same within some annoying variation of like arguments different slightly semantics but in general you can if you just write a little translator you can run between all the different software stacks and then what's neat now is we have even have a pulse interface which I think is an open question as to how generalizable it is it's it's designed for IBM's machines right now and it's intended to be usable for other technologies but so these are this is where we are it's probably a little premature to actually fix any of these interfaces right but it is useful to have them because it allows us to experiment and interoperate but I think what I hope I've shown you in our work is that it's really about where should we break these that's where we're gonna get 100x efficiency it's both right a lot of the architecture work I would say is is focused on the cost of communication right and the fact that you're gonna have some physical layout that's say we have like a to be sort of distance metric so a lot of the work tends to be in that area there also tends to be some so that's a little bit general but there also tends to be a fair amount of work in sort of technology specific right now actually I didn't talk about it but I would say a really big area is classical control and I think that's I think that's already being done but I think there just aren't that many classical sort of embedded processing control and the big secret signal analog circuit designers working in these bits I think it's mostly it would be really great if we could get people who like build these systems for you know cell phone base stations yes yes we do it and we're even like working on four cold systems we're working on super ducting circuits or cold control so at the beginning of this talk I talked about this gap between algorithms finish but I think there's this sort of interesting gap that we have to deal with which is a gap in time right or actually in scale both in pionen scale so 15 years ago the work that we did in this space was very theoretical and essentially what can we do for like a hundred thousand a million cubits how could we write compilers for that now one day when we had these machines a little better then suddenly machines show up and were like oh we're gonna be here we're going to look at how to very deeply optimized for small machines and they're pretty regular properties right so the question is when this also happened in classical machines and eventually classical machines got over here right and bits were free instructions were free essentially right and then we didn't worry about those things so the question is what are we going to what the things that we learn in the next five to ten years in this space are they how are they going to carry forward as things scale we optimistically think that the scale I think actually quite a lot of what we learn here will generalize I think it would be hard to imagine a future in which qubits were free right I mean we may have a lot of them but you know I think we're still going to be fairly conscious of using them and gates probably and so a lot of this sort of domain-specific exposure and in the end it will come down to lick which extractions like what things do we think are important that we will continue to expose and so and even classical architectures are backsliding right classical architectures are now starting to expose errors of variability yet and power constraints so physical details are sort of going back and things aren't free finally this is our project website it has all the software that we use to do these experiments maybe it's a less of an issue in this kingdom with the British audience usually when I give this talk I'm trying to convince classical people to work in this space and I say go here look at this software and look at the videos of like Peter shor lecturing and things to you telling you about these algorithms and so we have a tutorial that we run and it has like it's a system that goes from our compiler to quiz get to the IBM machines and it has a bunch of jupiter notebooks that are structured for people to play them that's sort of the entry level and then you know the different observations i talked about are you know are then going into the compiler so finally let me wrap up you know once again i think that you know we're at this really exciting historic time where there are a lot of opportunities and i think that the key thing is you know how do we break these abstractions and what things are weaken exposed and what complexity are we're going to deal with right now a lot but at some point we're gonna have to pick and choose decide what are the right things all right thanks [Applause] certainly I mean right now you know we've been working at a fairly low level so we're forming the compiler with physical details but there certainly are certainly in the classical world it always happens that there's programs like application knowledge that we haven't done a lot of that yet partly it's because there aren't a lot of quantum applications so and a lot of them that were reading with we already understand pretty well but I think that there's this idea of practice but then there's I also this idea I think maybe more importantly I think we need a more abstract way to express algorithms that's easier to do correctly that's closer to the original and then an automated way to translate that into like right now it's we basically take an algorithm and we write it in a circuit description basically it looks like yeah I think what you're saying is sort of is there is there any focus on sort of less computational tasks that are more like embedded or test there is at Chicago and they have a pretty strong focus of communication sensing and then there's then there's a focus on these slightly simpler control you know our work this particular work and I think you know the sort of computer science systems so that was actually in the primary conference but but we we run tutorials and actually in June which is the federated computing conference they're running there else all those people are actually on our advisory board so then we hope that they're gonna come in we have an advisory but the public part of that it's every four years they do the federated conference it's there yeah yeah program synthesis yeah yes the sketches really just constraints and so the original sketch was like very much pseudocode just like the barely you know like not all the statements in the program but like a few statements that sort of show you know what the look like i mean you could start with just nothing totally random but it's like a skeleton and then you have a certification of what you can put in output yeah he had basically just a functional description of what it should be and maybe he put something like there would be some some generalized operator here I think maybe not as much I mean you know I honestly I'm not really that great at that history but I would you know we know that they they had vacuum tubes and eventually transistors and like core memory magnetic cores things like that they tend to not be so there weren't so many technologies at once right they were sort of like there would be an established technology and then one would painfully replace it right and everyone would be like I will never use that next technology because this is more comfortable - for example memory technology so over the last ten years there have been a lot of different memory technologies especially for non-volatile memory yeah yeah I mean that happened over at least 20 years right and then and then beyond that you know it was probably another 20 years of making transistors cheaper and cheaper so it but I would say probably the first 20 years is where the greatest paradigm shifts happen right so you started out like writing assembly code or Micra code and optimize everything eventually we've got better compilers and the compilers had more resources to work with so that people wouldn't write and then eventually we got to the point where we've had enough memory and processing we stopped worrying so much about every and then eventually we got to the point where we didn't know what to do in the classical world everything is about we're going to put a widget on here that's because special like especially accelerates this one thing yeah it's really picking up so it's in particular the use of my areas for architecture computer systems and I would say that over the last 15 years you know maybe every third conference there would be one study usually from my group about this and then last year I gave the keynote S Plus which is architecture program languages and operating systems and there were no quantum papers and this year actually Christa said Laurie the Microsoft David and there were five quantum and then it turns out there are five at our next conference in two months - oh I think we're suddenly went from like almost zero to essentially of a regular session in every conference but also because actually we ran like six tutorials in the last year so we're trying to create [Applause]

Channel: QuICS

Views: 222

Rating: 5 out of 5

Keywords:

Id: 2Q5JftLZDz8

Length: 64min 41sec (3881 seconds)

Published: Tue May 28 2019