SimulaQron - a simulator for developing quantum internet software
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 490 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/47360 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | |
| Genre |
FOSDEM 2020445 / 490
4
7
9
10
14
15
16
25
26
29
31
33
34
35
37
40
41
42
43
45
46
47
50
51
52
53
54
58
60
64
65
66
67
70
71
72
74
75
76
77
78
82
83
84
86
89
90
93
94
95
96
98
100
101
105
106
109
110
116
118
123
124
130
135
137
141
142
144
146
151
154
157
159
164
166
167
169
172
174
178
182
184
185
186
187
189
190
191
192
193
194
195
200
202
203
204
205
206
207
208
211
212
214
218
222
225
228
230
232
233
235
236
240
242
244
249
250
251
253
254
258
261
262
266
267
268
271
273
274
275
278
280
281
282
283
284
285
286
288
289
290
291
293
295
296
297
298
301
302
303
305
306
307
310
311
315
317
318
319
328
333
350
353
354
356
359
360
361
370
372
373
374
375
379
380
381
383
385
386
387
388
391
393
394
395
397
398
399
401
409
410
411
414
420
421
422
423
424
425
427
429
430
434
438
439
444
449
450
454
457
458
459
460
461
464
465
466
468
469
470
471
472
480
484
486
487
489
490
00:00
InternetworkingSoftwareQuantumComputer networkQuantum channelQuantumSoftwareInternetworkingQuantum channelQuantum computerComputer simulationSoftware developerProjective planeFocus (optics)Set (mathematics)QubitQuantum entanglementRevision controlInformationstheorieOpen sourceMereologyMoment (mathematics)TrailComputer animation
02:56
Quantum channelQuantumComputer networkLink (knot theory)SoftwareCartesian coordinate systemMeasurementDistancePerfect groupQuantumPoint (geometry)Classical physicsComputer animation
03:51
Secret sharingHeat transferDistribution (mathematics)QuantumZeitsynchronisationComputer networkQuantum entanglementQuantum information scienceQuantum channelInternetworkingData transmissionLink (knot theory)Stack (abstract data type)Computer hardwareQuantum entanglementSoftwareAbstractionComputer programComputer hardwareQuantumLocal ringSemiconductor memoryQubitCartesian coordinate systemLink (knot theory)Operator (mathematics)Message passingInterface (computing)Operating systemScheduling (computing)Logic gateDifferent (Kate Ryan album)Pairwise comparisonWeb serviceDevice driverOSI modelInternetworkingStack (abstract data type)Expandierender GraphSynchronizationMusical ensembleAtomic numberTelecommunicationCommunications protocolRhombusFunctional (mathematics)Classical physicsKey (cryptography)CASE <Informatik>Computer animation
08:05
Computer hardwareSoftwareCartesian coordinate systemInterface (computing)Computer animation
08:30
Computer hardwareQuantumInternetworkingSimulationQuantumRevision controlLibrary (computing)Cartesian coordinate systemOrder (biology)Formal languageDiscrete groupImplementationLogic gateMoment (mathematics)Computer simulationComputer programComputer hardwareSet (mathematics)LogicPerfect groupMemory managementTelecommunicationOpen setBinary fileJava appletEvent horizonSoftwareInterface (computing)Classical physicsSimulationComputer animation
12:46
Virtual realityQuiltVertex (graph theory)QuantumPopulation densityMatrix (mathematics)Vector graphicsStability theoryRevision controlPopulation densityNumberComputer simulationFront and back endsFormal grammarVirtualizationQuantum entanglementComputerQubitQuantumData miningModul <Datentyp>SoftwareImplementationTelecommunicationPointer (computer programming)Computer animation
14:47
Density matrixStability theoryScaling (geometry)NumberQubitMeasurementFormal grammarCartesian coordinate systemMultiplication signDifferent (Kate Ryan album)Pairwise comparisonComputer animationDiagram
15:22
Virtual realityComputer animation
16:33
Revision controlDemonComputer networkWebsiteHyperlinkInterface (computing)String (computer science)Point (geometry)Interface (computing)Computer animation
17:00
Letterpress printingRevision controlComputer networkVertex (graph theory)SimulationMathematicsParameter (computer programming)Message passingComputer configurationInterface (computing)Einstein-Podolsky-Rosen-ParadoxQubitStability theoryFront and back endsComputer animation
17:27
Computer fileEinstein-Podolsky-Rosen-ParadoxMessage passingComputer configurationFormal grammarStability theoryComputer animation
17:55
Message passingComputer networkComputer configurationWebsiteHost Identity ProtocolQuantumSimulationMenu (computing)Wechselseitige InformationHill differential equationConvex hullInclusion mapIntegerInternetworkingQuiltVector potentialLemma (mathematics)Normed vector spaceLocal ringQuantensimulatorComputerState of matterAddress spaceSoftwareConfiguration spaceComputer fileComputer animationSource code
18:22
Computer networkTopologyVertex (graph theory)Connected spaceGraph (mathematics)Equals signRandom numberDefault (computer science)Network socketIP addressComputer fileDefault (computer science)Network topologyNumberComputer animation
19:06
Message passingComputer configurationComputer networkWebsiteDefault (computer science)Default (computer science)Configuration spaceComputer animation
19:42
Inclusion mapSimulationMessage passingCartesian coordinate systemCASE <Informatik>Computer animation
20:09
Computer networkDefault (computer science)WebsiteData typeInteractive televisionConnected spaceLevel (video gaming)QubitTouchscreenCASE <Informatik>Computer animation
20:55
Default (computer science)Computer networkWebsiteData typeComputer-generated imageryQubitConnected spaceOperator (mathematics)CASE <Informatik>Computer animation
21:19
WebsiteComputer networkDefault (computer science)Data typeMessage passingHadamard matrixPoint (geometry)Computer animation
21:48
Gastropod shellWindowComputerComputer animation
22:16
Data typeDefault (computer science)Computer fileGoodness of fitTimestampDirection (geometry)FlagQubitSystem callQuantum entanglementCASE <Informatik>SoftwareInformationStack (abstract data type)Different (Kate Ryan album)Queue (abstract data type)Computer animation
24:15
Multiplication signGoodness of fitDirection (geometry)FlagTopologyComputer networkQuiltClassical physicsQubitMessage passingWhiteboardComputer animationEngineering drawing
24:40
TimestampGoodness of fitDirection (geometry)FlagMeasurementQubitMessage passingWhiteboardMultiplication signComputer animation
26:21
Software testingEinstein-Podolsky-Rosen-ParadoxRadical (chemistry)Scripting languageFront and back endsConnected spaceContext awarenessQubitComputer animation
27:03
Configuration spaceSoftware testingMeasurementCartesian coordinate systemScripting languageProcess (computing)MeasurementComputer animation
27:29
MeasurementMatrix (mathematics)QuantumSimulationVertex (graph theory)Population densityVirtual realitySoftwareLocal ringGrundlagen der MathematikComputerLogic gateQubitMultiplication signRhombusCartesian coordinate systemBuildingCodeQuantumQuantum computerState of matterFormal languageSoftwareLibrary (computing)Computer animation
30:16
FacebookPoint cloudOpen source
Transcript: English(auto-generated)
00:05
All right, everyone. I'd like to introduce our next speaker, Axel. Axel's currently doing a PhD in quantum information theory with a focus on quantum networks at Q-Tech in Delft. And that basically means that he's developing
00:21
the tomorrow's or the future version of the internet, which would be a quantum internet. And he's an active developer on the quantum open source project, Simulacron, which he's going to talk about, but also Q-Elk and CQC Python. And he gave a talk at last year's FOSTERN, and today he's going to talk about this project Simulacron,
00:42
a simulator for developing quantum internet software. So please welcome Axel. Thank you. It's really great to be back here. As mentioned, I was here last year. And it's really nice to be back
01:01
because last year I got really motivated on making Simulacron, which I'm gonna present, better and easier to use. So since then, there's a lot of things that happened. For example, it's much more easy to install. It's now a package on PyPy, and there's a command line interface, so it's very easy to use,
01:20
which I will show later in this talk. And maybe as Mark mentioned, one should not apologize in a talk, but I should maybe apologize because this track is called quantum computing, and I won't talk about quantum computing. I'll talk about quantum networks. And this is joint work with my professor, Stephanie Vayner.
01:42
Is there some feedback? It's okay. Maybe I shouldn't talk too loud. Yeah, so let's get started. So as mentioned, I'm in QTEC in Delft. That's my last year in my PhD. And we're also part of the quantum internet alliance
02:01
in Europe, KIA. So in Delft, we're trying to build a quantum network. And maybe just to get a feeling for, it's very, should I, is it okay?
02:22
Or should I, I have a question. Yeah. Just to get a feeling for who's in the audience, who ever heard about the notion of a quantum network before? A few. Okay, that's excellent. Then I can maybe, by the end of this talk, we will have a lot more that knows about quantum networks. So in a very simple picture,
02:41
a quantum network is essentially a set of small quantum computers connected by quantum channels. So they can exchange qubits and they can generate entanglement between each other. And at QTEC, we're not only thinking about this sort of theoretically, but we're actually building such a network at the moment in the Netherlands between four cities.
03:01
So between Delft, Leiden, The Hague, and Amsterdam. And we currently have essentially a link between Delft and The Hague, and we're starting to testing it now. Essentially a measurement point in Driesweig, which is between Delft and The Hague. And this is a distance of roughly 25 kilometers. And then we will extend this to have a link to Amsterdam,
03:23
which is roughly 50 kilometers. So this is coming up. So you might ask, okay, why do we wanna build a quantum network? Why is this interesting? And the reason, of course, is that we can do a lot of cool things if we have such a network. There are a lot of applications for a quantum network.
03:41
And is there anyone that, for example, knows one application that you can run on a quantum network, which you can't do on a classical network? Perfect. So the most famous is, of course, quantum key distribution, which is very nice to have being able to generate key, which you can use for secure communication. But this is not the only one.
04:01
There's a lot of other things that you can, for example, have better synchronization of clocks. You can extend the baseline of telescopes. You can do blind quantum computation, and a lot more things, like secret sharing, anonymous transfer, and so on. And for essentially all of these things, what we need is entanglements.
04:23
And this is basically the fundamental operation that a quantum network enables you to do. So maybe in comparison to a classical network, where essentially the fundamental operation is to send a classical message from one node to another, you might then think that, okay,
04:41
in a quantum network, the fundamental operation is to send a qubit from one node to another. But in our view, this is not really the case. So here the fundamental operation is to generate entanglements. And the reason being that you can use this entanglement to send qubits using teleportation.
05:03
Now, we don't wanna just build a quantum network, a small quantum network, but we wanna go further. So we wanna have a scalable design and be able to have essentially a quantum internet in the end. And furthermore, we don't want this to be essentially a large, hard-coded experiment,
05:21
but this should be a universally programmable network where you can run any application you want, and it's essentially a service provided for anyone that wants to run an application. But for this, we need a lot of things to help you abstract, for example, the hardware away.
05:41
So you shouldn't have to think about how do we encode qubits, how do we generate entanglements, all these things. So one thing that we need is, for example, a quantum network stack, similarly to, for example, TCPIP in the classical network that abstracts certain functionalities away for you.
06:01
And we have a proposal for such a quantum network stack and also protocols for, so a link layer protocol and a network layer protocol, network layer protocol, that generates entanglements in the link layer protocol between nodes that are directly connected, and the network layer protocol generates entanglements
06:20
between nodes that are not directly connected in the network. Now, a network stack is not the only thing you need that connects, essentially, an application and the hardware, because you also wanna do, for example, gates, local gates on your nodes. And for this, we need, essentially, a full-fledged operating system between an application and hardware
06:42
that enables you to generate entanglements to local gates, to scheduling of applications, to memory management, et cetera, et cetera. And what this does, it enables you to do, is to, you as a programmer that wants to write some application, you don't need to think about what is actually the hardware in this network and how it's physically implemented.
07:02
So, the hardware might be nitrogen vacancies in diamonds or ion traps or atomic ensembles or whatever. You don't need to know about this. And in a more expanded picture, essentially, we envision that the, we call it the QNodeOS,
07:20
so the quantum node operating system, essentially has different, you could call it drivers for different hardware. So, it has a hardware abstraction layer for, for example, these Envy centers or ion traps, which is specific to that hardware. So, that's maybe very nice, but then you might think, okay,
07:40
I wanna write one of these applications. How do I then communicate with this operating system? And this is where CQC comes in, and this is an interface that we defined. It stands for the classical quantum combiner, CQC. And this specifies essentially what instructions should an application send to the QNodeOS
08:02
to specify what it wants to do. And our goal is not only to have this in an abstract world in simulation, but the network we are building should be compatible with this CQC interface. So, you as a user, perhaps,
08:22
could write an application on your own, and then communicate with this network using CQC. CQC is essentially an instruction set. We defined a set of instructions encoded in some binary formats.
08:42
So, it's not really meant to be used directly, but we written, essentially, libraries which enables you to write an application that's in a more easy way that essentially then creates these CQC instructions for you.
09:00
So, for example, we have one which is maybe the most easy to use, one library in Python where you can write your applications. They send out CQC instructions. But CQC is essentially, it's both hardware-independent, but it's also language-independent. So, we also have, oh, I should, maybe it was a wrong order here.
09:22
So, you might wonder, okay, I wanna write one of these applications today, but we don't have this network yet, and this is exactly where Simulacrons comes in. So, it's a replacement for now until we have the actual hardware to write these applications,
09:41
and it can understand this CQC interface. So, you can already now today write your application using this Python library. It sends out CQC instructions and sends these to Simulacron. But we also have libraries, for example, in C, in Rust,
10:02
and what's nice with this is that we can have essentially a community, so people can develop their own libraries in possible other languages. So, there's also now actually an implementation in Java from Johan Voss at Glue on HQ, which is an open pull request at the moment for their simulator, Strange.
10:23
There was also an implementation in Go during one of our hackathons we organized. I'm not sure it was fully finished. I don't know exact status of this, but I think it's somewhere out there. But if you have another favorite language and you wanna write your library, that's really great.
10:43
So, not only can CQC talk to Simulacron, but it can also talk to other simulators which understands CQC. So, at Qtec, we also have a different simulator which is called NetSquid, which is actually a discrete event simulator for quantum networks.
11:01
And maybe some of you heard about, for example, NS3 for classical networks, which also does a discrete event simulation. And this is the world's first discrete event simulator for quantum networks, and it's hopefully gonna be released in the coming months and is currently in beta. But, of course, as I mentioned,
11:21
in the future when we have hardware, you should also be able to communicate with the hardware using CQC. So, you can already today write your application in one of these languages, and without much change, when we have the hardware, you can then run your application on this hardware.
11:42
So, I'm saying without much change, because we have not maybe found the perfect version of CQC. It's currently in version two. We're working on version three at the moment, which has some more improvements in, for example, memory management and how you can maybe do classical logic
12:02
in your program. So, maybe more about Simulacron. So, what's cool about Simulacron is not only that it understands CQC, but it's actually a distributed simulation. So, I can install it on my laptop, you can install it on your laptops,
12:21
and we can together simulate a quantum network using classical communication in the background. So, we can set up a network like this on maybe three computers. We all run our own application that specifies certain gates or generates entanglements,
12:40
and then we can simulate this together. So, you might then wonder, okay, we have a quantum network, so there should be entanglements between our laptops, but these are classical computers, so how can we have entanglements in such a network? And what we essentially do is we simulate this with classical communication
13:00
between our computers that essentially simulates the entanglements, and this works in a way such that any qubits that are entangled will be simulated on the computer. So, if I have one of our computers, we might not know which one, but if I have a simulator on my laptop,
13:21
you have a qubit simulator on your laptop, and they get entangled, one of them will move to either mine or to yours, and stay in a combined state, and this is where the classical communication comes in. I won't go too much into the detail of this, but if you're interested, you can look more in the documentation, where we essentially have the notion of
13:41
virtual qubits, which are essentially pointers to the actual simulated qubits, which might live on another node in the network. And we try to develop this in a kind of modular way, so the way we represent qubits are kind of detached
14:00
from this distributed simulation, so we have different implementations of how we actually represent these qubits, so the first backend we used was using full density matrices, actually using Qtip, and if you're more interested in Qtip, there will be a talk, I think the next or the one after, by Boxy.
14:22
We also have backends, essentially using KETs or vectors, which is using ProteqQ, and we have our own version of stabilizer formalism, which is of course, you can simulate efficiently in the number of qubits.
14:41
And we can kind of see the implication of choosing which formalism you want to simulate, by looking at this graph, so here's the generated GZ state, which is kind of a large centennial state, and you measure it, and on the y-axis we have how much time it takes. You can clearly see that
15:02
both density matrices and KETs have an exponential scaling in the number of qubits, while it's maybe hard to see, it looks kind of flat, the stabilizer formalism is essentially cubic in the number of qubits. And I should say this is not a comparison of different simulators, it's purely about which formalism
15:20
you use. Yes, okay, so I thought I would give a demo, this is maybe, let's see if this was a stupid idea or not, if everything goes wrong, then at least I tried, but okay, so let me see if I can bring up my terminal,
15:54
okay, is this visible in the back? Let me know otherwise.
16:01
So, to get started, I want to show you everything from scratch, so I will make a fresh virtual environment in Python, and just as an unrelated side note, if you ever struggled with virtual environments in Python,
16:21
check out my tool, which I call Manven, which is very nice to create temporary virtual environments. But first we make a temporary virtual environment, so now we're completely fresh, we don't have essentially many packages installed here, so this is how you get started,
16:41
and let's now pip install Simulacron. So, it will pull down some packages, and one of these packages it actually uses is CQC, which is this interface that we can communicate with Simulacron. So now we have Simulacron, let's clear this,
17:01
and we can then use our command line tool, so you can just run Simulacron, it has a few commands, it's quite simple, what it can do, for example, is to look at settings, so there are a few different settings, for example, how many qubits should each node have,
17:22
for example, which backend do we want to use, so by default, the backend is stabilizer formalism, but we can see, for example, we can choose stabilizer formalism predictQ or qtip.
17:42
Let's see, how am I doing on time? So, another thing we can see is we can specify a network configuration file that describes how does the network we want to simulate
18:01
look like, essentially, what's the addresses of the nodes, what's the topology, and I can show you an example of how this looks like, it's basically just a JSON file, so let me go to the documentation, let me zoom in a bit,
18:25
so here is how you can configure a simulated network, let me go down to here, so here's an example of basically you write a JSON file that specifies, essentially, your IP address and port numbers of your
18:40
simulated nodes, since they can be on different computers, and you can also then specify a topology of your network, if you don't give it anything, by default it's fully connected, but otherwise you can specify, essentially, an adjacency matrix, in this case, Alice is connected to Bob,
19:01
Bob is connected to Alice and Charlie, and so on. But that's how you define your simulation, so let's now get started, so by default we will have five nodes, you can see this by doing nodes, and they get the nodes
19:21
in the network, so we have Alice, Bob, Charlie, David and Eve, fully connected, and now let's start Simulacron. So, it asks you if you want to replace your configuration file, you can force to do this, it's not relevant. So now Simulacron is started, so it's running in the background,
19:41
and maybe let me remind you of this picture, this big screen, this picture that we have here, so Simulacron acts as the backend, as the server, so it's running in the background, and we can now write our application that actually sends these CTC messages
20:02
to the simulation, in this case actually just using a TCP socket, and sending these messages. So what we can now do is to start Python in interactive mode, and we can import from CQC a CQC
20:23
connection, and a qubit. So the CQC connection enables us to connect to Simulacron, and in this case we can for example be say we're now the node Alice, so we can start one of these C connection,
20:42
and we're Alice, and I don't want to clutter my screen with a lot of debugging messages, so I set the log level to essentially only errors. So now we have a connection, and now we want to create a qubit. So we can create a qubit by essentially giving it the connection,
21:01
and the reason for this is that whenever we then do an operation on these qubits, it will use the connection to send down the instruction to the hardware, or in this case the simulation, to do the corresponding operation that we gave it. So now we have a qubit, we can for example do a Hadamard,
21:20
and as I mentioned, now a message is sent down to the backend, do a Hadamard, a Hadamard is done, and we get a reply back, okay, it's finished. How am I on time? Good? So, I think it's been 20 minutes, okay, perfect.
21:41
So, this is one node, but the point is that we now have a network, right? So let's have another node. So I open up a new pane here, but you could also think about let's think that this new window is actually on a different computer. It's a completely different process,
22:02
and since we made this Python environment, we should also activate it here, so I activated the last activated environment, this temporary environment, and we can now open Python, and then the same,
22:20
import this CPC connection, and a qubit. So, let's say that in this case now we're Bob. So we make a CPC connection, which is Bob,
22:40
and I don't want any logging. Okay, cool, so now we have Alice and Bob, and let's create an entanglement between Alice and Bob. So, on Alice we can say, create an EPR pair with Bob, and we will then get a qubit, and let's call this qubits EPR. On Bob's
23:04
side, we will also get a qubits, let's call it also EPR, these are actually different qubits, and Bob will receive great. So now we have a qubit on Alice, and a qubit on Bob. They are entangled, but they are simulated
23:22
entangled. We can also get some information about this entanglement. So, entanglement info, it, oh, let's print this. It has some information about the entanglement, so in this network stack that we are
23:41
developing, entanglement gets essentially an ID that you can use to identify who am I entangled with, and which entanglement is it, so that the nodes can agree on which entangled pair to use in the network. And we can, for example, also see who am I entangled with, so in this
24:01
lowercase here with Bob, we have a qubit entangled with Alice. And let's now use this entangled pair to teleport the qubits. So we want to teleport this qubit queue that we already have, and maybe for you who know about this, let's remind you
24:21
how you do teleportation. So, we have some bell pair, and some qubits we want to teleport. We do a CNOT and a Hada board and we measure our qubits and send classical messages to the other node to apply certain corrections. If you don't know this, it's fine. I just want to show you how it works.
24:41
So let's do this. Let's do a CNOT between the qubit we want to teleport and the EPR pair. Let's do a Hada board on the first qubit. Let's measure it and save the measurement outcome. In this case, it was zero. Let's measure the
25:01
other one. It's also zero. Okay, maybe a bit boring. It's more exciting if you had to do a correction. So these are the measurement outcomes and we now need to send these to Bob because Bob needs to do the correction. So we can do this. We can say Alice, send the classical message
25:22
to Bob with the two measurement outcomes. And what Bob can undo is to receive these classical messages and, okay, they were
25:40
both zero in this case, but for example, if one of them was one, we might have to do an X correction on the qubit of Bob. In this case, we didn't, so since the qubit we teleported was actually in the plus state, if we now
26:01
measure this qubit, we should randomly get it was zero or one. And let's measure this. Okay, it was randomly one. Of course, we all see now that it's random. Of course, you cannot see this by just doing this one time. You have to do it many times and see that it's roughly one half zero and one.
26:22
But let me maybe go to an example. So how you would actually do this is not do it directly in the terminal. You can write a script. Let's say a Python script. In this case, Alice. You open up a C connection
26:41
to the backend. You maybe generate an EPR pair in qubits and so on. And in this case, we actually open up a C connection in a context which is a Python concept. And the reason is that when you then close this connection, or when it goes out of scope, it is closed and qubits get cleared up.
27:03
But we have written these two applications for Alice and Bob, and we can now run these with this run script that essentially just puts these two processes in the background. So let's do this. Run. Okay, cool, so now we teleported once more.
27:22
Alice's measurement outcome with teleportation was again zero zero, and Bob's measurement outcome was zero. If you do this many times, zero, zero one, zero, one, okay, it's random. Cool. So that's how we use Simulacron.
27:43
And let me go back to this. So if you want to know more about Simulacron, you can go to our webpage. There's also links to the actual code and the documentation. And if you want to write your own library in some
28:00
other language that communicates with CQC, that's great. And also if you want to connect this with your simulator, that's maybe even better. And we're happy for any contribution or questions or thoughts. And with this I would like to thank you, and if there's any questions.
28:43
So the question is not for the simulation, but for the real network. So you mentioned these two ways to build a network, the IOM Connector and the other one, and which states are the network between the IOM diversity and
29:00
the other one, and which metal do you use? Yeah, so for this network that we're building in the Netherlands at the moment, this we'll use at its NV centers or nitrogen vacancies in diamonds. Because they are very nice in the sense that they have, they essentially have an electron which you can entangle with
29:20
another electron in another NV center. And around the electron there's a bunch of carbon spins which you can use to store qubits, and they have a very long coherence time. So they are nice because you can both optically entangle these qubits, but you can also store them for a long time and do gates on them. So that's why they're very interesting for this
29:40
scenario. They might not, they might be harder to scale. You might not be able to build a quantum computer with NV centers. But for many of our applications in a quantum network, we don't need many qubits and we don't need fault tolerance. We just need a handful of qubits to do a QKD for example. Yeah, yeah, yeah.
30:02
Any other questions? No? Okay, then let's thank the speaker. Thanks.