Programming Quantum Networks in Python

Speaker 1 [00:00]

He's a PhD candidate at QTech, Delft University of Technology, and his research focuses on benchmarking and improving the performance of near-term quantum networks through advanced simulations. And it's a pleasure to introduce you, to have you here sharing with us, and I would like to highlight, if you have questions, you can go to talks.pycon.de, and you can find this talk and there's a place there where you can put your questions and then we're going to scan through them at the end and I think with this we keep everything organized under control here. All right, Simon. All right, great, thank you. So today I'm going to be talking to you a bit about programming quantum networks in Python and as Jaap Ricardus introduced me, my name is Samuel Oslowich and I'm a PhD candidate at QTech at Delft University of Technology in the Netherlands. So in this talk, what we're going to cover is, first of all, what even is a quantum network and why should you care about them? Then I'm going to talk a little bit about what is being built now with the Quantum Internet Alliance, where we are actually working to build a real quantum prototype network. Then I'm going to talk a little bit about the most fundamental quantum network protocol, quantum teleportation. And then we're going to go through, I'm going to give a live demo of programming quantum teleportation in Python so you can see how easy it is to get started with programming quantum networks yourself. And then by the end of the talk, I'll give you some resources and share a GitHub repository so that you have everything you need to be able to try this yourself and start learning about quantum networks yourself. So why quantum networks? Why should you care about them, and what even are they anyways? So I'm going to start with talking a little bit about classical networks. I think we're all very familiar with classical computers and the internet. It's become so ubiquitous in our daily lives. Back in the 60s and 70s when we were first creating the internet with ARPANET, I don't think anyone could have imagined how useful the internet would be and how we would be using it nowadays. You really can't imagine life without the internet. We use it for video streaming, online banking, cloud computing, and there are even the people online watching these talks also using the internet. So what if we could do something similar for quantum computers and connect them to create a quantum internet? Does this also unlock advantages and new applications? The answer is yes, it does. If you connect quantum computers, you can unlock new applications like blind quantum computing where you can run a quantum program on a server and the server will not be able to learn anything about what the algorithm is that you're running or even being able to see the data that you're running your algorithm on. It also enables things like quantum key distribution with enhanced cryptography where you have provably secure cryptography that's guaranteed by the laws of physics. So if there's an eavesdropper on the channel, this is physically detectable. And of course, just like how we can connect classical computers together to do distributed classical computing like in data centres, we can also connect quantum computers together in quantum data centres to be able to form larger and more powerful quantum computers through distributed quantum computing. I just want to give you a little bit more detail on one of these examples, blind quantum computing. So blind quantum computing enables you to run quantum computations in the cloud without the server ever seeing your data or the algorithm that you're running. If we wanted to do something like this classically using the internet, there are a couple problems. The server, your cloud provider, must decrypt your data in order to process it, and you're really relying on some sort of a trust model or a contractual agreement. You send your data to this cloud provider, and you have a contract with them that says they won't look at your data and won't use your results, but in practice, this is vulnerable. You're just trusting them to honor this agreement. With blind quantum computing, you can actually guarantee through the laws of physics that the server will not be able to see your computation or know what algorithm you're even running, and this is especially useful in cases. you're running quantum simulations for drug discovery, or you're in the medical sector, and you need to care about the confidentiality of your patient data. And so then blind quantum computing enables you to have this much stronger security guarantees. So now we know a little bit about why we should care about quantum networks and what they can be used for. And these quantum networks, they aren't just science fiction, and they're not just purely lab experiments anymore. As part of the Quantum Internet Alliance, it is our mission to build a global quantum internet made here in Europe. We're a collaboration between many different universities, industry partners, and startups. And one of our main goals is we're currently building a prototype full-stack quantum network and our aim is to achieve that by 2030. And one of the big tools that we're using to build this quantum network is Python. We program all of our applications that we run on this quantum network using the NetChasm software development kit. So great, we know a little bit about quantum networks now, but how do you program a a quantum network anyways? Well, the first thing that we care about and that we need to know is what is the data that we're actually sending, right? In classical networks, the fundamental unit of information that we send is classical bits, which can be zeros or ones. That's it. But in quantum networks, it's a little bit different. We have quantum bits, also called qubits. These can also be zero or one, but they can also be a mixture of zero and one at the same time. And this is one of the reasons that this is one of the things that gives quantum computing and quantum networks these enhanced capabilities. Now, I'm not expecting you to fully understand qubits now, and you don't even need to fully understand them to be able to program with them. So right now, I just want you to think of these qubits as a new data type, kind of like integers or floats, but it's a bit weirder. So how do we, now that we know what the data is that we want to transfer, how do we actually transfer this in quantum networks? Again, I'm going to go back to classical networks. I think as Python developers, you know, you're very familiar with classical networks, right? You just need to use a socket library, you connect to a server, and then you can just send your information across the classical channel. And if these packets get lost in fiber along the way, it's no problem. We have TCP, transmission control protocol, and it will just resend them. And this works because with our classical data, we can make many copies of it. So if we lose one copy that's sent, we just take our copy and send it again. And so then we have this kind of reliable delivery mechanism built in with TCP. We don't even have to think about it. We can just send a message over the internet. We can kind of just assume and rely on the fact that it's going to get there. So naturally, that leads us to the question of, can we do something similar for quantum networks? Well, unfortunately not. This comes from the fact that you cannot copy qubits. And this is not a technical limitation. This is a fundamental law of nature called the no-cloning theorem, where in physics you are just unable to copy quantum information. This means that, you know, if we send a quantum bit through our channel and it gets lost, it's gone forever. And this can be especially painful because it might take us a very long time to create this quantum bit. You could imagine it could be the process of a very long algorithm, and then we want to send it over to another party, and if it gets lost, we need to redo this entire computation from scratch. So this is, of course, a big problem. So how can we reliably transfer data in quantum networks? How can we get our qubit from point A to point B without having to worry about losing it? This motivates a new networking protocol called quantum teleportation. The idea is if we have, you know, Alice and Bob and we want to send a qubit from Alice to Bob, rather than sending it through the channel where it can get lost, we teleport the qubit from Alice to Bob. Now, this probably sounds very science fiction-y, but I'll get into a little bit more of the details and intuition behind this in a second. And the reason that this works and that this is great is because if we teleport the qubit from Alice to Bob, we never have to send it through the channel, so we don't have to worry about losing And, this is no cloning safe, since we don't need to make any copies. So how do we actually do this? It turns out that if our two nodes share a special quantum resource called entanglement, they're able to perform protocols like quantum teleportation. So then, of course, you've got to be wondering, what is entanglement and how does this enable teleportation? So I'm going to talk about this using an analogy. So imagine that we have two magical coins, and these two magical coins are connected. So if we were to flip our coins, so if we flip one coin and we get heads, we know that whenever we flip the other coin, it will also be guaranteed to be heads. So there's this kind of correlation between these two magical coins, where if I flip one, I automatically know what the outcome is going to be for the other one. And it doesn't matter how far apart you take these coins. For example, if I were to have one coin in Delft in the Netherlands, and we were to have one coin here in Darmstadt, as soon as I flip my coin in Delft and see that it's heads, I know that whenever the coin is flipped in Darmstadt, it will also show heads. now this is a really you know unique and very funky correlation this is something that you really don't see classically because it's impossible classically now of course in practice we don't have magic coins we have particles and we can entangle these particles in practice we create entanglement by using photons, individual particles of light, and then these photons can become entangled, and this is how we distribute entanglement between the different nodes in our network. And like I mentioned, you know, these are some really strange correlations that you can't achieve classically. I mean, even Einstein thought that this was really odd. He called it spooky action at a distance. And then the core thing here is that in quantum networks, entanglement Entanglement is this fundamental shared resource that you create that enables all of these different protocols like quantum teleportation. So now that I hope you have a little bit of an idea of what entanglement is, let's go over how you can use entanglement for quantum teleportation so that we can solve this problem of sending our state from Alice to Bob. So here, right, again, the problem is we have this qubit that I'm showing here as a coin and it's in a superposition, so you could say it's in between both zero and one at the same time, which I'm showing by having it be both heads and tails at the same time. And Alice wants to send this qubit to Bob, and remember, we can't just send it through the channel because it might get lost and we can't make copies. So the first thing that needs to happen is Alice and Bob need to create entanglement. So Alice and Bob create their entanglement, and now they have their entangled pair. Alice has one entangled qubit, and Bob has the other. Then Alice is going to perform some local operations to connect the qubit that she wants to transfer to the entangled qubit. This would be in the form of quantum gates, but we don't really need to fully understand that right now. So now Alice's qubit that she wants to transfer is connected to this entangled qubit. Then Alice is going to measure these or observe them. This is just like, in this case, it would be like flipping the coins. So Alice is going to flip her coins, and she gets two heads. And when Alice flips her coins or measures her qubits, you'll notice that now the state that was on Alice's qubit has already been transferred to Bob. But we see that this isn't exactly what we wanted, right? It's been flipped, which I'm showing by having it be upside down. So we've almost completed teleportation, but the state that Bob has received, you know, it's a little bit messed up. You could also think of this kind of similar to maybe bit flips in classical computing. But we can fix this if Alice just sends her measurement results to Bob. This gives Bob the information that he needs in order to flip his state and apply these corrections. So Bob can apply those corrections, and now he has recovered the initial state that Alice had. So we've been able to teleport this state from Alice to Bob without ever having to send it through the channel. So again, the reason this works and the advantage here is this entanglement is a pre-shared resource. We create entanglement before we ever need to send the qubit. So if entanglement gets lost, we can just create it again, and we still have the qubit on Alice safe and sound. So the qubit never actually has to travel through the network. The only thing that travels through the network is these two classical bits. So now that we've seen teleportation, and I hope I've given you a little bit of an intuition for it, let's look at how you can actually code quantum teleportation in Python. So of course we're going to need some Python tools. We use NetChasm. This is a Python software development kit for writing quantum network applications. And we're also going to need Squidasm. Squidasm is a quantum network simulator that allows you to run programs on a simulated quantum network. And of course we need a simulator because not everybody can access a quantum computer just yet. So now I'm going to go into a coding demo. So here, this demo file is going to be made available to you through a GitHub link at the end of the talk. It's also in the pre-talks where I have the skeleton file and also the filled out version so you can check it out yourself. So the first thing that I want to do is just go through the skeleton code here. So right here at the top, of course, like I just mentioned, we need to import all of our libraries. We have the NetChasm software development kit for writing our quantum programs. And we have Squidasm for actually simulating our quantum network. Then I have a couple of utility classes and functions. This teleport params just stores some information about what the state is that we want to teleport. And this print function just allows us to print our quantum states on the terminal in a readable format. So you don't really need to worry too much about those. Then going into the meat of the program, into the file, we have our two programs. We have our sender program and receiver program. This is where we actually implement the code for the sender and the receiver. So we, you know, in the sender, we need to, you know, read these teleportation parameters for the initial state we want to teleport. We have some metadata. This just gives the programs or the simulator some information about what resources we're going to need, like we're going to need two qubits, we need a socket to create entanglement, and we need a classical socket for classical communication. And then you would actually implement the, we're actually going to implement the protocol here in the run method. The receiver program is pretty much the exact same as the sender, it follows the same boilerplate. And then in the main function is where we actually set up the simulator to run the code. So the first thing that we need to do is create our quantum network. Here we just create a very simple one with two nodes, our sender and our receiver. And you can, in practice, you can do all sorts configuration here with different noise models and different latencies. But here we just include a one millisecond classical communication delay. Then we need to, of course, create the state that we want to teleport. We need to create the programs for each node. We've enabled logging so that we can have a little bit more of an in-depth view of what's going on so we can see the protocol in action, and then we actually run the simulation with our network configuration, our two programs, we get the results, and we print them out in order to be able to see is the state we teleported the state that we received. So now that we understand the boilerplate a little bit, let's get into actually coding the protocol. So again, that's going to be in the run method. Here we're going to start with the sender. The first thing that happens in the run method is already done for us. We have a classical socket for sending classical communication. I think this is something you're all familiar with. Similarly, we have an entanglement socket for creating entanglement. And then we have something called the net chasm connection. This is the connection to the quantum hardware. So for example, here in our two-node quantum network, we have Alice and Bob, where Alice would be one of our quantum network nodes. The host here in this box signifies everything that happens classically. So this could be like your laptop, for example, where you have your classical sockets, you write the code to create your qubits and your entanglement sockets, and then the net chasm connection is what connects your classical computer, like your laptop, to the quantum network processor. This is the quantum device. So every time we want to execute our quantum code, we send it over the net chasm connection to the quantum network processing unit. This is very similar to if you do GPU programming, where you send the code, instead of executing on the CPU, you execute it on the GPU. But here, we execute it on the quantum processor. So going in to actually code the protocol, the first thing that we need to do is create the qubit that we want to send. So we're going to call this local qubit, and we're going to initialize it using the net chasm connection. Then we want to set this qubit to the initial state. This is just based off of the parameters that we passed in before. So you don't need to fully understand this part, but if you're curious, I recommend checking out on QTech Academy. We have free lecture courses and videos that you can audit for free, and that's a great resource to learn more about quantum information and quantum networks. And I'll have a link in the slides later so that you can access that. So now that we've created our local qubit, there's one more thing we need to do. We need to do something called flushing the net chasm connection. And so what this net chasm connection flush does is it takes all the quantum code from before, so creating our local qubit and preparing it in a state. It compiles it and sends it to the quantum processor via the net chasm connection. So we wrote our code here, and then NetChasm flush sends it through the NetChasm connection to be executed on the quantum network processor, and we yield from it because we want to wait to receive the results. So now that we've created the qubit, the next step is to create entanglement, so we're going to call this our entangled qubit. And so for this, we're going to need to use our entanglement socket. Here we call create and keep, and since we just want the first qubit, we take the zeroth element of the list, the first element of the list. Here we call create and keep. This kind of follows classical networking protocols where you have a sender and a receiver, so one party would send a message, the other receives. Similarly, when we create entanglement, one party is the creator of the entanglement and the other is the receiver. So when we go and code the receiver, we'll see receive and keep. And then once again we need to yield from this net chasm connection, flush the connection so our quantum code gets executed. And let's go ahead and add a log statement so that we can see what's happening. So now we have created entanglement with the receiver. Then the next step is we need to perform these local operations. We need to connect our local qubit to our entangled qubit. So we're going to do that by doing what's called a CNOT gate between the local qubit and the entangled qubit. And then we need to do a Hadamard gate on our local qubit. And again, it's okay to not fully understand what these gates mean. And if you want to learn more, I highly recommend checking out the reference material that we provided later. Unfortunately, we don't have quite enough time to go into all the details. So now that we've done our gates, we need to measure them. So we can store our first measurement result in M1, and we can measure our local qubit. Then we can measure the entangled qubit and store that in M2. And then let's go ahead and you need to remember to flush the connection so that our quantum code gets executed. And then let's go ahead and add a log statement so we can see what these measurement results were. We measured local and entangled qubits and print out M1 and M2. And then the last step of the sender protocol is we need to actually go ahead and send these corrections over to the receiver. So we can do this via our classical socket. So we can do a classical socket and we're just sending some integers, we can send m1, and then we send m2. So that's it for the sender protocol, now we just need to implement the receiver protocol. And actually before I do that, let's just add one more log statement to say that we've sent them. We can say sent corrections to the receiver. Great. So now if we go ahead to implement the receiver, again, it follows a very similar pattern. We're at the beginning. We need our classical socket for classical communication, entanglement socket for creating entanglement, and this net chasm connection so that we can actually execute our code on the quantum network processor. So the first thing that the receiver needs to do is create entanglement. So again we're going to call this our entangled qubit and this is going to be entanglement socket and now you see that since we're the receiver, we're calling receive and keep. Then we need to flush the connection again. And so now we've created entanglement with the sender. So let's go ahead and add another log statement. So we've created entanglement with sender. And then the very last step to complete the protocol is now we need to receive these corrections from the sender and apply them. So first we need to receive M1, and we're going to do this by reading from our classical socket. So we call receive int, and then same thing for reading m2, and then based on these corrections that we received, we might need to apply some quantum gates. So if m1 is equal to 1, we need to apply a z gate to our entangled qubit. This is a phase flip correction. And then if M2 equals 1, we need to apply an X gate to our entangled qubit. And this is a bit flip correction. Similar to how maybe in classical networking, if there are some errors, you might need to apply some bitwise operators in order to fix them. Then of course we need to flush the connection in order to make sure our quantum code gets executed. And then let's add one more log statement to say that we've finished the quantum teleportation protocol. So completed quantum teleportation. Great. So now we've done all the code to implement the protocol. We can go ahead and see if it runs. Recall that the state that we're teleporting is the plus state. And for those of you that are unfamiliar, the plus state is just an even mix. being both 0 and 1 at the same time. It's kind of like that both heads and tails coin that we saw in the example. So now if we go ahead and run. Quantum teleportation demo. And we look here at the state we wanted to teleport. Wanted to teleport plus. And we receive plus. So we see that it worked, which is great. It means we did everything right. And of course, we can also go through the logs to see exactly what's happening. We create entanglement with the receiver. The receiver creates entanglement with the sender. Then the sender needs to measure the local entangled qubits, sends those corrections to the receiver, and then we've done it. We've completed quantum teleportation. We've done it. We saw that That took maybe 30 or 40 lines of Python code. It's as easy as that. So now we can get back to finishing up the talk. So this is actually, like I mentioned, this is something that you can try yourself and get involved with yourself. So here's a link to the repository with that example code, and I'll also have a link at at the very end of the slides. And it's also on the website as well. You can also learn a little bit more about these Python libraries from the Squidasm docs. This has all the documentation for how you can set up the simulator and configure your networks if you want to have networks with more nodes or different noise types or different delays. And as I mentioned, you can learn more about quantum information and quantum networking from QTech Academy. They have courses and videos that you can audit for free. Now, as we're starting to wrap up a little bit, and you've seen how you can actually program this and run quantum teleportation, I want to give you a little bit of a taste of what is the state of the art, what's going on in research and quantum networks right now. So of course, there are many open problems in quantum networks. It's a very active research area. And in our group at QuTech, we're researching many different aspects of quantum networks. We're looking into quantum network applications. This is trying to discover, you know, what are some ways that we can use entanglement and these correlations that it produces in order to unlock capabilities that aren't possible classically. One recent work that we've done there is it turns out for load balancing in classical networks, If your load balancers share entanglement, then they can use those correlations to make better load balancing decisions without having to send classical messages back and forth. Another thing that we're really interested in is how can we make these quantum network nodes kind of universal and easy to program so that they're not tied to one specific physical hardware. so that you can, you know, as a non-physicist, you can just write one quantum network program and run it on different types of physical quantum hardwares, whether it be nitrogen vacancy centers in diamond or trapped ions. You just write one Python program and it runs everywhere. And to this end, we've created QNodeOS. This is the first operating system for quantum network nodes, and it allows you to write quantum network programs in Python and then actually execute them on real quantum hardware. And lastly, I want to highlight, as mentioned, my work is on benchmarking these quantum devices. So coming up with what is a good way to evaluate quantum network nodes, what are the performance metrics that we care about, and how can we identify the bottlenecks so we know what needs to be improved. And I also want to highlight that, you know, this is an active research area, but this isn't just for scientists and PhDs. You can get involved yourself through the Quantum Internet Alliance. We offer hackathons and different community events that you can find out through their website. Again, highlighting QTech Academy and these free online courses that you can audit to learn more, to learn the basics, and there's some really great lectures there. And then you can also get involved with just playing around with this on your own and coding your own quantum network applications using our different quantum network simulators, like Squidasm. So with that, that brings us to the end of the talk. I just want to briefly highlight again everything that we've touched. So we've seen that quantum networks allow us to connect quantum devices, enabling these new applications, for example, blind quantum computing, enabling us to run a quantum computation on a server without ever learning what our computation was. We also saw that this, you know, it's not purely science fiction. This is real and happening now. The Quantum Internet Alliance is currently working to build a real quantum internet. Then you saw the most fundamental quantum network protocol, quantum teleportation, and how we can transfer quantum information from one node in a network to another without ever actually having to send it through that noisy channel and we don't have to worry about losing it. Then you saw how easy it is to program teleportation in Python, knowing just 30 or 40 lines of code and now you have everything that you need in order to be able to learn more and try it yourself at home. So with that, I'd like to thank you for listening, here are all the QR codes to the different resources that I mentioned during the talk and I'd like to open the floor to questions.

