 What? I don't know. What screens were on the screen? Do they want to hear that it's a game? Okay, well sure. Is there an okay to answer it? On the screen? Uh, what? Uh, okay. I'm still talking. Am I allowed one? It's just a quick thing. You have to stand between those two lines. Okay, sure. Do you have... Okay, sure. So next speaker is going to be Josh Isaac. He's a quantum mechanic, freelance science writer, software developer, PhD in quantum computation, and he's one of the early employees at Xanadu, which is a quantum computing hardware startup based in Toronto. And he's going to be talking about strawberry fields, which is a software package for photonic quantum computing. So let's welcome the speaker. Uh, hi everyone. So I come from a physics background. As mentioned, I did my PhD in quantum physics in Australia. So if anyone has any questions about the physics, feel free to talk to me afterwards. So I'll start off just by talking a bit about Xanadu as a company. So Xanadu is a full-stack quantum computation company based in downtown Toronto. So because we're full-stack, we're on the entire focus from the hardware all the way down to the infrastructure and then to the software itself that the users will be using. So we're taking sort of a different approach to the other quantum computing companies. We're focusing on photonic quantum computation. And photonic quantum computation has quite a few advantages compared to superconducting qubits or iron traps. So with photonic quantum computation, we can make use of the last 30 years of advances from optics. Also, as opposed to the other methods, we can work at room temperature. So we don't require supercooling. And I'll get into that a bit more. So this is an image of our team. We started small, so to give you some background, when I was interviewed, we had five people working there. When I started working, we had 15. Now we have about 35. And this slide's been a bit of a running joke because in every slide someone gives from Xanadu, the team just to show how diverse we are. So we're a huge group of physicists. Almost everyone here is their PhD in quantum information, quantum computation. We also have a small business team and a algorithm team, a quantum photonics hardware team. And as Xanadu's grown, we've added everyone to the slide and we're reaching the point now where we don't think we'll be able to add any more people. So the previous iterations had everyone's names and backgrounds. Then we went to the photos plus the names and now we've removed the names. So this will probably be one of the last times we're able to present the full team just because of the race of growth of Xanadu. So some key areas. We're focusing on quantum machine learning, quantum finance, optimization problems, quantum chemistry and sensing, especially photonic hardware sensing. So I mentioned earlier that we're working with quantum photonics. So quantum photonics, not only is it a different form of hardware from the other quantum computing companies, we're also working in a different quantum computing paradigm. So the other quantum computing companies are working with qubits. So discrete quantum bits that can take a state 0, 1 or a superposition. As Xanadu, since we're working at quantum photonics, we're working in a different paradigm called continuous variable quantum computation. And if some of you were here for Thomas' keynote, the very first talk of the quantum computing track, the continuous variable paradigm was mentioned on that slide next door to quantum annealing and the qubits. So as far as we know, we're the only quantum computing company working in continuous variables, and this has certain advantages, certain disadvantages. I'll go through them and I'll give you guys a crash course on continuous variables. So essentially, as Xanadu, what we're doing is we're using integrated photonics chips. So we're working with well-established hardware companies and universities to develop integrated photonics chips that include waveguides. And we have a photonics laser lab on location in our offices in Toronto. So what we're doing is we're coupling lasers to these integrated photonics chips, creating entanglement between the waveguide modes and superposition, and then performing measurements on that. And so that's our model of universal quantum computation. So something that I'll just emphasize quickly is that the continuous variable approach to quantum computation, it's still a gate-based model. So I'll introduce you to some of the gates we have. They're a bit different to some of the other gates in the qubit model. So for instance, in the qubit model, you've probably been used to seeing today how we had my gates. We use a slightly different gate set that's based in quantum photonics. And in addition to that, there are particular advantages for continuous variables in the near term. So the noise-intermediate-scale quantum device range. So before fault tolerance. But the thing to emphasize is once we have fault tolerance, the continuous variable paradigm and the qubit paradigm are essentially on equal footing. So the algorithms you can apply with the qubit model, you can apply in the CV model. So a couple of the main advantages to the quantum photonics approach, especially using continuous variables, is something I've already briefly mentioned. We can make use of room temperature hardware. So because we're making use of room temperature hardware, we don't have to worry about super cooling. We don't have to worry about going down to full Kelvin or anything. We're using quantum photonics and standard photonics gear that we purchased almost off the shelf. And these are easily rack-mountable. So if you go into our lab, it will look like a quantum photonics lab in the university. We have small little racks where we're starting to put together some of our quantum hardware. I think one of my colleagues bought a used computer case of eBay. So we have one of our integrated quantum chips sitting in this used computer case. Another advantage is that we can connect to existing communication networks. And one of the choices we had when we were setting up our hardware lab was what wavelength do we use for our photonics. And so just a disclaimer, I'm not a hardware person. I'm not part of the hardware team. I'm part of the software and QML team at Zazoo. So I'm not the best person to talk to with Rios the hardware. But from what I recall, we've chosen the 1515 nanometer wavelength for quantum photonics. And this is solely because it's what's used in telecommunications. So we have the opportunity to take information from optical fibers from telecommunication companies and couple them directly into our quantum chips. But this is FOSSTEM, so I'm going to take a hard turn here and talk about open source software. So as Zazoo, we've taken the approach that open source software is best at the moment for the physics community, for the quantum computation community. So we've made the effort to open source almost every tool we've used. And this is just a list of some of the things that are available already on our GitHub repository. So if you go to github.com.zazoo.ai, you'll see these open source software projects. So the ones I'll just highlight are on the left, we have the SDKs and software tools we've released. So Strawberry Fields is the one I'll talk about now. This is our SDK for interfacing with our quantum photonics hardware. We also have Penny Lane, which is a bit more high level. And that's the next talk. So that's an abstraction of quantum computation that easily allows us to perform quantum machine learning and back propagation. We also have the Hapnian library, which we don't really advertise too much, but I'm actually quite proud of this. So a slight tangent, but it turns out that when you're doing continuous variable quantum computation, you end up calculating the Hapnians of a lot of matrices. And some of you with a physics background might be familiar with boson sampling. So boson sampling is a quantum photonics algorithm where it turns out that by sampling the system, you're sampling from all of permanence. And permanence are a sharp P hard to compute, sharp P hard to sample from. So you can demonstrate quantum advantage or quantum supremacy from the boson sampling experiment. So our quantum photonics ship, actually, the first generation of it will be doing something called Gaussian boson sampling. And Gaussian boson sampling does the half-nines of matrices. And this is one order higher than calculating the permanence. So the Hapnian is a generalization of the permanence. So what we've done is now do is we want to be able to easily simulate these things. So we can benchmark, we can run classical simulations of quantum algorithms. So we developed this tiny little tool called Hapnian, which we used internally. And not only that, but we also, we have a whole bunch of researchers who found the fastest currently known algorithm for calculating the Hapnian classically. So this is the equivalent for the Reissa algorithm for calculating the permanence. So last year in the archive, we submitted a paper for this fastest known classical algorithm and also a Python package. So you might not find much use for it, but you can pip install Hapnian. And we took a year working out how to calculate, how to build the wheels, the binary wheels and the windows Mac and Linux. I don't know why no one uses this package, but you can pip install it now. We have a pipeline where it's built automatically on Travis, keeping everything open source. And it's also parallelized. So open MP for local parallelization and open MPI. And then on the right, you just have a couple of GitHub repositories related to some of our research we're doing. So not only do we want to emphasize software is open source, but when we do research that involves computation, we also want to open source that. Because a big problem in the scientific community is sometimes you read a paper and you can't reproduce the results because they haven't released their source code. So every time we release a paper that does a computation, we strive to release the source code. And we also strive to document the source code instead of just putting a Python script in the GitHub repo. So all the ones on the right are papers we released last year in 2018, put up on the archive. The source code is all there. Documentation is all there. I don't think they have unit tests. It's something I'm trying to change. Physicists aren't very used to writing unit tests. So I'll give you guys a quick crash course on continuous variables just so you understand some of the terms I use for the rest of the talk. So as you can probably guess from the name, when I say continuous variables, we're working with a continuous spectrum of real numbers. So when you measure a qubit, you break the superposition, you measure either a zero or one. In our system, when you measure our q-modes instead of q-bits, you get the result as a continuous number, so 3.78 or something to that effect. You can sort of think of it as analogous to analog computing compared to digital computing. So in the regime before fault tolerance, continuous variables are sort of like analog computation. And just emphasizing again, it's universal. So any algorithm you can do, it's universal for BQP, same as the qubit model. And the way we do this is because we're working with light, light can be represented by electromagnetic waves. So this is how we encode the continuous degrees of freedom. For instance, the electromagnetic amplitude in different vectors, et cetera. So this is what allows us to physically carry the continuous variable information. So it's sort of like a spectrum here. At the top, you have the qubit model where you just have two distinct states. And you can almost think of this as starting to increase the number of states you're allowed in your quantum system. So this is known as the qubit system. You can have a quantum system with three states, et cetera, et cetera. And if you continually add more states to the system, eventually you arrive at a point where you've essentially got a continuous system you can sample from. So this is what we're working with here. You can see that in the qubit system you have a summation of the different states you can have. In our case, we can have an integral. And that's just essentially summed up here. So qubits, we can represent that as a state zero and state one with complex coefficients determining their superposition. In our case, we have eigenstates called x eigenstates, and we simply have an integral over that. And the function psi represents the amplitudes of that continuous state. But not only do we have this continuous representation, but light is quantized. So we can represent the continuous variables as real numbers on the electromagnetic waves of the light we're entering into our photonics waveguide. We can also look at the photon number occupation from the wave particle duality of light. So for instance, we can represent the light as a summation over a bunch of occupied photon states. So even though we are working a continuous variable framework, there's still a degree of discreteness that we can access. And so this is how we generally represent our continuous variable states. So this is called a Wigner function. You saw it, I think in the Q-SIP slides, that was a Wigner function. This just represents the continuous variable. So we have two orthogonal operators in our continuous system, the x-operator and the p-operator, position and momentum, plus on each axis, and this is just the probability of the state. So what you're seeing here is just a vacuum state enters into the quantum waveguide. But apart from having to think about continuous variables instead of discrete variables, the quantum computing gate paradigm is still there. So we can still represent our quantum circuits using quantum gates. And it's universal, so we have a set of quantum gates where you can produce any quantum algorithm. So this is an example of what one of our current prototype chips look like. So this is known as Gaussian boson sampling. If you want to sample this, you need the half-nian, so please pip install half-nian. And the gate nomenclature simply comes from quantum optics. So I guess in quantum optics and quantum information, there's been a bit of a... Sometimes physicists aren't really good at talking to each other. So it turns out that quantum optics, people working in quantum optics experimentation have been doing a lot of quantum information over the last 20 or so years. We haven't recognized it as quantum information. And you can take what they're doing and rewrite it using the same quantum information terminology that we use when we're looking at qubit circuits. So this is essentially what we've done here. The BS gate, that's just a beam splitter gate. So in the quantum optics lab, you're applying a beam splitter between these two waveguides. S, that's squeezing. The R gate, that's a parametrized gate. That's parametrized in terms of a continuous variable, and that's rotation. So we can rotate the states of the Q-mode within the 2D phase space. So this is just a quick overview of some of the differences between the Q-modes and qubits, just to sort of drive this point home. So in qubits, you have qubits. Q-modes, you have Q-modes. Some of the fundamental operators in the qubits are the Pauli operators. With our case, we have the Quadrature operators. And also some of the common dates. So in qubits, you come in to see phase shift, Hadamard, C-naught. In our case, you'll hear us say rotation, displacement, squeezing, cubic phase, terms like that. So this is a bit too much maths for my liking, so I'll show you these gifts instead. So displacement gates. When we say displacement gate, we're literally taking the state in the 2D phase space, and we're just displacing it. Rotation gate, same thing. We're just taking the state, get their names from how the state is transformed in this two-dimensional, continuous phase space. Squeezing gate, same thing. We just squeezed the state. Not much more to say. From here, they start to get a bit more complex. So the beam splitter is our fundamental gate for entangling two modes. So what we're doing here is we're applying a phase that entangles between the two modes with this beam splitter. Actually, something that I've just remembered that I should probably state is that one of the main advantages of quantum photonics as a system for quantum computation is that you've noticed in the previous talks when people have been talking about superconducting qubits and ion traps, et cetera, there's an issue with connectivity. So we can only connect a specific number of qubits in existing quantum chips. With quantum photonics, that's not an issue at all. If we create a chip with 20 Q-modes, we can just use beam splitters and have complete connectivity between all the Q-modes. Noise also isn't an issue. So even though we're working at room temperature, so thermal noise, you'd expect to be in the background there, even at room temperature in quantum photonics, thermal noise is so insignificant, we don't even have to worry about noise. The thing we do have to worry about is that every time we apply a different gate to the Q-mode, there's a certain proportion of the light that will be lost in the coupling. And so we have to worry about gate depth. So after, say, applying 10 or 20 gates, loss becomes significant, and that's when we have to do the measurement and stop the computation. But that's something that we've got an architecture team who are working through that and trying to work out how to minimize loss in quantum photonics. So these are some of the more fun gates. So all the gates you saw earlier, they're gashin gates. They take a gashin distribution in the phase space and they create another gashin distribution in the phase space. This is a non-linear gate. So it takes a gashin distribution and gives you something funky. And this is one of the most important gates because without this gate, we don't have universal quantum computation. So the previous gates, all the gashin gates we call linear, this one offers non-linear gates. And this allows us to access the full range of BQP algorithms. And you can see it takes the gashin state and gives us something weird. Another one is the cubic phase gate. This also is a non-linear gate and it takes the gashin and gives you something weird. So we don't need both of these. As long as we have the ability to transform a gashin fully in the phase space, all we need to do is apply one non-linear gate and we get universal quantum computation. So these are just some of the states you see if you're working with continuous variables. Coherent states, those are just states you displace. Squeeze states are states you squeeze. And this is a bit more nicer to look at. So this is a pictorial description of what these states are. So because we're working in continuous variables, there's a lot more degrees of freedom and that's exhibited with a larger number of initial states you can have in your system. So these are all the gashin states we can start off with. There are also some non-gashin states and they can be as simple as a single photon state. So if we have a single photon source and we emit this through the waveguide and we perform measurements and calculate the Vigna function, that's what it will look like. And the key thing to note about non-gashin states, so these are key resource states in universal quantum computation, is that the Vigna function in the state space is always negative. So as soon as you see the negativity, the Vigna function is a quasi probability. So it allows negative probabilities and that's what we want to see. If we see the negative probability, we have universal quantum computation with photonics. And we also have a couple of measurements. So we can do photon counting, access the discrete nature of the system or we can access the continuous nature of the system and look at homodyne and heterodyne measurements which return real values. So now I'll talk more about our SDK. So everything you saw was sort of like a very fast crash course in continuous variables. And I have to say, when I first came to Zadoo, I hadn't done any continuous variable quantum information work before and even I found it was a lot to learn, a lot to get through. So I tried to condense it down as much into GIFs as I could but it's still a lot of information. Only thing you need to know is we're a gate model and we provide universal quantum computation. So now I'll talk more about our SDK. So strawberry fields is sort of our... It's a couple of things. It's a Python-based tool which includes a quantum information simulator. So it allows you to create quantum circuits, you apply your gates and it prepare your states, perform your measurements and it can simulate that for you. It also is an API to our quantum hardware. So we're in the middle of building our quantum hardware. We have a couple of prototypes in the lab and we've run internal testing where we've sent a programmer in the strawberry fields to the hardware, run the quantum computation and return the result back to our software. So our aim at the moment is to have the hardware online in quarter two this year, so about mid-year. And that's progressing well. So hopefully if I'm here next year I'll be able to show you demonstration of using strawberry fields to access our quantum photonics hardware in Toronto. So feel free to check out our GitHub page. We've taken quite a lot of care with strawberry fields in terms of the documentation, the testing. We're quite proud of it, so check out the documentation. It probably explains a lot of the CV background a lot better than I was able to do today. A couple of the main features of strawberry fields. So as you'd expect for foster, it's open source. It's full stack, written in Python. It's available if you just pip install strawberry fields. We have our own assembly language written for defining your quantum gates and applying them to the actual quantum chip or the simulator. This is called Blackbird. And we have pastors written internally which allow us to translate that directly to machine code which is interpreted by a control lab. So that's part of the hardware integration. It also includes a suite of CV quantum computer simulators. And the simulators are where it gets interesting. So we've got three simulators. We have two there written in NumPy. And one uses the discrete method, so a number of photons to calculate the results of your simulation. The other one uses the Gaussian representation. So it transforms Gaussians in the bigness phase space. They both have their pros and cons. The Gaussian one is faster but not universal. The other one is slower because you're doing a classically intractable computation that you need to speed up using quantum hardware. But you can access universal quantum algorithms with that one. The most interesting one in my opinion is the TensorFlow one. So I think at the time we were the first to actually think we could implement one of these back ends using a modern machine learning library. Because these machine learning libraries like TensorFlow, PyTorch, they now provide an amazing array of mathematical functions, especially the really obscure ones that you need in quantum physics. And this is the case with TensorFlow. It's not quite the case with PyTorch. I don't think they support complex mathematics yet. But TensorFlow definitely supports everything we need to do to simulate quantum computation. So we have one of the back ends of Strawberry Fields written in TensorFlow. And this is quite exciting and I'll get to that a bit more. So this is just a quick overview of the Strawberry Fields SDK. So we have the main Strawberry Fields API and Blackbird Quantum Programming Language. So this is just how you write your Python programs interface with our hardware, interface with the simulators. We have the simulators I mentioned before. Two written in NumPy. One using discrete number of photons as the back end. One using Gaussian representation, the TensorFlow one. And then hopefully online, middle of this year, the quantum processor, as well as the back end. We also have, actually, this is something cool. So this is, I'll try and explain what this GIF is doing. So what we have here in the very beginning of the GIF, we just have a vacuum state. So the laser is coupled to the quantum chip, but there's no gain, there's no loss. Nothing's really happening. We're not applying any gates. What we're doing, though, is we're using the Strawberry Fields TensorFlow back end. And what the Strawberry Fields TensorFlow back end is doing is it's got what we call a CV neural network. So a continuous variable neural network composed of various continuous variable gates. So we have Gaussian gates and one non-linear gate, such as a Kerr gate. And each of these are parameterized by a real number. And because they're parameterized by a real number, this makes it really useful for machine learning. So what we can actually do is we can treat those TensorFlow variables, do our simulation, and optimize over these TensorFlow variables using stochastic gradient descent, or just gradient descent, and ask TensorFlow to optimize the result of this quantum computation to output a single photon state. And so that's what's happening. That's what you're seeing here. We're starting off in a vacuum state, TensorFlow's doing its optimization, working out the parameters of the quantum neural network. And at the end, we have something that has something like a 99.999% fidelity to a single photon state. And this is actually quite exciting because generating a single photon state deterministically is something that's very difficult to do in quantum physics and it's still pretty much an unsolved question. We know how to do it stochastically, but we don't know how to do it deterministically. So this is actually a pretty neat tool to, even if you're not interested in quantum computation, if you're just a quantum optics experimentalist who wants to be able to work out what primitives you want to apply in the lab to get a particular state, you can do that using strawberry fields. So I mentioned the back ends. These are just the simulators we have built in strawberry fields. Allows you to do universal quantum computation. The Gaussian back end is fast memory efficient because you only worry about squeezing, displacement, things that are easy to do classically. We have the Fock back end either using NumPy, which is much slower because you're doing something classically intractable. And it works on a truncated Fock basis. So there's a potential possibility for errors to be introduced. You just need to increase your Fock basis to take into account something like 30 photons, 40 photons. It goes as large as you can without using up too much memory, essentially. Yeah, so that's essentially the scaling. D is the cutoff of your Fock space. So if you want to simulate anything below 20 photons and n is the number of modes, so if you want to simulate four modes, you're doing something like 20 to the power of four. You already see how bad that scales classically. So it's exciting as we're getting our quantum chips online and we're starting to perform these same simulations in seconds or milliseconds. If you want to do a computation, it's pretty easy. You just import strawberry fields. You import NumPy. You create your engine and your engine just specifies the number of modes and keeps track of your queue modes. And then you just apply your gates with an engine context. So here I'm creating a coherent state. I'm squeezing two states, applying a beam splitter to entangle them, applying another beam splitter, and then doing measurements. And what this algorithm is actually doing is it's doing quantum teleportation. So we're creating a state side that's owned by Alice and Alice and Bob are able to communicate a classical bit and that's what the measurement is doing. This classical bit is then communicated to Bob in the last two lines. And once that's done, Bob has essentially the same quantum state as Alice. So quantum teleportation has taken place. And this is the sort of hello world of continuous variable quantum computation doing quantum teleportation. So when we designed strawberry fields, we know that it can sometimes be hard when you're a physicist to design software for people who don't have that background in physics. So we strive from the beginning to sort of make it as easy to use as we could, as straightforward as we could, and to have the best documentation that we could. So if you're doing any simulation in continuous variable quantum computation, it will essentially look like this in strawberry fields. So you import strawberry fields, you create your engine, so in this case I'm just creating engine with two modes, and then you create your engine context. And in this engine context, you just apply your gates. So if you have your quantum circumference now, so your quantum algorithm determined, you just construct it within the engine context here. And then finally, you run your simulation, you run your engine, and you specify which back-end you want, whether you want a numpy back-end, or you want a TensorFlow back-end, and if you're using a foc back-end, you have to specify the maximum number of photons you want to simulate, and you get returned your output state. So if we look at the example from before, the quantum teleportation circuit. On the left was the blackboard code for adding the gates to the circuit, and this is the equivalent circuit here. And, yeah, I guess that's all there is to say about it. We tried to make it as simple as we could. It's a domain-specific language embedded in Python, but with its own separate parser. We've got a C++ parser as well with the aim to create C++ simulators, and also use that to interface with our lab control systems. So that's basic introduction to strawberry fields and what we can do with it. Another exciting thing with strawberry fields is the applications built on top of it, because sometimes when you want to do a quantum algorithm, you want to look at the low-level stuff and you want to carefully control which gates are applied, which Q-modes are entangled. In a lot of cases, you don't really care. You want to be able to do high-level things without thinking about what's happening on your quantum processor. So that's what we're trying to do now with strawberry fields, build high-level abstractions on top of strawberry fields that just make quantum computation easier to access. So this is one tool we developed. It's just an online interactive web application where you can graphically build your circuits, choose your backend, choose your simulation type, and just run it in the cloud. And this is sort of a toy problem, just to see if it could be done to advertise. It actually became quite popular and a lot of our physicists in the lab use this. So I'll walk into the lab and see people dragging gates around, trying to convince them to use strawberry fields, but they always end up back at the interactive web application. We have a couple of other ones. So there's a great library called OpenFermion. And what OpenFermion does is it allows you to formulate many electronic structure problems in terms of quantum computation. So you define your Hamiltonian, the properties of the Hamiltonian, transformations you want to take, interactions you want to make, and OpenFermion has a whole bunch of methods to allow you to transform this into a problem for quantum computation. And this is a great package. So we really wanted strawberry fields to be able to interface with OpenFermion. The problem is OpenFermion is a great package, but only knows about fermions, so particles like electrons, which have to satisfy the Pauli exclusion principle. When we're working in photonics, we're working with bosons. So we loved OpenFermion, but we couldn't use OpenFermion. So what we did was we submitted quite a big pull request to OpenFermion to add boson support. And it's there now. We're quite proud of it. We think we're the only ones using it, but it's in OpenFermion. You can now do boson stuff and interface directly with strawberry fields. So in this case, something that continues variables in quantum photonics is really good at simulating is, as I said, Hamiltonian simulation of bosons. So here we're just using OpenFermion to create a bosthub at Hamiltonian. And there's a new function. There's a new quantum operation you can call in a strawberry field called bosthub at propagation. And this automates the process of simulating this Hamiltonian propagation for you. And everything is automated. So normally if you were doing this, if you had to work this out yourself, you would start off with your bosthub at Hamiltonian. You would then have to work out how to decompose this into various gates, whether you're using qubits, whether you're using CV gates. So this is all automated. So our goal is for any bosonic function we have in OpenFermion, we'll be able to decompose that and apply that in strawberry fields and in our quantum photonics chips. The other package we have is QMLT. So this is another package built on strawberry fields. And the main impetus behind this is we noticed a lot of people didn't like using TensorFlow. It can be very unwieldy using TensorFlow. You're doing very low-level stuff. So we wanted to also automate this process. So we wanted to make quantum machine learning using strawberry fields fun because quantum machine learning backend is there. We're doing all the linear algebra and the nonlinear functions using TensorFlow commands. And we want there to be a fun and easy way to access this. So this is what the QMLT does. So you import strawberry fields and you import QMLT. And what you can do in QMLT is you can create a machine learning model where you define your cost function, you define your quantum circuit using CV gates. And you can import regularizers and helpers. And it just makes it a whole lot easier to use than doing the low-level TensorFlow stuff. And built-in life plots. Is this planned already? This is already really. So it's on our GitHub repository. So that's essentially all the parts of the strawberry fields SDK and it's how it's structured. There's still one more package that we're part of, Penny Lane, which sort of sits separate for strawberry fields. And that will be talked about more in the next talk. That Penny Lane is a very exciting package. Yeah, so feel free to check out our documentation. We're constantly adding to it. Every time someone in the office of one of our researchers does something cool with CV quantum computation, we try and convince them to create a page in our documentation detailing as a tutorial what they're doing, why it's cool, and how you can simulate this at home using strawberry fields. And let us know if anything you think is missing or anything needs to be explained better. We know continuous variables can sometimes be a bit harder to access than the qubit method, just because not as many people are working with continuous variables. But continuous variables are exciting. They're a lot more attractive to things like machine learning, where you want to work with continuous variables. Also, check out our GitHub. Feel free to go through our code. We're physicists, so let us know if we're doing anything crazy, make issues, make pull requests. And check out our interactive website, Strawberry Fields to AI. So this is the interactive Strawberry Fields circuit builder. Yeah, and I think that brings us to the end of the talk. So thank you. Yeah. The question is the toughest question. Sure. Are you going to call your quantum chaos package Halter-Skelter? I see you've picked up the theme of, yeah. So that's a very good question. Oh, yes. So the question is, what's the ultimate goal for doing error correction on the CV system? Yeah. It was the mole. So we have a separate team at Zandu called the architectures team. And they're about 10 or 11 people. And that's their job to get to the bottom of this and work out the best scheme for error correction. So we know how to do error correction in the case of dual-rail qubit encodings in quantum photonics. And in that case, we're using something like special resource states called hex-GKP states. And what these states do is they allow us to do error correcting codes. In our specific architecture, it's still a bit of an open question what the error correction will look like. But we know it's possible, and we're working hard and getting to the bottom of that. Right. So open fermion, oh, the question is, what's the advantage of open fermion over existing numerical packages for something like density functional theory? So open fermion sort of sits in between packages like that and packages like strawberry fields, kiss kit, pike will. So what open fermion does is it actually integrates with those packages as well. So I think one of the common ones is pi SCF for electronic structure calculations using DFT or Hartree Fock. So what it does is it interfaces with those to do some known classical algorithms we have. And then things that are classically hard are sent to open fermion. Open fermion decomposes that into quantum circuits and quantum simulations. And then those can be sent to one of the quantum simulation packages like strawberry fields to actually be implemented on quantum hardware. So it sort of sits in the middle trying to just try and make everything run faster. So we have things we know classically, but we don't have time. So I wanted to ask about this current interaction. So do you have a timeline for implementing it in your chips? So the question is do we have a timeline for adding a non-linear gate such as the current interaction to our chips? So the cubic phase and the current interaction are really, really difficult to do in quantum optics. So we don't have an issue with noise. We don't have an issue with connectivity. But it is hard to do a non-linear gate in quantum optics. So what we're trying to do is we're trying to find new algorithms for resource state preparation. So create resource states such as a cubic phase state that we can then use through other algorithms such as gate teleportation to apply the cubic phase gate. So it's still ongoing research. Yeah, exactly. Could you rephrase the question slightly smaller so I can repeat it? When you say hybrid computers, do you mean like hybrid classical analog digital or something like that? So I think the question is, is there anything we can't compute using the continuous variable method in the correspondence of the classical analog computation mode? Oh, something extra. Potentially, that's a good question. I'm not, because I don't have a CV background. I'm not one of the best to ask questions about the actual computational theory underpinning CV systems. But we can encode the full cubic system in a CV system. So my expectation would be, yeah. I'll do a break in five minutes.