Hi everyone, my name is Titouan Caret, this is joint work with Emmanuel Gendar, and what we have done is to look at three graphical languages designed for quantum computing,

and we identified among them a common core structure, we called it a Z-star algebra, and then we classified all the Z-star algebra that can be useful for quantum computing. So first let me explain what is a graphical language. So we start from some building blocks, which are boxes with n inputs and m outputs,

and from them we can build bigger diagrams in two ways. First, there is a vertical composition when you just plug the inputs into the outputs. So this is called the composition, and the identity operation for this is just wire side by side, this is the identity. The second way to build bigger diagrams is to take two diagrams and just to put them side

by side, it's called the tensor product, and the unit for this operation is just the empty diagrams, which is diagrams with zero inputs and zero outputs. So we also require that it's possible to cross the wires, so we have this generator, which is the swap, and this

must satisfy this equation, so it must be an evolution, and you must be able to make any diagram go through wires. So it's not always the case, but sometimes we also have this, so some cups and caps, diagrams with zero outputs and two inputs, or zero outputs and two inputs.

It's called a compact structure when it satisfies this equation, which is the stack equation, and some compatibility with the swap. So when we have all of this, then we can have a very nice topological graphical language where we can bend the wire

like we will do with real wires. So if we forget about this last line, those axioms, it is just what we call the symmetric modoidal category, and in particular this is in fact a prop, which is a product and permutation category. So what is a graphical language? Just a family of generators,

and then you can build the free symmetric modoidal category from them, and you can quotient by equation between diagrams. So this is what is a graphical language. In fact, graphical languages are just generalization of the usual equational theories.

So if we have a compact structure, there is a very nice property that we'd like to have. This is called the only topology matters paradigm. They say that for all generators, if you use the cups to bend the outputs into inputs, and then you mix them using permutation, using swaps, it doesn't matter. This means that you don't care about the order of the

inputs or outputs on which in which. You only care about what is connected to what. This is why basically your diagrams are graphs. So this is a very nice property we'd like to have for a graphical language. It's called the only topology matter paradigm.

So I say that graphical languages are basically generalization of equational theories, and like equational theories, we can have models of them, interpretation. So to have a model of a graphical language, you need a symmetric modoidal category, a way to give an interpretation to composition and tensor, and then a model is just a strict

symmetric modoidal form term. So morphism preserving a composition and a tensor product. So we will see two of them. First, this is a category of linear relation with a morphism n to m is just a linear relation. We can see it as a linear subspace, and then composition is

the usual composition of relation, and the tensor product is a direct product of vector spaces. Then the most important category for this tool, this category qubits, that were morphism for n to m, just a matrix of size 2 to the n times 2 to the m. So then, composition is just the usual matrix product, linear maps composition,

and the tensor product is a tensor product of vector spaces, which is the chronicle product of matrices. So it's called qubits because the one object here is C2, which is a qubit space corresponding to a qubit. So this is the only thing you need to know about quantum computing

for this tool, that this is the category of that pattern. So a quantum graphical language is just a graphical language that has a model into qubits. So here are three of them, one of the ZX calculus, ZH calculus, and ZW calculus. So we think they're quite similar. In fact, they were developed by kind of the same people, the same community here. But

the same structure was also discovered in linear relation in a completely independent way. And I think that when a mathematical structure appears in two different settings like this,

it was further investigation. So this is what we have done. So we propose a generalization for those four languages, and the generalization is what we call the Z star algebra. So what is a Z star algebra? First, we have two families of generators. We have the black here, we call them spiders. So you have spiders for arbitrary

arity. So for each n and each m, you have a spider with n inputs and m outputs. And the spiders are indexed by what we call phases, which are elements of the Nabellian group. So this is new here. And the spiders, they obey some rule. First, we require the one-to-one

spider to be the identity, just a wire. And if two spiders are connected, then you can fuse them and you just put together the phases. You just use a group law here denoted additively.

So this is for spiders. And the other family is almost the same, we call them harvestmen. And again, for each n and m, you have one harvestman with n inputs and m outputs. They are also indexed by element of a Nabellian group. But here, we have also a fusion rule,

but then we need to have a one-to-one harvestman between them for, well, make them shoot. And we require this one-to-one harvestman to be an involution. So two of them, this is the identity, just a wire. And at least the last ingredient is this interaction

between spiders and harvestmen, which is called the B-algebra rule. OK, so this is a Z-star algebra. And now our goal will be to classify all of them by all models in qubits. So to do this, first, we need to find all the generators possible. So we need to

find all the spiders and all the harvestmen in qubits. But in fact, we will not do this because there is a way to forget about harvestmen and only care about spiders. How? Because if you have a spider and a harvestman and the only topology matter paradigm, there is a way to come back to two spiders. To do this, we say that spiders are compatible

if this mixed snake equation is true. And when it is, it's not always the case, but when it is, this unique morphism, we define it, we denote it this way, this is a diamond. And if you have two spiders which are compatible, you can use this diamond.

You plug it into the outputs of the spider, and then from this spider, you find a harvestman. OK, and you can go backward because this is an evolution. This is invertible. So the main point to remind here is that if you have a spider and a harvestman and

the only topology matter paradigm, it's the same thing as two compatible spiders. So here, we just look for two compatible spiders. So now, let's find all the spiders in qubits. First, we will start with monoids. So what is a monoid? Graphically,

you have a binary operation and a unit, and you see that if you plug the unit into the binary operation, so just the identity, and we have this here, this associativity equation, which is very important because this allows you to say that if you want to build a unary operation from binary one, then there is only a unique way to do this. The associativity equation

ensures that there is a unique way. They are all the same. So when you have a monoid, you can already define a restricted family of spiders which have a arbitrary number of inputs, but only one output. OK, so we're almost there. This is the start. And here, this is just the

