So… Christina, when you're ready?
Okay, so it's our pleasure to have, uh, Patrick.
Today, with us, my history with Patrick goes really, really back. I think when I got into…
Santa Cruz, he was living as a…
postdoc, so I heard about all these stories about, like, the…
Brilliant postdoc of Michael Dine.
And then what happened after…
Yeah, that guy left before me.
Yeah. And then, after some years, I met him, and now as one of my bosses in Illinois.
And, uh, unfortunately, I…
didn't work with him, but yeah, but, like, uh, he
It was smart for me. But yeah, but today is gonna talk about something that I never heard from him before. He's gonna be this quantum simulation of SU3, so yeah, thank you for accepting the invitation, Patrick, and yeah, take it away.
Well, thanks very much, and thank you for tolerating a Zoom seminar.
First of all, I can beg courses and whatever to complicate things, but as I was telling a few of you before it started, I also had a plane that almost crashed on my way to Stony Brook in December, so I'm just as happy to be, you know,
feet on the ground. Um, let me see if I can get the share screen working here. Uh, okay.
We should have tested this earlier, but…
I think it'll be okay.
Okay, good.
Yep, I started.
Continue to share this keynote window. Can you see it? Is it okay?
Yes.
Alright, good.
And I'm going to try and make…
You guys a little smaller so I can see my own screen.
Okay. Yell at me if you have questions, feel free to stop, I can't see the, uh…
the notifications anymore, so just speak up. Okay, uh, this is a talk on quantum simulations for high-energy physics. Um, it is based on a couple of papers. Those are the archive numbers. The first one's published, the second one is in press.
Uh, it's been a pleasure to work with a large group of really excellent graduate students on this, and also
Postdoc Andrew Lytle, who is now a program manager.
We're not seeing the screen.
They're not seeing screen, okay.
I can see the string.
I see it as well.
Let's see, okay, hang on.
I don't know what's going on, then. So, a few of you can see, and a few of you can't. Uh, let's see.
Let me try it again.
Now I see it.
Still okay?
Alright. Okay.
Um, yeah, various folks that I worked with on this, Andrew Lytle is now a program manager at the National Quantum Algorithm Center in Chicago, and Enrico Rinaldi is our counterpart, uh, former, well, current Lattice Gauge theorist, but working for Quantinium.
Okay, uh, I will start with a, um, overview of quantum computing for high-energy physics and the status of quantum computers, very much a bird's eye view. I'm sorry, I don't know exactly what the background is in this audience. So, again, you can either slow me down or speed me up, depending on what you like.
The bulk of the talk will be on setting up SU3 gauge theory. Of course, SU3 interactions are the basis for quantum chromodynamics, and so a first step in trying to
put QCD on a quantum computer is to understand how to do pure SU3 gauge theory. I'll talk about some progress that our group has made on this, some remaining challenges, and just in general, the structure of how a quantum simulation might look, a digital quantum simulation, I should say. And there, there will be some parts that are…
perhaps more familiar, analytic in some parts that are a little more circuit… circuitology heavy, so again, uh, feel free to ask about that. And I'll close with some results.
Unfortunately, I was hoping to have real device results for you for today, but some of them are in… still in progress, so I'll just quote, uh, things from simulators and emulators. That means when we take a quantum circuit and we pass it through a classical computer, or we do some simulation, which is supposed to be a benchmark or analogous to the quantum simulation in some other way.
On a classical computer.
Alright. So, um…
At the very, uh, least, I'm sure that you have seen stuff about quantum computing in the news, even the financial news, and in these kinds of reports, you hear about
Uh, three kind of related, but not identical things. Quantum supremacy, quantum advantage, and quantum utility.
Quantum supremacy was kind of the original phase that was used, and if we had to put a sharp definition on it, I would say that it is a demonstration of a solution to a problem that classical computers cannot do.
Quantum Advantage is slightly weaker. It's a demonstration of a solution to a problem that classical computers just can't do as well. Maybe they can still do it in some way with some error bar.
Quantum utility is, uh, is the most practical and relevant one. It's a demonstration that someone is willing to pay for the quantum
simulation, rather than the classical one.
And so these last two are maybe the first, uh…
goals to get to. And these are a question of, um, uh, with three stages. First is, do we have good problems?
So what do we want to do with these machines? And most talks on quantum computing appeal to this quote by Feynman. The basic idea being that there are lots of quantum systems that are complicated enough that maybe the natural place to study them is in a quantum simulation.
So, their nature provides for us for free some class of problems that look pretty interesting for quantum computers. There may be other uses as well.
Uh, we need good hardware, we need good tools. Uh, I like this quote from Dyson that new directions are launched by new tools much more often than by new concepts. Uh, this is basically, are we going to have a good enough quantum computer to do what we want to do?
And, uh, for my purposes, this quote here regarding software and whether we have good algorithms is the most relevant one.
Uh, we need to make sure that we have algorithms that will finish in a human lifetime.
Or maybe less. Okay, problems. So, what do we want to do?
As you well know, some quantum problems can be solved using classical methods super efficiently.
Uh, for example, Lattice QCD on classical computers already operates extremely well for computing, among other things. The equilibrium correlations in QCD specifically. So in some quantum field theories, the equilibrium correlations can be got in some quantum field theories, few particle
scattering matrix elements can be got. We can also study small models, few particles at a time. If they have a small enough Hilbert space, you can just diagonalize the Hamiltonian directly.
And then there are some classes of specific sets of unitary operations that can be simulated super efficiently, even though they are entangling. The classic example of this is a simulation of Clifford circuits on qubits using the stabilizer formulaism.
But there are other problems for which no efficient classical method is known, and the most interesting one for our field is the simulation of large generic systems that exhibit some kind of sign problem.
So if you haven't encountered a sign problem before, this is, I think, the simplest one.
You take the particle on the circle with a theta term, so some flux coming through the loop,
And you're trying to compute the partition function at low temperature as a function of theta.
So you can do, uh, sort of, uh, direct
sum of the left-hand side here, the Tracy to the minus beta H, because the system is simple enough, we know how to diagonalize the Hamiltonian exactly, and you end up with a sum of this form.
Low temperature is large beta, so this sum is dominated by the low-lying terms in N. You only need 1 or 3 terms or something here to get a really good answer.
The other side, you try and compute this Euclidean path integral by path sampling, and roughly speaking, what it does is it just adds up all the paths of all the different ways that the particle can go around the loop. So the path sampling tries to compute the partition function in a sum which is morally just the Poisson summation of the left-hand side. But what that does is it inverts the beta dependence and the exponents.
in the denominator. So if you want to take the low energy limit and calculate this ratio, Z of theta to Z ,
Then, uh, if you calculate it using the right-hand side, you have a large number of order one terms in the numerator, which have to really efficiently cancel in order to give you the final answer.
Which we know from the left-hand side is something of the order e to the minus beta theta squared.
So there's some efficient, exponentially efficient cancellation that happens here, and it's a real pain to try and do it by adding up all of these paths that have order one weights with different phases.
So this is a case where you can just avoid it by doing the calculation differently. You do exact diagonalization. Of course, in general, we can't do that. This only works because the system is simple.
And the hope, although it's, uh, at this point totally unproven and unknown, but the hope is
that quantum computing, by just being a different formulation of the problem, may give us a new tool that can avoid some of these, uh, some of these problems.
Here are some more interesting systems and simulations that exhibit sign problems. First of all, all non-equilibrium antibody problems have e to the minus iHT doing a lot of work, so dynamics just right away is the most natural
sort of application here. We might like to track what's happening through a heteronization process in a shower.
There are also some equilibrium, many body problems, uh, that have sign problems. States with a lot of matter are the canonical example people give. We might like to study QCD at low temperature, but high baryon number density. And in that case,
ordinary classical Monte Carlo fails because the fermion determinant in the presence of the chemical potential is not real and positive.
Topological terms are, uh, yet another example. This is not even many-body, this is just the vacuum, but some vacua are painful because they still have a sign problem arising.
For example, from the theta term. And we're lucky that in the real world, there's a strong CP problem, because otherwise, ordinary lattice QCD wouldn't work.
If theta was 2, then we'd have a tough time.
I want to just mention another possible perspective, which has only begun to be explored and fleshed out a little bit in the literature. I think there's a lot open here. It's possible that studying gauge theories from a more kind of experimental QIS perspective will yield some interesting new ideas about what's going on, or how to describe properties
say, the phase structure. So, for example, trying to understand how magic and non-stabilizerness correlate with sign problems or different phases of gauge theory vacua, that might be something that we can study more directly on a quantum computer.
And of course, the QIS input has been very valuable in ADS-CFT, that's more on the theoretical side. This is not a guaranteed deliverable, but it's an interesting thing to keep in mind. We may be able to do more than just calculate observables. We might get some, uh…
some new types of observables to think about, too.
Okay, let me move to hardware. Uh, will the quantum devices that we get be good? I'm certainly not the right person to ask about this, but I can point to some positive signs.
First of all, it's a hard problem, and any hard problem takes a lot of money to address. The investment on the United States scale bumped up a lot around 2020, when this
National Quantum Initiative Act was passed, and it stayed fairly constant. I don't have… I don't know if that was actually enacted, and I don't know what the proposed is going forward. This is a little out of date. But, um, anyway, we're looking at, on the order of, uh, a billion dollars put in by, uh, by the federal government, plus billions coming from,
private companies, hundreds of millions in corporate academic partnerships, startups, and public investment abroad. So, there's a lot of work going into this. Uh, that's…
one positive sign. Another thing we can look at is, uh, sort of the roadmaps from the companies and what they've been able to achieve over the last few years. So, more specifically, thinking about their qubit quality and qubit connectivity.
So, when we were running our first variational quantum eigensolver simulations several years ago, we used this 7-qubit IBM device called IBM Nairobi. They took it offline in the fall of 2023, can't get access to this anymore. And now, what you have available is more like this. This is, uh, this is a brand new Nighthawk system.
It's 120 qubits, it's laid out in this two-dimensional square lattice configuration.
This is one of…
what will ultimately be several IBM devices of this type that you can get access to, and there are similar devices with slightly different properties from many other different
corporations working on this. So this is the Google device, Willow from a couple years ago, 105 qubits, and Quantinium just put out their newest machine called Helios. That's a 98-qubit machine.
Uh, these first two are similar in the sense that they're both based on superconducting qubit technology, the transmon. This one is different, the Helios is based on, um,
On ions, so here are the qubits are mobile, they move them around, they let them interact. It has different properties, uh, different strong points and different weaknesses.
But these are just a few examples. There are also many more qubits currently available in some neutral atom platforms. Photonic systems are interesting. Those are mostly not available yet, but they have sort of fewer barriers to realization.
So, there's a bunch of different ideas being explored simultaneously for, uh, what can constitute a qubit and how you wire them together. That's the point I want to make.
So I have a question. So maybe maybe this is too taking it too far afield. But how do you implement the quantum gates? And what do you do about quantum error correction?
Um, let me just say, uh, just a little bit about that. So, uh, how they implement the different gates is very platform-dependent and hardware-dependent.
Um, I will say, in the next slide, something about the current error rates. Uh, most groups are not implementing anything like a, um,
sort of production quality, full-scale quantum error correction yet. There is some level of error correction being done in, um,
Google has done it, Quintinium has done it, but these are kind of, uh, proof of principle, small-scale things. The neutral atom companies, um…
Inflection is saying that they have much larger, uh, things working now, although I haven't personally worked with that, so I'm not sure the status of it.
Okay, so individual gates are, um, in the Transmon case, it comes from
pulses of microwaves, uh, in the, um,
And the trapped ion case, you put the qubits together, uh, and physically together, and keep them there for a certain time, and drive them to different levels, and then separate them again. The most important thing right now is the two-qubit gate error, so everybody does 1 and 2 qubit gates right now.
And the harder ones, obviously, are the two qubits, getting them to do the right thing together. So that drives the dominant noise right now. For example,
Well, uh, okay, I have to make a caveat to that.
Um, but okay, here, uh, this shows from the dashboard for IBM Nighthawk, uh, a few of the relevant errors.
Um, the…
CZ error, that's a 2-qubit gate, uh, on Nighthawk, uh, has an error rate on the order of 310 to the minus 3.
median. Actually, the readout assignment error is higher, uh, but that's, uh…
Let me, let me separate that off. That one's easier to mitigate. So these, uh, these types of gate errors right now, 310 to the minus 3, they're comparable across IBM's device, which is the…
superconducting, um, 310 to the minus 3 is also what's quoted by the neutral atom folks at inflection.
Uh, slightly better results from the ion people at Quantinium.
But you put these together, and roughly speaking, they're telling you that you may be able to implement right now, on the order of 1,000 to maybe 10,000, depending on the type of gate. Useful gates on these physical qubits without error correction.
So, this is still all being done on physical qubits instead of logical qubits.
And then people spend a lot of time right now on post-processing to clean data and try and do error mitigation, but in the future, that'll probably go away when we reach some kind of fault-tolerant
fault-tolerant era. So right now, we're in this NISC era thing, where things are still noisy, and you've got, maybe,
10 to the 3 to 10 to the 4 gates that you can run. And by the way, this comment here, uh, oops, about…
different but comparable constraints. This 2-cubic gate air is not the only relevant thing. There's also the defacing time, and if you compare the time it takes to run a gate to the time that the whole thing decoheres, that also gives you a similar kind of, uh,
1 to 2,000 gate quantity that you can run.
The devices also differ in their connectivity, so if we go back to this
layout here, you can kind of imagine that what these bonds mean in the IBM layout is that qubits that are next to each other, connected by a bond, you can run a two-qubit gate on.
If they're farther apart, then you have to do swaps first. You have to exchange the information in the different qubits in order to interact a pair that's separated by more than one bond.
And so that becomes expensive, because every swap is, like, 3 2-qubit gates.
So, right now, there are some significant advantages to working with a platform like this over here, uh, the Quintidium, uh,
Well, all of their platforms, because they have all-to-all connectivity. You can take any pair of qubits and put them next to each other and directly run a two-quubiting entangling gate. You don't need to do a bunch of expensive swaps first. In the future, that won't be as big a deal, but right now, in the NISC era, that is a helpful thing.
Alright, so actually, implementing quantum error correction, it has been demonstrated below threshold, meaning that doing the error correction accumulates less error than it fixes.
Uh, that's… that's certainly a prerequisite to using this. It's sort of at the demonstration stage, um, needs a lot more physical qubits to implement well, and architecture, um, particularly kind of a…
a bubble wrap of, uh, classical supercomputing surrounding these systems in order to process the errors and turn it
back into a meaningful result.
Sorry, what does NISQ stand for?
noisy intermediate-scale quantum era. This was coined by Presko a few years ago, and…
Uh, spread rapidly, yeah. So it sort of says we're not using
Quantum error correction productively yet.
There's some demonstrations of it, but it's not like it's the thing that you do in order to get a good answer.
Uh, maybe I should pause and see if there are other questions at this point.
Okay. And for comparison, uh, I just quoted at the top here, operations on classical bits in a classical computer are much more robust, so this is not the kind of thing that we think about when we do stuff on our laptop. It's just a completely different environment on the quantum computer, at least at this time.
Alright, so, uh, now we have to read the tea leaves and look to the future, and try and understand, uh, where this is going, uh, and what we need to be ready for.
So we can run…
a few thousand gates on something like 100 to 1,000 physical qubits, depending on the system. And…
Miraculously, many different platforms, companies are all pointing to the same roadmap.
That might… there might be some correlations there that are, uh, being, uh, reinforced. But they're all saying something along the lines of, we're going to have fault-tolerant quantum computing,
by 2029. Um, we'll see. I don't know. I'd be happy to inflate that by a factor of 3, and it'll still be exciting.
The Continuum Soul, that's going to be their next platform on the order of 200 qubits, uh,
Next year, uh, then the platform after that is switching, so this is 192 physical qubits, platform after that, they're claiming 100 logical qubits, and you should be able to run, uh, hopefully millions, at least, of, uh,
of fault-tolerant gates on it by 2029. Right now, IBM is at the Nighthawk stage, uh, in the coming years, they're going to be increasing the number of gates that you can run on them, so that just means lowering the 2-qubit gate errors.
On the current devices, and then there's a jump,
Between 2027 and 2029, going to their next system, Starling, that's supposed to be 200 logical qubits, and something on the order of 100 million logical gates. Similar projections have been made across essentially all platforms. So, um…
So let's entertain the possibility that, never mind the timescale, but at least one of them might get there. We might have such a device, will we be able to use it productively in high-energy physics?
So that's the question of the software. Are the algorithms feasible?
And there are a number of different groups that are looking into this. General problem of simulating different types of quantum field theories on quantum devices. This is an active area of work. The problem is very much incompletely solved, and if it turned out that there was a breakthrough and we just got a good quantum computer later this afternoon, we couldn't just place QCD on it. We're not in a position to do that yet.
Putting a theory like quantum chroma dynamics onto a digital quantum computer requires several, uh, somewhat nuanced steps that have to be walked through.
You need to discretize and truncate the Hilbert space. The qubits have a finite-dimensional Hilbert space, whereas even a single link of a lattice gauge theory has an infinite-dimensional Hilbert space. We have to control the discretization and truncation effects so that we remain in the desired universality class. We need to map, uh, if we want to do dynamics, we need the time evolution operator to actually be something that we can
in a feasible number of gates, and we need to have good control of all of these errors that are induced by
Uh, by, uh, accumulation of noise, or by theoretical errors that we've made.
The starting point for the work that I'm going to talk about is a paper from the Washington Group about 4 years ago. The Trailhead paper. I like the fact that all you have to do is search Trailhead and you get one result, so that's pretty impressive.
This was a paper that, in some ways, seems ahead of its time, um, and it, uh, it provided kind of the springboard from which we
disembarked. So, they developed groundwork and some tools for simulating pure lattice SU3 in what's called the electric, or the ERIP basis, and they studied it on very simple lattices with low truncation. So a single plaquette by itself, or two plaquettes next to each other.
And the goal of our work started about one and a half, maybe two years ago, was to
take the framework here and improve it a bit, study it, see what could be fixed up about it, and generalize it to more physical lattices, higher dimensions, arbitrary truncations, what would we actually need to do in order to get to the point where we were doing some interesting physics?
And to make a public code that's optimized for the generation of quantum circuits in SU3.
So the theory here is very old. It's the Cogut-Suscund Hamiltonian is what we're working with. It's remarkable that this was written down so early, but then, uh, wasn't really the useful thing for classical computers.
Euclidean Monte Carlo approach was much more relevant than the Hamiltonian approach, but now it's had, in the last decade, a resurgence of relevance because of quantum computers.
The Hamiltonian is very much like Maxwell theory, there's the E squared term that is diagonal in the electric basis that we're going to work in, and you can think of this as measuring the electric Casimir operator of irreducible representations of Su3 on every link.
We're measuring the flux tube on every link.
And then there are the plaquette terms, or the magnetic terms over here.
And roughly speaking, what these do is act a little bit like raising and lowering operators, adding little loops of flux to every plaquette that they, uh, that they touch.
And this is just a constant subtraction term.
So, we'll also work in this electric basis with one improvement. Um, and so in that case, we should think of the lattice as a bunch of fluctuating flux degrees of freedom on the individual links, and there are some
interactions that make those changes in time, so it's not… those aren't eigenstates of the Hamiltonian.
More precisely, uh,
This is, um… the terminology is a little bit confused in the literature right now, but this is what's either called the irrep basis or the reduced electric basis. Hilbert space that we'll work with. We are actually not working with
color quantum numbers on each link. That is too expensive to do.
Instead, what we do is use the Gauss law and say, at every site, we have to have a tensor product of irreps coming in that contain a singlet in that tensor product. That's what gauge invariance is telling us. So, the Hilbert space can actually be reduced to something like a specification of a singlet at every vertex, and the irrep on each link.
And we have to have an extra, uh, sort of register to encode the singlet, because it could be that there are singlet multiplicities. So, for example, if I have two 3s and two three bars meeting at a vertex here, there's more than one way to braid them together into a gauge-invariant state, into a singlet.
The particular way I've drawn here is these are not orthogonal states, but you can orthonormalize them.
And this is, uh, not a significant problem. So, for example, the trailhead folks didn't run into that in the small, simple lattices with low truncations, but it builds up rapidly as you increase dimension and the number of ear reps that you include. So, for example, if you have
D equals 3 spatial dimensions, then you think about, okay, it's like jacks, so 6 links meet at a site, and if all those links are carrying adjoint flux, so if they're all in the, uh, in the 8-dimensional representation of SU3, then there's actually 145 different singlets that you can pull out of that, and those all have to be accounted for in the Hilbert space.
This Hilbert space includes, uh, non-gauge invariant things, so it could be that, uh, that you just put erreps on the links that have no singlet, or you could put a specification of the singlet at a vertex that's not physical,
So, it's not a completely physical Hilbert space, but it's still local.
If we were to have a completely physical one, we would have to give up locality because the Gauss law is a non-local constraint.
It's better than just working with the colors, because it reduces a lot the number of degrees of freedom that we need, and the number of transitions that we can make, uh, but it's still infinite-dimensional, and, um…
and somewhat complex. So we're going to have to do, uh, some further truncations to this.
Uh, momentarily.
Okay, so…
Roughly speaking, what do we want to do? We want to implement the Hamiltonian on some set of degrees of freedom, quantum degrees of freedom, that are going to represent the, uh…
the Hilbert space on the previous slide, and in a minute, those will be qubits, it doesn't quite matter right now. But the hard part of that task, no matter how you do that in coding, is to implement this magnetic time evolution, the splicad operator. That's the thing that's not diagonal, it causes transitions between different irrep states, and
Unfortunately, although it's local, it's not super-duper local. It's… it acts on a plaquette.
And moreover, the action on the plaquette needs to know something about what's going on at each vertex. So it does involve
several local degrees of freedom, uh, altogether.
So here, it's advantageous to not have the quantum computer work that out for you, but instead classically pre-compute as much as you can. Uh, we will classically pre-compute all the matrix elements of the plaquette operator between the gauge invariant electric basis states that are relevant for a single plaquette operator. So that means sort of assigning, um,
Or enumerating the gauge invariant basis states of a single plaquette and the links coming into it.
So you can think of that kind of like this. You've got, on this blanket in 3 dimensions, you have four sites, you have 4 active links, those are the ones that are going to get excited by the application of the Plaquette operator. And then there are the control links that lie just outside the plaquette, and they encode information about what the site singlet is at each vertex.
So, something like this, for example, we start in a state here, which is the electric vacuum on the plaquette, but there's a little bit of flux on a diagonal plaquette over here. After we apply the plaquette operator, in general, we'll get some linear combination of
this excited state, same excited state of the links, all that's changed here is the two different singlets that are available in 3 cross 3 across 3 bar across 3 bar. So you'll get some linear combination of those two singlets out of this.
So we need to be able to calculate, uh, what the matrix elements are, so that we can implement them by hand into the evolution.
Okay, this is kind of in a gross and intimidating formula, but I assure you that if you expand it out, it's much worse. So this, uh, this represents, uh, an achievement in compactification.
This is our master formula. It's composed of four site factors, and those site factors, you don't really need to pay attention to the details. The, uh, the content of them is just saying, I need my initial state,
Uh, Klepsch-Gordon coefficient, that's like the wave function of the initial gauge invariant state at the site. I need the wave function of the final singlet that I'm going to make at the site. I need Klebsch Gordons for all the active link states that are getting lifted from whatever they started in by an application of a 3.
And then there may be some conventional annoying phase information that has to be dragged along. So that's what these site factors are doing. They're asking, what's the… what are the singlet wave functions, and what are the excitation
Klutch cordons to… that come in when I tensor the link by a… by a 3 or 3 bar. And the important thing here that we've added to the story is the treatment of these, uh, these site singlets, uh, and generalized how it looks for D equals 2 and 3.
And despite…
So R and S and R prime and S prime, these are representations of SU3.
That's right.
They're associated with 4 the 4 links on the boundary.
Yes, the R and the S are the active links, and the C's are the control links outside, so they're also SU3 Europes.
I see. So you've assumed the external links are in the 3s and 3 bars or something.
Uh, no, the external links are unspecified.
That's right, yeah.
see, so those are the control links. So those could be other representations.
That's right. And we just have to enumerate all of them and calculate.
Watch the 3 in the 3 bar there for?
That's coming from the fact that we're tensoring in this box, and the box is made out of the fundamental
Yeah, that's why those appear explicitly. And this is, like, a condon shortly phase here.
Oh, I see, okay.
So, despite the, uh, rather, uh,
involves structure of this thing. It turns out that, particularly because the master formula factorizes into these site factors, uh, this can be enumerated and calculated pretty efficiently. We can do this, um,
once and make a big catalog, and then we just have it. You don't have to do it every time.
Uh, to carry it out, um, so maybe I should have said a theme of this talk is the kind of hybrid nature of computation here. There are some things that classical computers are very good at. They're very good multipurpose machines, and we're going to leverage them as much as possible to do things in advance and save the quantum computer for just the stuff that's
that's most difficult. So the first classical tool that we use is an adaptation of an existing SUN clutch-Cordon calculator.
We extended it so that it computes the singlet Klutch Gordons and returns things in a nice permutation basis diagonal way.
And anyway, the important thing for us is that you can feed in
Tensor products of SUN EREPS, and it'll spit out the Klepsch Gordons for, uh, for every, every ear rep in the decomposition, particularly the singlets, which we need here.
So if you have something like this trivalent vertex here, uh, then if you allow
It's called the Hardcore Gluon approximation. You don't allow any erreps larger than 3 and 3 bar. Then the number of singlets that you can make at this vertex out of different
permutations of 1333 bar is 4, and the maximum multiplicity in any one tensor product is just 1.
So you don't need any extra qubits of the vertex to record which state you're in, the link information is enough.
Because there's no singlet multiplicity.
If you allow two index tensor ear reps, then there's 16 that you can make, and the largest multiplicity is 2, for example, 3 eighths tensor together, and they have 2 singlets in them. So you need at least one, uh, vertex degree of freedom, one qubit there to record
which state you're in. By the time you get to three dimensions with this 2-index tensor truncation, you're up to this 145 multiplicity that I mentioned previously, and that tells you that you'll need a vertex register with at least 8 qubits in it in order to record the gauge invariant state that you're in.
But it's still better than keeping track of all the different colors that you might be in on the links.
So once we have the clutch cordons, we can use them, because as you saw, the master formula was built out of essentially just Klutch Gordons. So, with that, we can then compute all of those site factors and all of the non-zero matrix elements between the physical plaquette states.
And it's very important for the success of this program that the matrix here is very sparse. So the dimension of the local Hilbert space that this plaquette operator will act on is going to be something like 30 qubits, so 2 to the 30 is a billion or something. So it's a very high-dimensional local Hilbert space. We don't want to do every possible transition in there.
fortunately, it's a very sparse set of transitions that are actually generated by the operator. So we'll leverage the fact that this matrix is very sparse.
Okay. Now we have to count how many magnetic transitions are there per plaquette, and at first sight, this looks like a non-starter. For a small lattice, this kind of line of plaquettes thing, it looks manageable with a sharp truncation on the ereps if you don't keep more than fundamental or anti-fundamental flux. 81.
Fine. Add two index tensors, that balloons to 30,000, or keep the truncation and go to 2 dimensions, it's 20,000, and by the time you're in three dimensions or higher truncations, these are becoming unfeasible. We can't actually do this.
on any foreseeable device, even if we could, uh, run that many gates, the gate times would be, uh,
would not prevent us, or would not allow us to do anything interesting. So we're going to have to deal with this, uh, problem.
And, uh, one way to go about it is to refine what kind of truncations we're looking at. So we actually don't need most of these matrix elements. First of all, most of them are very small, I'll talk about that in a minute. Another point is that
Uh, so far, I've introduced different truncations in the standard way, which is to increase the amount of flux that you allow on each link, but there's a more refined way, uh,
Which is a little bit more effective field theory motivated, where you look at the state's meeting at a vertex, and you say, okay, I can define an energy density that's associated with this vertex by adding up the electric energy of each flux coming in.
And in that way, you would say this thing has a higher sight energy than this, even though the maximum earwreps in each case are the same.
And we can use this to define a much more granular energy truncation, which is effectively a truncation on the site singlets.
Uh-oh, figure it disappeared, there it is. Um…
So, here is, um…
Here's a plot just showing counts of matrix elements with respect to this axis here is the energy truncation, or it's a proxy for the energy truncation.
And what's happening here, um, the main thing to focus on is that this blue curve is much smoother than the red curve. The red curve is like the table on the previous slide, just showing counts as I increase the amount of flux on each link that's allowed. The blue curve is what you get when instead you change the amount of electric energy per site.
And so, for example, if you want the leading effect of the adjoint, uh, you actually go to here instead of all the way up to here. That means, uh, you're working with, instead of
Uh, more than billions of matrix elements, you're working with tens of thousands, perhaps. Um, similarly… oops.
Excuse me, Patrick?
Yeah.
You're… you're counting energy just using the electric term, the strong coupling approximation, right?
That's right.
Yeah, but you want to be going to the continuum limit, which is weak coupling, so…
That's right. That's right.
Why is… why is this a good, effective field theory approximation?
Yeah, so, uh, one thing that we will have to address, uh, eventually is, can this method reach the continuum limit? Everybody has to address that eventually, and everybody has different problems in approaching the continuum limit.
The main thing is that, uh, we don't have to take G arbitrarily small.
standard lattice gauge theory simulations right now are operating at, you know, beta of 6 or something. That's G equals 1.
Uh, the strong coupling at 2GEV inverse is like 1. So the target here is not to get to G…
of 0, it's to get to G of order 1, and we have to figure out what that means exactly.
In the process, there's a significant window there where strong coupling perturbation theory is a good guide. It probably won't get you all the way down to G equals 1, but qualitatively, it does an okay job.
The truncation that you need, um… so this is, strictly speaking, you're absolutely right. This is only a good guide for, gee, roughly 1.3 or above.
Um, there it works pretty well. You're safely in a regime where strong coupling perturbation theory is good. Below that, uh, some modification of this is needed.
But that remains to be implemented. So, we have to study that. I'll say a few more words about the continuum limit at the very end.
Thank you.
Other questions? Thank you.
Any other questions right now?
Okay.
Um,
Oh yeah, I mentioned this earlier, so another thing is, this is really crude, and we can do much better than this, but you could just ask, okay, you've enumerated all of these matrix elements that need to be implemented as some hoppings,
Um, what is the distribution of values? And this is in three dimensions with that 1, 3, 3 bar truncation. This is just the count distribution on a log scale, log-log scale. And so you can see that there is a big chunk of these things that's pretty small.
So, it may be that they're not that important, that remains to be interrogated. Uh, it may also be that you can do something a bit cleverer, where you define some bins here,
You've been those matrix elements together, and then you do many transitions at the same time, instead of doing them one at a time.
So, this is a… this is some work in progress.
Okay, um, I'm gonna talk a little bit about how you build the quantum circuits now, and I apologize if this is, uh, uh, even less comprehensive than the lattice gauge theory stuff.
But, uh, bear with me, we'll see what we can do. So, we are going to build our quantum circuits using something named after Givens 1950, but was first used Jacobi 1846, so…
The idea here is we're going to decompose our magnetic Hamiltonian, since it's very sparse, into matrices that look like this.
So they just have, uh, they're symmetric, and they only have two non-zero elements, uh, some JK and, and, uh, and KJ, both of which are equal to 1, and then the coefficient here in that decomposition is the actual magnitude of that.
that matrix element. These, uh, these coefficients are the things that we've classically pre-computed, and we can efficiently build, uh, classically, again, this is a pre-computation, we can
build the circuits that we need in order to implement the time evolution operator in the Trotter product expansion. So, roughly speaking, the leading order trotter formula for a single time step decomposes into a product of magnetic rotations and a product of electric rotations.
Like this. Actually, all the electric ones commute, so we don't even have to do that.
And what that allows us to do, then, is here, um, here now we've re… we've replaced the exponentiation of the entire magnetic Hamiltonian with a sequence of unitaries that
all have just one single transition in them. So, they rotate exactly one pair of computational basis states, and that's the Givens rotation.
Uh, so then we can do one of them at a time at some transition amplitude between… on a… on a qubit device, it's a transition between one bit string and another bit string that encodes
some initial and final states of a plaquette, of the links and the site singlets on some plaquette.
So how we actually do this in practice, as we take these
two states that are some…
complicated bit strings, and we do a sequence of operations to rebase them.
So we do, uh, essentially a permutation that rebases them into a bit string and another bit string that only differ at one pivot qubit. So they have some string of bits that are all the same, and then there's a single qubit at which they differ by 0 and 1.
And then on that, we do what's called a multi-controlled rotation, where we demand that all of these qubits here are exactly what they need to be, and then we apply a rotation on the pivot qubit here. So that's denoted here by this, uh, in this circuit diagram.
Uh, these closed circles here are the controls, and this utilization is the controlled unitary acting on the pivot qubit. And finally, we have to revert the basis back to what we started with.
So what this circuit here does is it acts on 3 qubits, for example, and it rotates the pair 000 and 111, and it leaves every other, uh, bit string alone. That means it's doing our givens rotation.
So this is the basic prototype.
And for our whole circuits, these multi-controlled unitary gates are the absolute workhorse. They're doing all of the interesting physics.
They're like tweezers, because they grab just two very specific bit strings and manipulate them out of a very large number, and so they're kind of a
precision instrument.
This is very different if you see, I don't know, what the audience's exposure is, but if you go to condensed Matter talks about quantum computers, um,
Much more often, what you'll see is Pauli expansions of the operators into poly strings, and
that's more natural for spin systems, and for qubits, but for theories like Yang-Mills, they're really not very much like a spin model. We've got a local Hilbert space that we need 30 qubits or something to encode, and they interact through a much more complicated, uh, not-nearest-neighbor interaction.
So, we end up falling back on these more precision devices in order to enact the actual interactions of interest.
So, mapping a general QFT onto qubits is always going to be somewhat unnatural, and we just have to live with that.
The problem with this is that multi-controlled operations are very costly if your device
like the ones I was talking about earlier, uh, rely on just 1 and 2 qubit gates.
So you can always decompose this
Uh, this sort of anti-toffily gate here. It's got two controls and one target.
You can decompose this into two-qubit gates, but it's quite costly. This 3-qubit gate here costs 6 2-qubit gates, and a number of other single-qubit gates.
In general, um, roughly speaking, right now, the best you can do is, if you have N controls,
On the operator, you can get it down to 6N minus 12 2-qubit gates using, uh,
particular, uh, ladder structures, and you need some number of ancilla qubits to store
pre-computations while that's happening. So it's not a, uh… it's not a great thing. These MCUs are very expensive if you have to decompose them.
So we need some kind of optimization, at least in the short term, but maybe also in the long term, in order to keep our gate counts to something
quasi-reasonable. And so to do that, we introduced two algorithms called pruning and fusion.
Which I will attempt to explain.
The idea of printing is that because we've used this local construction, there is a large unphysical Hilbert space. For example, here on the left, this is a state in the Hilbert space, but it has no singlet. This one has no singlet. This one has only one singlet, but maybe the vertex register is recording that it's in another singlet.
And this is typical with the local encodings, but we can turn it actually into an advantage, because it means that the unitaries that we want to implement are actually not uniquely defined. We don't really care what they do on the unphysical Hilbert space, as long as they don't mix the unphysical Hilbert space with the physical one.
So here is an example on 3 qubits. Red corresponds to unphysical, and green is physical, and suppose that we just want to rotate these two bit strings into each other.
They're already in the canonical form, where we could do it with a multi-controlled unitary.
But we have some freedom. So the one on the left here has two controls. This is an ordinary, um…
So, like a toffee, but with a multi-controlled unitary there. And this does the job. It keeps
Every other string fixed, except these two, and rotates them together. But if we don't care what happens to the red strings, we just care that the green strings are treated right, then this one with one control also does the job. It says, if Q1 is on, then rotates Q0, and that excludes the other two.
physical strings.
So the second one rotates the unphysical subspace as well, because it rotates these guys together in the middle, but we don't actually care about that. All that matters is that it should do the right thing on the physical subspace, and this allows us to go through and prune some of our controls.
Fusion, I see that my time is running a little short, so I'm just gonna speed through a bit more. Uh, this is just some circuitology, sometimes we can use circuit identities to smush things together.
And this usually has a fairly elementary logical, uh, Boolean logic statement, so it can also be done classically.
Okay, so the status of the code, uh, we have automated circuit generation and optimization for general dimension, irrep truncation, and, uh, a sort of coarse truncation on the magnitude of magnetic rotations.
Uh, the optimizations buy us about an order of magnitude in the gate counts, or, um…
roughly the circuit depth. Uh, this is a table that's got way too many numbers on it. Ignore most of it. It's just showing for different lattices and truncations what the rough costs are. Let's look at this one down here. This is a 3x3x3 periodic boundary condition lattice, so in 3 dimensions.
With a very strong truncation on the, uh, on the singlets at sites, so low flux, very low electric energy.
In this truncation, it keeps about a thousand magnetic rotations, and once you apply all of the optimizations and the decompositions, we result in gate counts that are pushing the… add together these two final columns, and it's pushing 100 million gates just to do one Trotter step on this. So it's going to have to be further
further optimized in order to make this relevant if you want to do 50 Trotter steps or something on the fault-tolerant computer on a bigger lattice, uh, we're gonna have to do a better job.
This is getting… this is already some progress, but it's not, uh… it's not there yet. I should say that, uh, there were papers
5 to 10 years ago that were quoting gate counts of 10 to the 40 or something, so, you know, it's getting better. It's getting steadily better with time.
Um, so the main problem to solve is still depth. Uh, we want the circuits to not be so, um, so complicated.
It would be great if hardware had native multi-control gates, I'm not holding my breath for that, but that would help. Uh, it may be possible on superconducting hardware.
I think more to the point, what we should do is have a deeper understanding of which states actually matter. We are working on that, that's work in progress. We may be able to carve our state space up in a more, uh, in a more careful and sculpted way, so that we keep the physics, but…
But don't waste a lot of gates.
All right, so let me close, uh, with some simulation results here.
Again, unfortunately, I'm not showing you anything on actual quantum hardware today that is still ongoing, uh, so this is all going to be simulations or emulations.
This, uh, our group was the first to do the, uh, 3D circuit-based simulations of SU3, um, naturally, one starts with the simplest possible thing.
the cube. So this has open boundary conditions and a noiseless simulation, and this
slide is just showing the very simplest thing that you can do. Uh, it's a quench from the electric vacuum. You start in the electric vacuum, where no link has any flux, and then you just turn on time evolution with a much lower value of the coupling.
So here's G equals 1, uh, two types of evolution in these two plots, they're showing different truncations on the number of matrix elements that are kept, and different numbers of Trotter steps. So,
Uh, the number of trotter steps is increasing from top to bottom, and black is an exact result from exact diagonalization.
Uh, never mind what…
Sorry, what are open boundary conditions? You just have arbitrary group elements on each of the.
Thanks.
No, I don't like that terminology, actually, because that's what it sounds like, but what they actually mean by that is that all the external links are clamped into the trivial.
Era.
So that's…
Well, I'm confused because all I see are external links.
Uh, what I mean by this figure here is that all of these links are part of the simulation, and if you were to embed this into a larger three-dimensional lattice,
Uh, this would give an equivalent result if you clamped every other link on that larger lattice into the… well, only the neighbor ones matter… the neighboring links here would all get clamped into the vacuum. So I could draw, like, here's a link coming out, here's a link coming out this way, there's a link coming out of the page here. You can imagine that all of those have been fixed into the trivial.
So the idea of these is not the particular shape or the particular physicality of this simulation, this is just a simple thing to do. It doesn't contain really interesting information.
Uh, it's more of a diagnostic to show, okay, with some number of trotter steps, we start converging to the exact result, which is not trotterized.
Uh, with different truncations, we preserve much of the physics, so the red curve here and the red curve here are very similar in structure, even though this contains many fewer matrix elements.
Um, so these are the types of diagnostics that we can do to give ourselves a sanity check that, uh, that things are at least converging in the simulation being done.
We've also explored ground state prep. This is one of the things that we're putting onto Quantinium hardware right now. Uh, so that was… back there, that was starting from the electric vacuum, which is only the actual vacuum at very strong coupling. You might like some way to efficiently prepare a good approximation to the true ground state at weaker coupling.
So this is a, um, a collection of different methods that we used to do that, computing the ground state energy of the queue at different values of the coupling, starting from 2 and going down to 0.8 here, uh, both
With exact diagonalization, adiabatic state preparation, adiabatic preparation from a larger start, and a couple of different variational onsatzes that allow us to substantially reduce the depth of the onsots.
Uh, the details here, um, maybe I'll just say the multi-givens thing, so the stars, uh, those correspond to preparing a state by sequential
plaquette excitations, so that one contains the plaquettes that you would excite up to second order in strong coupling perturbation theory. It starts with an excitation that's just one plaquette, and then it applies the excitations that you could get to by two applications of the plaquette operator.
Next to each other. Uh, and it sort of extends that then over the lattice, uh, and
It has a certain number of parameters associated with each rotation, and the strong coupling limit, you expect to be able to calculate those in perturbation theory. For smaller Gs, you'll need to fit them variationally, but it's a small onsatz that you can do on small subsystems, at least if you have some understanding of the correlation length.
We just tested it here on this very small system, the cube, and it does pretty well, uh, down to, uh,
G of 1 or so, it's almost indistinguishable from exact or adiabatic preparation. Uh, it starts to get, uh, to miss a little bit down at .8. Um, I think what this points to practically is that we using, um, a variety of different methods to do real ground state preparation. There'll be some onsots that gets us part of the way, and then we'll do
adiabatic preparation, uh, the rest of the way. Maybe I should have said, what, adiabatic preparation is. The idea there is that you take very small trotter steps and lower the coupling at each step so that you use the adiabatic theorem to flow into the state that you want to be in.
Uh, that works very well. It can work arbitrarily well if you eat enough time steps, but it's very expensive, because you have to do a lot more Trotter steps.
So… so we have ideas for this, they're working pretty well so far on these small systems. We'll test them on hardware, uh, and try and extend them to bigger systems.
This is one slide showing some effects of actual noise, uh, not done on a real device, but done on quantum's, um,
private, uh, in-house emulator, so I don't know what the details of the noise are that it's simulating. It's their… their noise model for their device. And for this one, we did the 2x2 lattice with 27 qubits, and just keeping the most important magnetic transitions.
on the order of a few thousand gates, like I mentioned before, this is kind of the limit of what we can do in our current stage of the NISC era.
And here, we turn down the noise to at least a tenth of
of what H2, uh, the H2 device had. Um, this is, again, that kind of,
Uh, simulation of the electric vacuum following a quench.
It's not too bad. Um, I think that the fact that we had to dial down the noise by a factor of 10 tells you that you just get garbage if you put it on the actual device, but their new device, Helios, has 2 cubic gate errors that are a factor of 5 to 10 better than this. So this is actually an interesting target now for the hardware. We'll try and put the 2x2 lattice onto real hardware.
Okay, uh, this is, uh, scattering that we can do on…
Uh, well, when I say we can do, I need to clarify that. Uh, this is the line of plaquettes, this is the simplest scenario where you might try to set up scattering.
I want to emphasize that this slide is very preliminary. I wanted to show it because it looks cool, but I produced it in the last two days using Claude code and just vibe coding like crazy. So, uh, so the…
Okay. It looks… it passes the, uh, the sniff test, shall we say, but it needs to be validated heavily.
The idea here is, uh, we can set up two wave packets on, uh, on placats, smear it out over a few plaquettes and far enough apart that they don't really overlap, and send them in against each other, and try and see some indication of scattering. What we've set up here is a collision where the initial state is just a product state, and you see from the heat map
Time is evolving up this plot, uh, so the rightmost wave pack is moving left, and the leftmost wave packet is moving right. This is an approximation where the, um…
Uh, it's more like a superposition state instead of a product state, so that you don't have a, uh, an actual collision happening. There's only one wave packet here at a time, but two superpositions. This is like a non-interacting control.
That tells us what would happen if we were able to turn off
interactions. And, uh, scattering interactions, I should say. And so you can clearly see a difference between these two. Um, what's actually happening here, if we dig into the eigenvalues of the Hamiltonian, is that there's some repulsive interaction happening. There's some higher energy states it's trying to access, and there's some repulsion that happens between these two wave packets. And one way that you can diagnose it is with the difference
in the signal, you see an excess out here, that's kind of a time advance for the, uh, for the repulsive interaction, and a deficit inside.
Anyway, this really requires a lot more validation. I don't want to take it too seriously right now, but it's the type of thing that, uh,
we can imagine, uh, setting up now as a quantum circuit and costing out for the future fault-tolerant devices.
Another thing that we can do, instead of doing the actual scattering problem, this was done in… using our code, YMCERC, that we made for making
Quantum circuits on lattices, use that as the baseline. Another thing we can do is try and simplify the model from lattice gauge theory to something more, uh, more tractable for current devices. This is an effective model of scattering that reduces the degrees of freedom a lot by working in an energy band and dialing up the hopping term by hand a lot. This is…
what you get, uh, if, uh, if you take that effective model and run this kind of scattering, uh,
simulation. This is noiseless, this is noisy emulation, uh, with Quantinium hardware. Uh, not on the hardware, this is a noisy emulation using the noise model for the Quantinium hardware. And you still see a pretty decent signal by eye here, so we're optimistic that we'll be able to put this effective model on, uh, on hardware also.
Uh, here are the observable. It doesn't just have to be by eye on some heat map, you can actually look for some, uh, some production of
Uh, let's think of this as two, uh,
to fundamental irrep glue balls colliding and making some adjoint rep, uh, glue ball, you can look for a peak in the probability to find a plaquette with adjoint flux on it, and you see a spike in it. This is the
oranges without noise, the blue is with noise, and we see that it's preserved.
Final simulation, uh, let me see if I can get this to play… yeah. This is flux tube spreading. So, we take a two-dimensional 4x4 lattice, we put a flux tube across it, and we adiabatically turn down the coupling to see the flux tube spread out, to see it, uh, kind of…
fuzz out in the transverse directions. We can measure the fraction of flux that's on and off path as we do that, uh, and get some kind of quantitative measure of it. This is going to be for larger lattices and
higher dimensions, kind of a diagnostic of
flux tubes and the pure gauge theory. This is an 80-qubit noiseless simulation using matrix product states, um, and yeah, we can do a bigger one for this.
Okay, I'm a little over time, so let me, uh, let me stop and conclude. Um, we've got…
Uh, this nice code now that puts out circuits that anyone can use, check out our GitHub repo, try them out. That's, uh, hopefully the barrier to entry is not too terrible if you want to play with it. We've got an extension done that does theta terms.
We have fermions working privately, although the costs are quite high. We need to…
to figure out how to compress that more. Um…
And there's several other things in the future. I would say the most important things are related to depth reduction of the circuits, and looking at the continuum limit. This is a plot showing, if you just take a single plaquette by itself, and you look at how the expectation value of the Casimir on each link depends on your truncation and on your gauge coupling, where does it saturate?
This tells you what truncation you need for the single isolated plaquette, given a value of G. And, okay, for this, uh, G of 0.8 is this purple curve down here at the bottom. You see that, um,
it saturates very quickly. A very low truncation is needed. That corresponds to basically just keeping, uh,
the lowest-lying ear reps, some amount of 3-3 bar and adjoint, perhaps, is good enough. Of course, plaquettes do not exist in isolation, this needs to be extended with mean field theory or something to get a more robust treatment. But I'll be able to at least
understand, uh, the challenges of reaching the continuum limits quantitatively.
Alright, thanks very much. Sorry for going over. Uh, let me stop there.
Good.
Thank you, Patrick.
Where they talk. And as you can know here, they clap.
Oh, well, I appreciate it.
Virtual Club. Yeah, there we go. Okay.
Can I answer any more questions? Let's see.
So… yeah.
Yeah, I have a couple of questions.
Um, so, uh…
I guess the first question is, if I had been thinking about doing this,
32 years ago, or whatever,
Um, uh, I would have tried to work in the basis of gauge invariant states,
Given by Wilson Loops, rather than this…
basis where you're including all of these non-physical states.
And apparently, people have decided not to do that.
Can you comment on that?
Well, you need to make sure that you have a nice, normalized gauge invariant space, and that you have enough locality
to, um… sorry, I didn't mean to engage in very… orthonormal space.
And you need to make sure that you still have enough locality to kind of
represent everything that you want to.
You could think of the, um…
Uh… the electric basis, to some degree, is starting to do that with just the smallest Wilson loops. It's not exactly that, but it's roughly that.
Um,
I don't think I can say anything more intelligent about that, except I'm…
Yeah, let me, let me not, let me, let me not, uh, say anything more about that. I'm not sure, uh…
how scalable that is, but it's certainly something worth looking at. I can say that of the… of the 3 or 4 different approaches that I'm aware of, none of them are that.
Uh, that people are working on, um, and I didn't mention the others, uh, which is…
Uh, not very nice, I should have spent some time on that, but there are people looking at the magnetic basis,
Uh, where you start with,
SU3 as, uh, as the group manifold, and try and, um, discretize it in some way.
I'm a little nervous about that approach. There's a maximal finite subgroup, and it's, um…
Uh… it's tricky.
It's not very big.
Yeah.
And it's not very big, yeah, yeah, so… so I'm not sure about that. There are other variants of this, uh,
electric basis that people are looking at, the loop string head run stuff.
There's a group doing large N as a truncation method. That's essentially the same electric basis, but they're using large n arguments to decide which matrix elements to cut.
Yeah, those are the main approaches that I'm aware of.
Okay. Yeah, the other question I had is kind of orthogonal to your talk, but…
Um, I wonder if you…
apply these same methods to the U1 lattice gauge theory, whether you see the phase transition and…
its properties.
Yeah, um, the main reason that we didn't look at U1 is because a lot of people look at U1, that's the standard, uh,
first step that people have looked at, and I believe that they have, um… I can't quote the papers off the top of my head, but I remember at least
a bunch of papers on building the circles. I don't know if they… they can do it, or they have to do MPS for all of it, uh, still.
Yeah, good question. I'll look at that. Pretty much everybody starts with the Schwinger model, because there's a very clean, nice signal of
paracreation. Uh…
Right.
But, unfortunately, this is a… this is a…
sort of thing where you get…
sort of qualitative changes in the complexity at every step. When you go from U1 to SU2, it's just a qualitative jump in the complexity, and
the lessons you learned don't really transfer. One- to two dimensions, same thing. SU2 to SU3 turns out to be a qualitative jump, and some groups just couldn't do Beyond SU2, so…
Okay. All right, thank you.
There were some question from Yannis. Do you want to ask, or should I read the…
Pushing.
Oh, I see, yeah, sorry. Uh, okay, there's some questions, let's see. Shouldn't Gauss's law be satisfied naturally and not imposed as a constraint? That's only if we work in a… in a global lattice gauge invariant basis, where we enumerate the gauge invariant states on the whole lattice, but since Gauss's law, uh, is, um, is something that solving it requires a non-local specification of the gauge fields.
Uh, we don't want to do that so that we can maintain as much locality as possible.
So, the price for that in our formulation is that there are states that are unphysical. So there are, uh, states which on the quantum device, have been mapped to things like
Several links in the trivial, and one link in the 3 in the flux just dies there, so…
So that's not, uh, not automatic, and we have to make sure we don't wander off into that space. There's also a question, can you share some technical details of how the cubic gates were improved on the Helios system?
I think what that means is the 2-qubit gates, um,
No, I have no idea. I don't, uh, I don't do any hardware, uh, I just interface with them and hope that they get better so that I can run my stuff on them.
Thanks for the questions.
Are they hardware people in Urbana, or are they different groups?
Um, well, we have… you mean at Quantinium?
Yeah.
Uh, oh, that's a… that's a big company. They've got, um, uh…
fabrication, I think, in Boulder and
Cambridge, if I'm not mistaken. I don't remember where their primary hardware people are, actually.
they have a big presence in, yeah, Japan, the UK, and the United States, at least.
Nobody from there is here locally,
And I'm not even sure that there's anybody in Illinois, to be honest.
Okay, if there's no more question…
Let's thank Patrick again. Thank you for, uh, the talk.
Too bad that you couldn't be here.
Thanks very much, everybody. Appreciate it.
Okay, guys? See you.