Speaker 2 [33:02]

Thank you so much, Samuel, for a wonderful talk and an introduction into using Python and quantum computing. There are plenty of questions, but if you would like to sign up and ask your own question, go to talks.pycon.de and leave your question there. So we'll start with the popular questions, so there are some upwards. So one of the things is, how big is the quantum network now? What is already sent over it?

Speaker 1 [33:30]

Okay. Yeah. So in terms of quantum networks that currently exist in the real world, most of them are in, you know, lab settings or are in maybe citywide scale consisting of maybe, you know, three, four, five different nodes in a network. And so they're over distances of, you know, maybe 20, 30, 40, 50 kilometers. So short distances, relatively small networks right now. And then And in the coming years, like, for example, like I mentioned with the Quantum Internet Alliance, we're working on building larger networks that are also not just in a lab setting, but are, like, fully programmable. And so, like, in this case, you know, we're looking to build networks over longer distances, you know, hundreds of kilometers. And then the information that is currently sent over quantum networks is, you know, these quantum bits or qubits, and the way that they're...the physical medium that they're actually encoded in would be in photons so you would encode your quantum bits in for example the polarization of your photons

Speaker 2 [34:38]

So the second question is, how is entanglement created? Does it mean that as soon as entanglement is created, transferring information does not require any kind of physical connection anymore?

