WEBVTT

00:00.000 --> 00:05.000
Okay.

00:05.000 --> 00:06.000
Okay.

00:06.000 --> 00:07.000
Great.

00:07.000 --> 00:08.000
All right.

00:08.000 --> 00:11.000
Our first speaker of today, that's not an organizer.

00:11.000 --> 00:14.000
We'll be David, and he's going to tell us about his project,

00:14.000 --> 00:17.000
Fafu-ti, and as you'll probably know this, or you know already,

00:17.000 --> 00:20.000
that basically every quantum project has to have a cue in the name.

00:20.000 --> 00:23.000
This one is no different.

00:23.000 --> 00:26.000
Otherwise, we lose our license to do quantum computing.

00:27.000 --> 00:31.000
And yeah, we'll be telling us about compiling to not just analog computers,

00:31.000 --> 00:34.000
but analog quantum computers.

00:34.000 --> 00:36.000
So, hi, I'm David.

00:36.000 --> 00:40.000
I'm a little bit scared because there are way more people than I expected,

00:40.000 --> 00:44.000
plus I'm speaking first, and I was hoping to have the opportunity to learn many

00:44.000 --> 00:46.000
things from other people who spoke before me.

00:46.000 --> 00:48.000
So, yeah.

00:48.000 --> 00:51.000
And thank you for today, all you about FFu-ti.

00:51.000 --> 00:54.000
So, FFu-ti is an ongoing experiment, more details in a second.

00:54.000 --> 00:56.000
I work for Pascal.

00:56.000 --> 01:00.000
Pascal is a hardware company that deals and deploys QPUs.

01:00.000 --> 01:02.000
We are based in France.

01:02.000 --> 01:04.000
We have offices all over the world.

01:04.000 --> 01:10.000
And we also make open source software for tools, programming languages, libraries, etc.

01:10.000 --> 01:13.000
Oh, pretty good at it, hopefully.

01:13.000 --> 01:17.000
And I need to tell you that we have a community portal,

01:17.000 --> 01:20.000
and we're launching it in a few days.

01:20.000 --> 01:22.000
Thanks for me.

01:22.000 --> 01:23.000
Hi.

01:23.000 --> 01:26.000
I'm officially the open source coordinator for Pascal,

01:26.000 --> 01:31.000
which means that I get to work on many libraries on topics that I do not necessarily understand.

01:31.000 --> 01:32.000
Lots of fun.

01:32.000 --> 01:35.000
Actually, it is. Lots of fun.

01:35.000 --> 01:39.000
But as background, I'm not a quantum computing guy,

01:39.000 --> 01:44.000
which is one more reason where I'm completely afraid and scared that I'm going to make a fool of myself.

01:44.000 --> 01:47.000
That, and I forgot to read my mask.

01:47.000 --> 01:50.000
I'm a system guy, a system programming,

01:50.000 --> 01:52.000
a distributed programming, and a compiler guy.

01:52.000 --> 01:56.000
So I've been contributing to open source for 20 plus years.

01:56.000 --> 02:02.000
I have left a few tracks in a few programming languages, protocols, and open source software.

02:02.000 --> 02:05.000
And so, yeah.

02:05.000 --> 02:09.000
I am going to tell you about some quantum computing things.

02:09.000 --> 02:12.000
Hopefully, I'm going to change your,

02:12.000 --> 02:14.000
the way you view some problems.

02:14.000 --> 02:18.000
I'm not going to introduce you to new quantum concepts

02:18.000 --> 02:21.000
if you are already familiar with quantum computing.

02:22.000 --> 02:25.000
So, what is this all about?

02:25.000 --> 02:26.000
It's about difficulty.

02:26.000 --> 02:28.000
It's an early stage experiment.

02:28.000 --> 02:30.000
It's about compiling.

02:30.000 --> 02:32.000
And it's about some of the lessons learned

02:32.000 --> 02:39.000
trying to develop this compiler for analog quantum computing architectures.

02:39.000 --> 02:44.000
Which means that I'm going to talk about quantum computing at some point.

02:44.000 --> 02:47.000
I think I'm in the right room for that.

02:47.000 --> 02:52.000
So, say hello to the Ising Hamiltonian.

02:52.000 --> 02:55.000
Thank you.

02:55.000 --> 03:01.000
This is, I mean, there are plenty of ways to look at what quantum computing,

