Up next in 10
How build a quantistic computer for blockchain cryptography
0 views
Jul 20, 2025
Inside the quantum track panel at NapulETH Neverlocal made an experiment building a quantistic computer for blockchain cryptography showing us the future of the next 10 years technology #quantistica #computerscience #technology #quantisticcomputer #photons #physics #napuleth #blockchain #cryptography
View Video Transcript
0:00
What happens is that this point that you
0:02
have collapses either to zero or to one.
0:06
So this cubit gets destroyed in the
0:09
process of measurement and becomes one
0:11
of these poles becomes either zero or
0:14
one. Now how does it happen? Uh this is
0:17
a probabilistic process. Basically uh
0:20
there is a probability that it will
0:21
become zero and a probability that it
0:23
will become one. Now you see that the
0:26
more this thing is close to one of the
0:28
two volts the more it's likely that it
0:31
will end up being there. So for instance
0:33
this thing is way closer to zero than to
0:35
one. So when we measured it like
0:38
probably 85% of the times a cubit is the
0:41
main computation unit of quantum
0:44
computing. So probably you know that bit
0:46
is a bit is something that is either
0:49
zero or one. A cubid instead can be any
0:53
point on that sphere which is called the
0:56
block sphere. Um so you can see that
0:59
it's not just like two things. It's a
1:01
continuum of things and entire surfaces
1:03
of possible states.
1:06
Now the most important thing is here. Um
1:10
this is also true vice versa obviously.
1:13
So if I have like something like this
1:15
thing here and I measure it along this
1:17
axis is the same. can basically destroy
1:19
the information and going up or down
1:21
meaning probability.
1:24
Okay. So this is the basis of something
1:26
called conjugate coding which is what we
1:28
are doing there.
1:31
I I am about to do that. Yes.
1:33
Yeah. So we have a little helper which
1:35
is basically formatting your transaction
1:38
right now. And as you know in blockchain
1:41
what you do is you sign the transaction.
1:44
Uh signing the transaction in literally
1:46
means signing the hash of transaction
1:49
such as that
1:50
exactly
1:51
which I've taken from ecan.
1:54
Yeah,
1:54
that thing there.
1:57
Uh do not take this one because it's if
1:59
you can go to transaction helper and
2:02
I cannot run it. No, no, I know. Just
2:04
show the code.
2:05
Oh, okay.
2:05
Um,
2:10
so
2:14
uh transaction YouTube transaction
2:17
preparer. Yes.
2:19
If you Yeah.
2:23
All right. So in here basically what you
2:26
have is you see we have from address as
2:29
a sender to address we are sending to
2:31
the zero address the value which in this
2:34
case is one ether and then we are
2:36
basically for money this transaction now
2:39
cannot run this thing because ether's rs
2:41
doesn't build on his system
2:43
unfortunately but what this thing spits
2:45
out is transaction h ash that needs to
2:48
be signed uh now I will basically give
2:53
this hash to him uh so that he can pass
2:57
it to the TE which has a secret K burned
3:01
into it. Uh and uh then we will get the
3:05
signature out from the TE.
3:09
Give me a second. Um
3:14
I'm passing this thing on WhatsApp.
3:17
WhatsApp?
3:18
Yes. Yes.
3:19
Is there?
3:23
Yes.
3:23
Yeah. Telegram. I think Telegram works
3:25
by
3:32
Okay.
3:34
So, I'm copying the hash
3:38
and I'm pasting. So, okay. I past the
3:42
hash on Telegram. It's that one.
3:46
Just Yeah. Copy. Perfect.
3:49
Okay. Okay. So, I'm going to keep it
3:50
here for safety reason.
3:53
All right. So, these is the these are
3:56
the two windows that I will use to pass.
3:59
Uh maybe a brief can I have a minute to
4:02
say what's in the box?
4:03
Uh yeah, I also passing you the row
4:06
transaction which is not signed. So, if
4:09
you put this on ether scan, uh it will
4:11
show you that the transaction is valid
4:13
but it's not signed. There is no
4:15
signature so it cannot be executed.
4:17
Why not?
4:19
because he has no secret, right?
4:22
Uh so if you go if you if you go on scan
4:27
and transaction signer,
4:31
I'll send you the Ah, it's fine.
4:38
I'm sure I can find it. This one
4:40
uh transaction
4:42
broadcast
4:44
maybe
4:44
this one
4:45
broadcast transaction. Yes, if you copy
4:48
paste the string and you or was it this?
4:52
No, this is time transaction.
4:54
Wait a second
5:01
decode.
5:04
So I just start by getting the sign
5:06
first.
5:07
Yes.
5:07
Yeah. All right. So, um, couple of
5:11
things
5:13
just, uh, just for you to know what's
5:15
effectively in the box.
5:18
And
5:19
I have the thing, by the way, this one.
5:21
Yes. What?
5:23
Okay. That's a very interesting.
5:30
Yeah. So, if you copy paste that thing
5:32
in the transaction X and you decode
5:35
Yeah.
5:36
you can see that there is no the white.
5:40
Yeah. Okay. There shouldn't be a
5:41
signature there. I think that's rather
5:43
than being calculated. Sorry.
5:45
It's okay. I will just I will just do
5:46
other things in the meantime. Uh there
5:48
there's plenty of things to So here is
5:52
the brief very brief
5:55
explanation of what's going on here.
6:02
And so
6:05
that's that's all we needed for this
6:07
demonstration. That's the packaged
6:10
contents of this box as they were uh in
6:14
London just before I put them in the
6:16
hands of some trusted couers that
6:18
brought it here safely. It turns out
6:20
quite incredibly. I didn't really uh I
6:23
didn't imagine that. That's almost all
6:25
we needed. What we really needed for
6:27
this particular project was a skilled
6:30
watch maker who spent about a month of
6:32
time going from theoretical
6:36
quantum information person doing quantum
6:38
gravity for his PhD to learning how to
6:41
do experimental quantum ponics because
6:44
apparently that's what his job is right
6:46
now. Um so that's the that's the
6:49
necessary components for this experiment
6:52
including personnel. uh he taught me how
6:55
to do it yesterday. Uh but I wouldn't
6:57
have been able to do it without
6:58
instructions honestly. Uh these are the
7:00
individual pieces. There's a photon air
7:03
source which is a big laser. In fact,
7:05
it's a small laser but it has a big pump
7:07
laser and then there's a lot of loss and
7:10
a few photons very sparse number of
7:12
photos come out of two fiber optic
7:14
cables from the front. In fact, they are
7:17
so few that we have to tape the box down
7:19
and tape it at the bottom because just
7:21
the sunlight that comes through that
7:24
little aperture in the front is enough
7:26
to drown the signal from that and make
7:29
it hard for me to run the experiment. Um
7:32
the the noise structure looks like so
7:34
that's the that's the generator of the
7:36
photos that get into the experiment. And
7:39
then there's the end of the photos.
7:42
That's where the photos start their So
7:44
here the photons start their life. Here
7:47
a brief uh few nanconds after in fact I
7:51
think picosconds after the photons end
7:54
their life they slammed against the
7:56
detectors and the detectors emit some
7:58
signal which we can record on some
8:01
microcontrollers and use to determine
8:03
whether we have seen the zero outcome,
8:06
the one outcome or we just missed the
8:08
filter. And for your information, that's
8:11
what the signals look like on
8:14
oscilloscope in our London office. The
8:17
these are just uh two of the photons. So
8:20
the two photons that come out and they
8:22
come out typically they should come out
8:25
perfectly aligned of the laser. But
8:27
because there's always photons drifting
8:29
around no matter how well we take that
8:32
there's a bunch of other signals. It's
8:34
just that they are not perfectly
8:36
aligned. They have to be timed exactly
8:38
for the detector to look at it. Uh
8:40
except the timing difference between
8:42
them. You can't really see it here but
8:45
and then the spacing is in the order of
8:47
few hundred nconds between different
8:49
pulses. The spacing between the photos
8:51
is tens of nanconds sometimes single
8:53
nonds. And so you need to have something
8:56
which has that precision to detect which
8:58
ones are actually the coincidence the
9:00
correlated pairs coming from the laser
9:02
which is the signal for the protocol and
9:04
which ones are just random photos that
9:06
come from the air and enter the box and
9:08
you don't want them because they carry
9:10
who knows what information. And what we
9:12
what you need to do is we implement a
9:14
small piece of electronic circuitry
9:17
which is called a coincidence detection.
9:19
And what it does is when the signals are
9:21
sufficiently aligned, there's a bunch of
9:23
MOSFETs and resistors that implement
9:25
effectively an end gate, but a very
9:26
short-term one. And they translate these
9:29
very short peaks, which by the way would
9:31
be too short for the uh microcontroller
9:34
to reliably detect anyway. And they
9:38
translate them into a pose that is
9:40
longer, but only comes if they are
9:43
sufficiently well timed. if they defer
9:45
by even like 20 nanconds, the pulse
9:48
doesn't come. It just gets lower very
9:50
quickly and and so this allows us in
9:52
hardware to detect coincidences before
9:56
we pass them to the microcontroller. So
9:58
one of the photos that come comes out of
10:00
the laser is
10:02
entirely wasted. It's only used for this
10:05
spanning purpose and it tells you when
10:07
to expect something in the other
10:09
detector. What is noise and what is not
10:11
noise? Without that photon, you do not
10:13
know what the which photons are the
10:15
interesting ones and which photons are
10:17
just random from the air. In fact,
10:18
there's many more random photos from the
10:21
interesting ones. And this is a
10:22
cryptographic impact because it allows
10:25
you to hide some of the error. Even if
10:27
you have a bit of error in your
10:28
protocol, as long as there's enough
10:31
turbo photons from the air, from the
10:33
light, then those will drown whatever
10:35
imperfections in your signal. You know,
10:37
because you can do the detection which
10:39
ones are the right ones. without the ver
10:41
photo.
10:43
Uh other pieces practical pieces that
10:46
photos were true. There's a visitor. The
10:48
vislitter is a way to take a photon
10:52
coming from one path. So you use we
10:55
decided to use an encoding of cubits
10:57
which is called path encoding. We use
11:00
the two fiber optic cables for each
11:02
photon. And depending on whether the
11:04
photon is in the first cable or in the
11:06
second cable, the bit encoded is zero or
11:08
one. And this is very classical. It's
11:11
just classical light. But because photos
11:13
are quantum, what you can do is you can
11:15
pass them through a a reflected cube
11:17
which has there's like a laser, a test
11:20
laser kind of this one is invisible. Um
11:23
and in this cube photons enter from one
11:25
port and they get split on both parts at
11:28
the same time with a phase in between.
11:30
So now the photon classically is on both
11:33
parts in superp position and the phase
11:35
between the parts is the thing that
11:37
encodes it. So if you try to measure
11:39
individual the two fiber optics, you
11:41
plug them into the detector without
11:43
doing this the correct measurement, you
11:45
just get 50/50 random coin flips.
11:47
Nothing interesting. If you want to
11:49
decode them, you pass them through a
11:50
second one of these which scramles them
11:52
and makes them come out of the correct
11:54
code again. So you this is a way to pick
11:56
the basis that you want to encode
11:59
information into and the code
12:00
information from. Then you have some
12:03
switches which are used to communicate
12:06
classical choices to the photons. It is
12:08
very hard. I mean photos travel really
12:10
fast speed of light which is fast. Uh
12:13
you cannot really time operations
12:15
mechanically that fast and nothing
12:18
complicated. So the best way to work
12:19
with photons and implement quantum
12:21
computations is to have fixed sets of
12:24
equipment that do different things and
12:26
have one kind of component that is fast
12:28
which is a switch. And the switch, all
12:30
the switch does is decide path one path
12:32
two, nothing else. And you have a bunch
12:34
of these switches together. And you can
12:35
use one to decide which basis, one to
12:37
decide which bit to encode. Then they go
12:40
through four different paths. Then they
12:41
get merged together and they get sent to
12:43
the destination. The destination does
12:45
the same thing. Has two switches that
12:47
decide which basis to measure in. They
12:49
go through two different paths, merge
12:50
again, and get detected. And so you have
12:52
all of these paths that are
12:54
alternatives. The photo is only in one
12:56
of them or in two of them in
12:57
superposition or in many of them in
12:59
superp position but they need to be
13:00
merged back into one and that's what
13:03
fiber mergers are for. We only need two
13:05
to one fiber mergers. So two fibers come
13:07
in they are skused fiber optic. It's a
13:10
very precise process. The photons come
13:12
into this junction and they come out of
13:14
a single fiber and this is a
13:16
polarization. All of this is
13:17
polarization maintaining because we use
13:19
polarization for part of the process.
13:22
And finally we have the stars of the
13:24
show microcontrollers. There are two of
13:26
them. One of them controls the encoding
13:30
side of things. One of them controls the
13:32
decoding side of things. In reality they
13:34
would be in different places.
13:35
Alice and Alice and but in here because
13:39
we need to do a compact demonstration.
13:41
They're in the same box. One of them
13:43
decides which basis to encode the secret
13:45
information into and which bit to
13:48
encode. and the other one decides which
13:50
basis to measure the information from
13:53
and so they are attached to the various
13:56
switches that we have that control the
13:58
parts of the photos that's the way this
13:59
experiment works laser is on uh box is
14:03
sealed hopefully there's not a lot of
14:04
interference in there right now I'm
14:06
going to start
14:08
so you go on you can see I sent you the
14:10
right RPC at the moment
14:12
okie dokie
14:14
um
14:16
okay
14:17
I
14:26
Yep.
14:27
So you can see it's considerably shorter
14:29
because it's in sign.
14:32
Yep.
14:33
So this is the one.
14:35
Yes.
14:35
And I'm going to
14:38
place it there. Yes.
14:39
Yep.
14:40
The code you will see that the there is
14:44
no basically no signature information.
14:47
You should come right after value. It
14:49
does not because there is a um
14:51
it does say valid false.
14:54
Yes, because it's not signed.
14:56
Um cool. So I also passed the ash and
14:59
then then you can
15:02
Yeah. So first things first, there is a
15:04
bit of the protocol that involves the
15:07
secret that these two ends should have.
15:10
The the information in this secret is a
15:14
couple of tables of bits that need to be
15:17
produced. Uh there's two rows in this
15:19
table and we need to pick the ordering
15:22
of the bits in the table. So whether
15:24
zero means x or zero means z. This is
15:27
the secret information that's shared by
15:28
the two tees. We put it as the first
15:30
input of our program. So let me run the
15:33
let me flash the two chips and run the
15:36
programs. So, first things first, I'm
15:39
going to flash. Program one goes on com
15:43
4.
15:48
That's the one. It's waiting for the hex
15:51
screen from the serialization utility.
15:53
Program two goes on com six. I had to
15:57
write them on my arm. Remember,
16:01
and that's also waiting for the same
16:03
information. So this is the secret table
16:05
that the two TE's would have stored
16:07
inside and would use to decide how to
16:10
encode the data and how to decode the
16:12
data. So this information comes from a
16:14
small utility that we have that Fabricio
16:16
has written. I shall not take credit for
16:18
this. Um I'm going to just put two
16:20
security bytes because it's a short
16:22
demonstration. So let's say 0x uh 012 3
16:28
0 x 4 5 6 7 and 0 x
16:34
8 9 a b and this gives me this states
16:39
there are 16 bits here 16 bits here 16
16:42
bits here that's 48 bits they get
16:45
encrypted using the the key so
16:48
technically you give this information
16:50
this information can't be read from the
16:52
outside it's decrypted by the enclave so
16:54
you can pass this but only the enclave
16:57
knows what the table is so this is
16:58
encrypted with a key that's that's
17:00
secret to the enclave uh use it as a
17:03
seed and I shall see fit to use it here.
17:07
So enter it on the
17:10
controller on the sending party. So
17:13
Alice enter it on the receiving party.
17:18
Same Bob and now I am told okay this is
17:22
valid information please provide the
17:24
input to your program. The input to my
17:26
program is going to be the hasht no one.
17:31
If you go on Telegram, this is the real
17:33
transaction.
17:34
Yes, that one.
17:35
This one.
17:36
7 CC.
17:38
7 CC. Yes.
17:40
And so this is the hash of the
17:42
transaction
17:45
which I will put here.
17:48
And if everything goes well, which it
17:50
never does. Ah,
17:51
error.
17:52
Well, no, not error. The the watchdog
17:54
has killed programmer.
17:57
Let's try again.
18:03
things are as fiddly as they can
18:05
possibly be.
18:08
This time I'm going to be fast.
18:15
But yeah, bunch of bits were generated.
18:18
Uh for debugging purposes, I have
18:20
printed them. You wouldn't. This is the
18:22
secret information. See the information
18:25
I sent initially as let me just kill
18:28
them. so that the wash doesn't restart
18:30
them. The information that I sent is was
18:35
a secret information that was decoded by
18:37
the the T internally and it contained
18:40
these secret basis choices. these secret
18:43
bits for the Z- basis, these secret bits
18:46
for the X basis. And these were used to
18:49
generate a bunch of switch
18:53
inputs that determine whether the
18:55
photons went into the X path or the Z
18:57
path, that whether the bit encoded was
18:59
the zero bit or the one bit. And on the
19:01
other side, the detector received these
19:05
photos, looked at the detectors, got
19:07
some bits out of the detection process,
19:09
and these were the bits that were
19:10
obtained. Sorry. These were the bits
19:13
that are were obtained. This would be
19:14
the measurement outcomes. They were
19:16
validated. They were valid and the
19:20
security was verified. This was a fairly
19:22
fair fairly well tuned um procedure and
19:25
it worked out for this program
19:28
execution. So now the key internally has
19:30
a key. The key was used to sign this
19:33
transaction and now this information
19:36
that I have should be the one that I
19:39
right.
19:39
Yes.
19:41
If I've done everything right, which I
19:43
am not sure I've done, how do I verify?
19:48
Uh, yeah, let's see. I I think you
19:52
should give it to me so that I can give
19:54
you the RTC because that's just the
19:56
signature.
19:59
Yeah, but can I not verify the the
20:01
signature by myself in some
20:03
I no enter?
20:06
I don't try. I don't know if the format
20:09
is
20:09
No, it's fair enough. So, I'll just send
20:11
it to you.
20:12
Just send me the transaction. Now, what
20:15
I I would like to show you my screen,
20:17
but it's it's a nightmare with two
20:19
computers at the same time.
20:22
Yes. So, give me a second. Now,
20:26
basically, I will copy this signature
20:30
into my program.
20:33
You have the key?
20:34
No.
20:34
I mean, I'm done.
20:36
The problem is not the keyboard. Where
20:38
is my computer?
20:40
Okay.
20:41
Run release. Okay. Now I should have
20:46
this thing which is
20:49
post it here.
20:51
Okay. Now if you go this one
20:54
I what?
20:55
Uh just copy in the transaction decoder.
20:59
Yeah.
21:01
This one.
21:02
Uh yeah.
21:03
Yeah.
21:05
And when you look at the code you will
21:07
see it's still the same but now there
21:08
are three more parameters D RS those are
21:12
the signature parameters. So now it's
21:13
actually signed and indeed it says valid
21:17
because the transaction now can be
21:18
executed. So
21:20
and the important thing is that only
21:22
signing happen on the TE. Uh so you know
21:25
in a real case scenario only Alice as
21:29
the private key sends it to the TE and
21:31
Bob basically gives it he works like
21:33
another wallet basically. above takes a
21:35
transaction, feeds it to the TE and the
21:38
TE signs it for him and then he
21:40
broadcasts it with the difference that
21:42
he can sign any transaction he wants
21:44
with that single key only once. Then he
21:47
cannot do it anymore because it destroy
21:49
the bunching information encoding the
21:52
table in the process and that's it.
21:54
Yeah. Thank you. Thank you.
21:57
[Applause]
#Engineering & Technology
#Physics