Speaker 1 [34:51]

That is an excellent question. So, right, I want to, so yes, the way that you create entanglement, one of the common ways that we do this in quantum networks is you have your two nodes, and then in between them you have something called a heralding station. And so your two nodes would send photons through this network to this kind of center point. it will measure these photons and then this can create entanglement on your yeah on the two nodes and the second part of that question is a really good one does this mean that you right do you still need some sort of classical connection the answer is yes you do as we saw in quantum teleportation we still need to send those two classical bits of information so you cannot communicate faster than light with entanglement, which makes sense. We're still obeying the laws of physics. So you still need some sort of... Yeah, if you want to teleport, you still need this classical information to be sent, but the correlations that you can produce do not necessarily require additional classical information to be sent. Like in this load balancing example I mentioned, there if your nodes share entanglement, they can just measure it and use those correlations to balance load in a network without having to exchange any more classical information.

Speaker 2 [36:17]

There's a lot of questions so I'm gonna go through what's most popular and I'm gonna pick a few and we'll see how many we can get through. So one more is in your example the entanglement was lost after the data was transferred is this analogous to snipping the fiber between Alice and Bob? In practice or maybe in future how difficult are these entangled states to recreate between two locations? Does this place limits of the throughput or expense of data transfer between quantum nodes?

Speaker 1 [36:49]