03:01.000 --> 03:03.000
including many ways I've not been exposed to,

03:03.000 --> 03:06.000
but that's the way I look at it at the moment.

03:06.000 --> 03:08.000
This is a pretty large matrix.

03:08.000 --> 03:14.000
If you have any cubits, this is a two to the power of n squared matrix.

03:14.000 --> 03:18.000
And it has very interesting properties.

03:18.000 --> 03:23.000
The main interesting property, as far as I'm concerned for this presentation,

03:23.000 --> 03:27.000
is that on a classical computer,

03:27.000 --> 03:29.000
most of the interesting operations,

03:29.000 --> 03:33.000
much all of the interesting operations on this matrix.

03:33.000 --> 03:37.000
I have a time cost that is at least exponential in the number of cubits,

03:37.000 --> 03:40.000
which means that too many cubits,

03:40.000 --> 03:43.000
your computer just cannot execute them.

03:44.000 --> 03:48.000
On the quantum computer, many operations, not all of them,

03:48.000 --> 03:54.000
have a time cost that is polynomial in the number of cubits, probably,

03:54.000 --> 03:55.000
strictly.

03:55.000 --> 04:01.000
Which means that if you have a problem that you can quickly and

04:01.000 --> 04:04.000
realistically encode as this kind of matrix,

04:04.000 --> 04:08.000
you have the ability to run it theoretically,

04:08.000 --> 04:12.000
much faster on the quantum computer than on a computer.

04:12.000 --> 04:15.000
One on a classical computer,

04:15.000 --> 04:18.000
at least if your number n is large.

04:18.000 --> 04:21.000
That is the promise of quantum computing,

04:21.000 --> 04:22.000
one of them.

04:22.000 --> 04:25.000
That's the one I'm interested in at the moment.

04:25.000 --> 04:29.000
But that's why quantum computing might change the world.

04:29.000 --> 04:33.000
So there are two religions,

04:33.000 --> 04:36.000
two schools of thought, at least on quantum computing.

04:36.000 --> 04:38.000
One of them is the digital one,

04:38.000 --> 04:41.000
all the illustrations on the previous presentation,

04:41.000 --> 04:44.000
were about digital quantum computing.

04:44.000 --> 04:46.000
So you have these big matrix,

04:46.000 --> 04:48.000
and you take it by turning it into gates,

04:48.000 --> 04:51.000
gates that are simple transformations.

04:51.000 --> 04:54.000
I'm a compiler guy, I see those gates, I see,

04:54.000 --> 04:58.000
oh well, that's what we call an intermediate representation.

04:58.000 --> 05:01.000
When you compile, you start with source code,

05:01.000 --> 05:04.000
at some point you end up with a machine code.

05:04.000 --> 05:08.000
These gates are one way to simplify the work.

05:08.000 --> 05:12.000
So an intermediate representation between this surface level

05:12.000 --> 05:16.000
language and this machine language.

05:16.000 --> 05:19.000
If you have been following a little bit,

05:19.000 --> 05:21.000
actually, about quantum computing,

05:21.000 --> 05:24.000
there are, there have been many,

05:24.000 --> 05:27.000
a huge number of claims, but quite a few interesting discoveries

05:27.000 --> 05:30.000
related to gates recently.

05:30.000 --> 05:34.000
But one of the difficult gates is,

05:34.000 --> 05:39.000
we're still in this noisy intermediate state quantum stage

05:39.000 --> 05:43.000
at the moment, not all of these hypotheses

05:43.000 --> 05:46.000
have been proven yet in practice.

05:46.000 --> 05:51.000
There is, well, there is the hypothesis

05:51.000 --> 05:54.000
that quantum gates are good for logical

05:54.000 --> 05:56.000
or integer related algorithms,

05:56.000 --> 05:59.000
and possibly not good for other applications.

05:59.000 --> 06:02.000
Again, it's a possibility to hypothesis.

06:02.000 --> 06:05.000
And then you have the other school,

06:05.000 --> 06:07.000
which is analog quantum computing,

06:07.000 --> 06:12.000
in which, basically, instead of going to the gates,

06:12.000 --> 06:16.000
you embrace the fact that everything is noisy,

06:16.000 --> 06:18.000
that you have these big, weird metrics,

06:18.000 --> 06:20.000
and you go for these metrics,

06:20.000 --> 06:23.000
so you have waves, your hypothesis,