commutativity equation. It's not always true only for commutative monoids. So in qubits, in particular, the model of the theory of monoids is just what we call a C algebra, in fact. This is C algebra of dimension two, and we know them very well.

Here are four examples coming from respectively from ZX, ZH, and ZW. We see that Z is common to the three languages. And in fact, there are only two C algebra of dimension two. So up to the homomorphism, there are only two monoids in qubits. In fact, here, ZH and X

are the same up to a change of basis. The W is completely different. The value is completely different. And we see that all of them are commutative. So in qubits, we don't care. It's about commutativity issues. It's not possible to have non-commutative things in dimension two.

OK, so I have already restricted family of spiders, but I need to also have some phases, those group elements, the index of spiders. So we define a phase is an invertible map satisfying this equation with respect to the binary operation. And when you have this, phases

are directly a group with composition. So this defines a phase group of a monoid. So in qubits, this is what we are. So for Z, X, and H is the same because they are isomorphic. We see the group is just two copies of the multiplicative group of C minus zero.

But for W is different, one of the two copies is the additive group of C. So this is what we've got. Now we still need to extend the spiders to allow more outputs than one.

And to do this, we extend monoid to Frobenius algebra. So we see the left part here. This is just the usual theory of monoid. And then this right part here is just the same, but upside down. It's called a co-monoid. And we see we have co-associativity. And this

allows also for another restricted family of spiders with arbitrary number of outputs, but only one input this time. So we have a family of spiders with a lot of inputs, a family of spiders with a lot of outputs. And if we plug them together, we can obtain a family of spiders for arbitrary inputs, number of inputs, and outputs.

And moreover, this middle equation here, called the Frobenius equation, ensure that there is a unique way to build the spiders. It's kind of a generalized associativity condition. And all those rules are in fact equivalent to the spider rule.

If you look at it, they are all specific instances of the spider rule. And from those rules here, the rules of Frobenius algebra, you can derive, show the spider rule in full generality. So this is equivalent to speak about spider or to speak about Frobenius algebra.

The main point was Frobenius algebra that they are easier to classify because we start from monoid and we know them well. So now let's see how we classify all Frobenius algebras. First, if we look at our running example, we see that for all of them, there is a co-monoid making a Frobenius algebra with them. But how do we, so this is only one

co-monoid working with the monoid we know. How do we find all of them? In fact, this is very easy to do once you know the phase group. So remember for a monoid, you have the phases, but for the co-monoid, you can also define co-phases in a dual way. But if you are in a

Frobenius algebra, you have the Frobenius rule that is true, then those two corresponds to each other. So the phases are the same as the co-phases. So we can speak just about the phase of the Frobenius algebra. And when you take a phase alpha, if you keep the same

monoid, you can slightly modify the co-monoid this way, and then you also have a Frobenius algebra. And in fact, all Frobenius algebras are this form. They are all what we call phase-shifted Frobenius algebras like this. Thus, if we want to know all the Frobenius algebras,

we just need to know the monoids and the phase group, and we find all of them. So in qubits, we have just two families of Frobenius algebras indexed by the phase group of respectively z and w monoids. We can also do the contrary, the opposite. So in a dual way, you can start

with the co-monoid and then find all the monoid making a Frobenius algebra with it. You just use the same trick, but the reverse direction is called the co-phases. Okay, so now we know all the Frobenius algebras that are available in qubits. There is

one ingredient remaining and this is the B-algebra rule. So we see this B-algebra rule is a little bit different from before. Why? Because when you go from Harvestman to Spiders, it's all these four transforms. So this is really what we need to check. And in fact, in qubits, there is only five pairs of monoids and co-monoids with this

property. There are only five of them, which are zz, zx, zh, w and wz. So this gives us a clear strategy to find all the z star algebras. First, we look at those pairs. Let's take, for example, zx.

So we have a monoid and a co-monoid, and then we look for all the possible extension of this monoid and co-monoid into Frobenius algebras using the phase groups. And among all those possibilities, we look for compatibility for this mixed-neck equation,

because we know if we have compatibility, then we can recover Harvestman, which is equivalent. So we try to find which Frobenius algebras are compatible. And when we do this, we end up with all those Frobenius, those z-star algebras. So I know this is very ugly,

but in fact, you can simplify this a little bit. Most of the parameters here are just renormalization factors, so not very important. And the main thing you need to take from this result is that we see there are only, all of them are just slight variations of zx calculus,

zh calculus and zw calculus. The only new thing that we see is this zz calculus, but in fact, this comes from the fact that the z Frobenius algebra is what we say is called the special Frobenius algebra, and then it makes a b-algebra rule with itself. It's kind of degenerate situation, not so interesting. So to conclude, we see that all the z-star algebra

that we know are in fact kind of the only one. So zx, zh and zw, this is not just a random phenomena that we designed the speaker calculus. In fact, they were the only one

if we think in terms of z-star algebra. In linear relation, we can do the same, use the same strategy to classify all z-star algebra, but here there is only one, and this is the one that has already been discovered. So we now have, thanks to this work, a clear view. Everything

is on the table. We understand completely how zx and zh and zw are related to each other. This is, I think, the main interest of this work that we have now a clear view with perspective on the three graphical languages. So this is in dimension two. We can think about

higher dimension. For example, in higher dimension, we have some example of zz, zx and zw z-star algebra for zh we don't know, and we know there is more. We know there is more because, for example, in dimension three, we already have non-commutative things.

So a lot more, and this could be useful for what is called the qubit quantum computing. So thank you for your attention. I have nothing more to say to you. If you have any questions, please email me or use whatever means you have to contact me. Thank you again.