Okay, so I think the first part of that question is what I'm going to start by addressing is when I showed in this diagram, after you measured the entanglement, this connection was gone. And so this is a really good point to highlight. When you measure entanglement, it's a finite resource. So once you measure it, it's used up. So the reason that that link between them disappeared is because once you measure it, the entanglement is destroyed, so to speak. So if you want to teleport another qubit, you need to create entanglement again.

Speaker 2 [37:25]

Can the entanglement channel be switched, routed like classical networks, or is it exclusively B2B?

Speaker 1 [37:32]

Yeah, so indeed, this is also a very active area of research in terms of how do you route entanglement in quantum networks. And so, yeah, so that's a very active research area. Can you repeat the question again? Oh, sorry.

Speaker 2 [37:50]

Okay, I'm lost. Give me a second. Yeah, can the entanglement channel be switched or routed like classical networks?

Speaker 1 [37:59]

Okay, so additionally, when you're creating entanglement and sending these photons, you

Speaker 2 [37:59]

Okay.

Speaker 1 [38:08]

actually can do this in fiber, just like in classical networks. And so then the same kind of things that you do in classical networks, where you have this routing or you have multiple signals being sent through the same fiber, you can also do that in quantum networks as well.

Speaker 2 [38:29]

Okay, doesn't this entanglement during transfer of qubits create a large computing overhead? Are there ways to mitigate it?