06:23.000 --> 06:26.000
but you have a way of a system to deal with.

06:26.000 --> 06:29.000
And there is the hypothesis that maybe this is better

06:29.000 --> 06:31.000
for simulations, machine learning,

06:31.000 --> 06:35.000
and things that do not need exact arithmetics.

06:35.000 --> 06:39.000
But by using analog,

06:39.000 --> 06:42.000
we have a much more complex system.

06:42.000 --> 06:44.000
So the question I'm trying to answer,

06:44.000 --> 06:47.000
and I do not have a definite answer for from it.

06:47.000 --> 06:49.000
The question I'm trying to answer is,

06:49.000 --> 06:51.000
we find a good intermediate representation

06:51.000 --> 06:54.000
that works nicely for analog.

06:55.000 --> 06:58.000
A few limitations about quantum computing.

06:58.000 --> 07:01.000
So first, I mentioned the word probabilistic.

07:01.000 --> 07:03.000
I'm going to mention it again.

07:03.000 --> 07:05.000
This makes things weird,

07:05.000 --> 07:08.000
at least if you come from classical computing.

07:08.000 --> 07:09.000
As I do,

07:09.000 --> 07:13.000
you are never quite sure what you're observing at the end.

07:13.000 --> 07:19.000
Was it, was it just luck or bad luck

07:19.000 --> 07:21.000
that your experiment failed?

07:22.000 --> 07:24.000
And clear.

07:24.000 --> 07:29.000
Also, if you look at how things work,

07:29.000 --> 07:31.000
at the moment we don't know how to do

07:31.000 --> 07:34.000
an if or while or a jump or anything

07:34.000 --> 07:38.000
like a conditional control element

07:38.000 --> 07:40.000
in any kind of circuit,

07:40.000 --> 07:44.000
at least not without wasting most of our students.

07:44.000 --> 07:48.000
And also in classical computing,

07:48.000 --> 07:51.000
there is a circuit called the flip-flop,

07:51.000 --> 07:52.000
which is very convenient,

07:52.000 --> 07:54.000
because you can store one and then you can change it

07:54.000 --> 07:56.000
and store zero, etc.

07:56.000 --> 08:00.000
It's the basics of how you have memory on computers.

08:00.000 --> 08:02.000
To this day, as far as I know,

08:02.000 --> 08:04.000
there is nothing that looks remotely

08:04.000 --> 08:06.000
like that in quantum computing.

08:06.000 --> 08:09.000
So it's a very different universe.

08:09.000 --> 08:11.000
So in a way,

08:11.000 --> 08:14.000
I have a few friends who do low-level GPU programming,

08:14.000 --> 08:17.000
those limitations are not completely

08:17.000 --> 08:20.000
dissimilar to what they have been dealing with

08:20.000 --> 08:24.000
for GPU programming, just weather.

08:24.000 --> 08:26.000
On the other hand,

08:26.000 --> 08:29.000
their most applications,

08:29.000 --> 08:30.000
most interesting applications,

08:30.000 --> 08:32.000
are hybrid applications,

08:32.000 --> 08:34.000
which combine CPU,

08:34.000 --> 08:37.000
CPU, possibly several phases of CPU,

08:37.000 --> 08:38.000
CPU, CPU, CPU, etc.

08:38.000 --> 08:40.000
And of course your CPU,

08:40.000 --> 08:42.000
your CPU has all the loops, has the memory

08:42.000 --> 08:44.000
and is not probabilistic.

08:45.000 --> 08:47.000
If you're a compiler guy,

08:47.000 --> 08:49.000
this is not called hybrid computing.

08:49.000 --> 08:51.000
This is called multi-tier compilation.

08:51.000 --> 08:53.000
Multi-tier compilation is fun.

08:53.000 --> 08:55.000
Yeah.

08:55.000 --> 08:57.000
So,

08:57.000 --> 08:58.000
clefty,

08:58.000 --> 09:00.000
not finished.

09:00.000 --> 09:02.000
Why do we want a compiler?

09:02.000 --> 09:04.000
Because that's the alternative.

09:04.000 --> 09:06.000
This is,

09:06.000 --> 09:09.000
this is machine code as far as I'm concerned.

09:09.000 --> 09:11.000
This is something running on some of the machine.

09:11.000 --> 09:14.000
It's part of the integration test,

09:14.000 --> 09:16.000
because it does our logo,

09:16.000 --> 09:19.000
and I have no clue what it does.

09:19.000 --> 09:21.000
In this materializes an algorithm,

09:21.000 --> 09:24.000
what does it do? Who knows?

09:24.000 --> 09:25.000
But as far as I'm concerned,

09:25.000 --> 09:26.000
that's machine code.

09:26.000 --> 09:30.000
So, we want to get away from machine code as much as possible.

09:30.000 --> 09:33.000
We want to move from source code to machine code,

09:33.000 --> 09:35.000
and usually when you're writing a compiler,

09:35.000 --> 09:37.000
quite often you have a runtime,

09:37.000 --> 09:39.000
for instance, if you're using Python or Java,

09:39.000 --> 09:41.000
you have the garbage collector,

09:41.000 --> 09:43.000
that is part of your runtime,

09:43.000 --> 09:45.000
and ideally you have a machine.

09:45.000 --> 09:49.000
So, not all the work that's done in quantum computing

09:49.000 --> 09:51.000
field has a machine.

09:51.000 --> 09:52.000
As it turns out, we have a machine.

09:52.000 --> 09:54.000
We have actual QPUs, physical ones,

09:54.000 --> 09:57.000
but this computer is running an emulator

09:57.000 --> 09:59.000
that is going to simulate things.

09:59.000 --> 10:02.000
The slides are not running on the emulator.

10:04.000 --> 10:07.000
Compiling, you have your source code.

10:07.000 --> 10:11.000
You're going to go through several intermediate representations.

10:13.000 --> 10:15.000
So, let's start with the source code.

10:15.000 --> 10:19.000
I did not pick the most sophisticated language to start with.

10:19.000 --> 10:22.000
This is just a logical formula.

10:22.000 --> 10:26.000
If I know that A and if I know that A implies B is B true,

10:26.000 --> 10:28.000
I want to be able to compile this

10:28.000 --> 10:31.000
to run it on a quantum architecture.

10:31.000 --> 10:36.000
So, again, not the most sophisticated language in existence,

10:36.000 --> 10:40.000
but there is at least one dev room this morning.

10:40.000 --> 10:42.000
That's dedicated in part to these kind of languages.

10:42.000 --> 10:45.000
So, it's not completely indigloable.

10:45.000 --> 10:48.000
Also, importantly, we have to start somewhere,

10:48.000 --> 10:51.000
and if we can find a good IR for this language,

10:51.000 --> 10:54.000
we can start working towards more complicated languages.

10:54.000 --> 10:59.000
If I have an IR for this, I actually know how to run more complicated things.

10:59.000 --> 11:02.000
So, we're going to transform it.

11:02.000 --> 11:04.000
First, we're going to get rid of the implications

11:04.000 --> 11:06.000
to just have ends, ors, and negations,

11:06.000 --> 11:10.000
and to have an idea of what we want to observe.

11:10.000 --> 11:14.000
Then, second IR, we're going to get rid of the end

11:14.000 --> 11:16.000
and turn it into a system.

11:16.000 --> 11:19.000
We're going to go through this formulation.

11:19.000 --> 11:26.000
It's called three sets. You can find it in every text book on a logical program.

11:26.000 --> 11:31.000
I'm going to use a few variables to fill the scheme,

11:31.000 --> 11:35.000
which may or may not be a good idea, but again, it's an experiment.

11:35.000 --> 11:43.000
Then, you turn it quantum effect, sometimes it's observable.

11:43.000 --> 11:47.000
Then, you turn it into another system,

11:47.000 --> 11:49.000
which basically means the same thing,

11:49.000 --> 11:54.000
but instead of having booleans, you have equality checks.

11:54.000 --> 11:57.000
Then, you turn it into another system,

11:57.000 --> 12:01.000
in which you have maximization instead of solving these equations.

12:01.000 --> 12:04.000
That's the beginning of something called cubo,

12:04.000 --> 12:09.000
if you're involved in quantum computing, you probably have heard of it.

12:09.000 --> 12:11.000
And we want maximization, why?

12:11.000 --> 12:15.000
Because maximization is something that our machine does it pretty well.

12:15.000 --> 12:18.000
This cubo, this is the exact same thing,

12:18.000 --> 12:21.000
but formulated as linear algebra,

12:21.000 --> 12:26.000
which we can then turn by a process that is semi-magical,

12:26.000 --> 12:30.000
basically, proved force at the moment, at least in my experiment.