Speaker 1 [38:45]

Does the transfer of entanglement cause a large computing overhead? So in terms of simulating it, like we saw with the simulator, simulating quantum computing and quantum networks, that is very difficult because it grows exponentially as the number of qubits you have increases linearly. But in terms of when you're running quantum computations, since this is the native operations that you're doing, creating entanglement and measuring it, it's only as expensive as how long it takes to create entanglement.

Speaker 2 [39:29]

I'm going to do two last questions, and then we can close the question session. You can talk to Samuel later, and there's also, you can go on to pre-talks and access the demo and the materials, leave feedback on the talks, et cetera. So one more question. What is an EPR socket?

Speaker 1 [39:48]

Okay, yep. So an EPR socket is just analogous to a, you know, a classical socket in classical networking. An EPR socket is what connects your two quantum network, or yeah, enables you to connect your two quantum network nodes and create entanglement between them. It's just a, you know, software abstraction, similar to how a classical socket is a software abstraction.

Speaker 2 [40:12]

Okay one last question. As far as I have understood quantum entanglement there have already been proven examples where qubits were measured in space and the entanglement worked on the ground. What kind of limitations are there in the real world for the distance of a network?

Speaker 1 [40:36]

Yeah, that's a another really good question. So the the distance between your nodes in a quantum network and the challenges that that creates partially depends on how you're sending your quantum information so in the question or you talked about satellites and creating entanglement in space and Sharing it between here on earth. So there you would be typically sending your creating entanglement and sending your photons through free space. As I also mentioned, we can do this using some of the same things we do in classical networks, where you send your quantum information, your photons, through classical fibers, and the error that you see differs depending on what medium you're using. So I believe that when you're sending entanglement over free space there's like a polynomial decay and when you're sending entanglement through fiber you see an exponential decay and so depending on the medium it kind of differs how difficult it is to create entanglement but it is a good point because entanglement is something that's difficult to create and as you scale the distances up it becomes more difficult.

Speaker 2 [41:55]

With that, let's thank Samuel again for a really nice talk and for answering all your questions. That concludes this session, so have a nice lunch and the rest of the day. Thank you.