12:30.000 --> 12:37.000
Into this, which is basically the source code, and laser.

12:37.000 --> 12:40.000
Which is basically the source code for that.

12:40.000 --> 12:46.000
So, we have gone from source code, which was one logical formula.

12:46.000 --> 12:52.000
And we have layout of, in our case, atoms for different

12:52.000 --> 12:56.000
manner of implementing quantum computing, other things,

12:56.000 --> 13:02.000
but for atoms, on a plane, plus some laser stuff.

13:02.000 --> 13:05.000
So, in theory, we can run that.

13:05.000 --> 13:07.000
Can we run that?

13:07.000 --> 13:12.000
So, first step is the compiler.

13:12.000 --> 13:18.000
So, it goes through the first few steps of intermediate for presentations.

13:18.000 --> 13:21.000
And, oh, this is the same matrix we had earlier.

13:21.000 --> 13:25.000
And, I made a mistake with copy and paste.

13:25.000 --> 13:30.000
And then, it is waiting a little bit.

13:30.000 --> 13:31.000
Yes.

13:31.000 --> 13:37.000
So, when I said brute force, the entire time was spent in the brute force.

13:37.000 --> 13:38.000
Here.

13:38.000 --> 13:41.000
Oh, great, quality of 18%.

13:41.000 --> 13:44.000
That's what can go wrong.

13:44.000 --> 13:52.000
So, this is source code.

13:52.000 --> 13:56.000
It's a bit unreadable, but it's basically, sorry, the machine code.

13:56.000 --> 14:09.000
So, it's a bit unreadable, but it's basically why it showed you on the slides earlier.

14:09.000 --> 14:11.000
And, no, let's run it.

14:12.000 --> 14:14.000
So, this is non deterministic.

14:14.000 --> 14:19.000
It doesn't always show something.

14:19.000 --> 14:21.000
That is not a bug.

14:21.000 --> 14:24.000
Actually, it's not a bug in that part.

14:24.000 --> 14:29.000
It doesn't always show something, because sometimes there are just no usable results.

14:29.000 --> 14:36.000
But, if you look at it, so, it gave me, I don't know if you can read this from what you are,

14:36.000 --> 14:40.000
but it gave me solutions that are false.

14:40.000 --> 14:43.000
Which is a bit annoying.

14:43.000 --> 14:53.000
So, earlier this week, I had solutions that were right, but I found that it was a bug.

14:53.000 --> 14:56.000
Well, at this point, I'm awfully confused.

14:56.000 --> 14:57.000
Oh, gosh, what am I doing?

14:57.000 --> 14:59.000
I gave a demo that failed.

14:59.000 --> 15:02.000
What am I going to say when I get back home?

15:02.000 --> 15:03.000
No.

15:03.000 --> 15:08.000
I'm actually not showing something that works in this period of transparency.

15:08.000 --> 15:12.000
Thank you for introducing the concept, because, yeah, we need that.

15:12.000 --> 15:14.000
So, what went wrong?

15:14.000 --> 15:20.000
So, to the best of my understanding, what went wrong is that.

15:20.000 --> 15:30.000
So, this is the metrics we obtained at, I think, the fifth step of intermediate presentations,

15:30.000 --> 15:33.000
and it has 36 numbers.

15:34.000 --> 15:42.000
But, we are trying to get it to compile with six qubits, which may give us 18 parameters,

15:42.000 --> 15:44.000
and a few physical constructs.

15:44.000 --> 15:47.000
We have an impedance mismatch here.

15:47.000 --> 15:57.000
So, naively, I tried to get it to work with some theoretical results that I found in a paper.

15:57.000 --> 16:02.000
Those theoretical results are probably completely true, but don't work for me.

16:03.000 --> 16:09.000
So, we have an impedance mismatch, because we have made a cardinal scene in compiler at some point.

16:09.000 --> 16:14.000
We have an intermediate representation that is more powerful than the final representation,

16:14.000 --> 16:19.000
and we cannot always go from one step to the next step.

16:19.000 --> 16:20.000
So, what can we do?

16:20.000 --> 16:23.000
So, it's an ongoing experiment.

16:23.000 --> 16:27.000
So, there are other versions of cubo, this intermediate representation,

16:27.000 --> 16:31.000
but require more cubits, and that hopefully works better.

16:31.000 --> 16:35.000
I have started experimenting, but I haven't finished yet.

16:35.000 --> 16:40.000
Or, invariant, perhaps we can find something non-cubo that would work.

16:40.000 --> 16:45.000
I have vague intuitions here, but nothing that even remotely looks like an experiment yet.

16:45.000 --> 16:48.000
So, we'll see next here about that.

16:48.000 --> 16:50.000
So, a few last words.

16:50.000 --> 16:52.000
Can we write a compiler?

16:53.000 --> 16:58.000
Well, all of this suggests that, yes, we can probably write a compiler.

16:58.000 --> 17:01.000
I mean, everything works right.

17:01.000 --> 17:06.000
But, we might not have the right AR, I.R. Sorry.

17:06.000 --> 17:10.000
So, maybe it's not entirely validated yet.

17:10.000 --> 17:13.000
But, we can draw a few lessons.

17:13.000 --> 17:14.000
Four one thing.

17:14.000 --> 17:17.000
So, this name I.R. was not sufficient.

17:17.000 --> 17:20.000
Despite the fact that the research papers were talking about it,

17:20.000 --> 17:25.000
were really confident about their applicability.

17:25.000 --> 17:29.000
In some of the cases, it should have worked here.

17:29.000 --> 17:31.000
That's one thing.

17:31.000 --> 17:34.000
Why did it take me so much time to understand the problem?

17:34.000 --> 17:37.000
Because testing a probabilistic system is really complicated.

17:37.000 --> 17:40.000
I don't think that we have a good solution for this yet.

17:40.000 --> 17:43.000
If someone has a good solution and is speaking later today,

17:43.000 --> 17:47.000
I would really, really learn to, I love to hear about this.

17:48.000 --> 17:51.000
Another thing is, so many I.Rs, it's really easy to get lost,

17:51.000 --> 17:56.000
especially since several of them are just numbers.

17:56.000 --> 18:00.000
And, yeah, another thing is, you've seen the big break,

18:00.000 --> 18:03.000
the big pose during compilation.

18:03.000 --> 18:06.000
I actually overdid it because usually it's quicker.

18:06.000 --> 18:10.000
I just increase the number of iterations.

18:10.000 --> 18:14.000
But, this is going to be a problem for big hybrid systems,

18:14.000 --> 18:18.000
in which you'll go from CPU to CPU to CPU to CPU.

18:18.000 --> 18:23.000
Handle the results, produce a new computation, compile again,

18:23.000 --> 18:25.000
to CPU to CPU to CPU to CPU to CPU to CPU.

18:25.000 --> 18:29.000
So this is a problem that we will need to solve as a community at some point.

18:29.000 --> 18:34.000
I have not seen anyone working on that yet, maybe I've just missed the research.

18:34.000 --> 18:39.000
On the other hand, I have good hope for competitors,

18:39.000 --> 18:43.000
because I don't think any of the problems is impossible to solve.

18:43.000 --> 18:48.000
And, having using rest for prototyping is really useful

18:48.000 --> 18:52.000
because of all the invariants that I needed to keep in mind,

18:52.000 --> 18:55.000
having a strong type system really helped.

18:55.000 --> 19:00.000
So, to do replace the cubo demonstrate other compiler frontends,

19:00.000 --> 19:03.000
so other languages than these logical language,

19:03.000 --> 19:08.000
I know how to do it for one or two languages, others I don't know yet.

19:09.000 --> 19:12.000
And, I'm pretty confident that we can use fewer cubo,

19:12.000 --> 19:16.000
or cubo, it's at some layer, maybe not all.

19:16.000 --> 19:20.000
I asked you to remind me to tell you about the community.

19:20.000 --> 19:23.000
Thank you for reminding me.

19:23.000 --> 19:31.000
So, we are launching our community portal in a few days.

19:31.000 --> 19:36.000
It's a good place to have tutorials and events course for collaboration.

19:36.000 --> 19:38.000
We have for our first open source.

19:38.000 --> 19:40.000
We definitely need to get in touch with you,

19:40.000 --> 19:42.000
literally, about that.

19:42.000 --> 19:44.000
And we also provide access to physical,

19:44.000 --> 19:46.000
cubo use and hydrophotone museum innovator.

19:46.000 --> 19:49.000
All the links are on the schedule.

19:49.000 --> 19:50.000
Thank you.

19:50.000 --> 19:51.000
Thank you.

19:51.000 --> 19:54.000
Thank you.