 Hi, my name is Ryan Kavanaugh and I'm very excited to talk to you today about some properties of parametrized fixed points on O categories. This work is motivated by giving a denotational semantics to a language with session types, in particular a language with recursive session types. So to set the stage, let's suppose we have two processes, a client C and a server S, and let's assume that they communicate with each other over a wire or a channel, and let's further assume that communication on this channel respects a communication protocol or a session type A. And examples session types include internal choice and external choice, channel transmission, recursive session types, and so on and so forth. Now in this language we're working with deterministic systems and our goal is to give a semantics that generalizes constant semantics to handle bi-directional communications. In particular, processes will denote continuous functions on domains of communications. To this end, instead of having a single channel or wire carrying bi-directional communications, we'll imagine that we have a pair of wires, a red wire that carries communications from C to S, and a blue wire that carries communications from S to C. Then C will denote a continuous function from the domain of blue communications to the domain of red communications, and symmetrically, S will denote a continuous function from the domain of red communications to the domain of blue communications. Now when we transitioned from bi-directional communications to pairs of unidirectional communication, we lost information, namely the alternation in direction and the interleavings. So to address this, what we do is we introduce a third domain, a black domain containing the complete bi-directional communications, satisfying the protocol A, and then we require that the black domain embed into the product of the blue and the red domains. And the intuition here is that the embedding gives us a copy of the complete bi-directional communications inside of the split-up communications. And so as a result, we don't actually lose anything. Now our goal is to give a semantics that captures recursive session types. And so to do so, we must first capture open session types. So let's assume we have an open session type A that depends on some context psi of type variables. And we'll write DCPO superscript psi for the psi indexed product of the category DCPO. And then A will denote three locally continuous functors from DCPO psi to DCPO. And I want to point out that perhaps surprisingly, all three interpretations are covariant. And the reason is types denote communications, not values. Then what we'll do is we'll generalize from a single embedding to a natural transformation where each component is an embedding. Recursive session types are given by the rule on the slide. And so our task is given an interpretation for the premise, we need to give an interpretation for the recursive session type at the conclusion of the rule. And regardless of how we do so, what we'd like is for this interpretation to respect the unfolding of recursive types. So for example, in the case of the black functor, what we'd like is we'd like for the interpretation of the recursive session type to be naturally isomorphic to the interpretation of its unfolding. And we already know that when we interpret recursive types using functors, what we can do is we can use parametrized families of fixed points to do so. And so given a functor f from DCPO psi alpha to DCPO, what we typically do is we find a parametrized family of fixed points f dagger and f dagger is a functor from DCPO psi to DCPO. The way we find f dagger is its action on objects d is going to be given by the fixed point of the partial application of f to d. And this parametrized family of fixed points is going to satisfy, is going to respect unrolling. And so more concretely, what this means is if f is the interpretation of the open type A and we interpret the recursive type by f dagger, then we get exactly the unrolling identity from the previous slide. So the question is, is this dagger operation functorial and does it preserve embeddings? And even if the answer is yes, we can't simply naively apply the dagger operation to the interpretation of the premise of the rule for the recursive type. And the reason is we end up with a wrong codemain. What we end up with is the dagger of a product instead of a product of the daggers. And so we don't actually have, we don't know what the interpretations, the blue interpretation and the red interpretation of the recursive type are. And the problem is that in general, the dagger of a product is not isomorphic to the product of the daggers. So what we need is more structure. And so in this talk, we give a parametrized fixed point operator on O categories that's suitable for interpreting recursive session types. And to do so, we'll build on techniques by Scott, Fiori, Lemon, Smith and Plotkin. And we're going to work with O categories because they give us just the structure we need. And they also give us an explicit handle on columns. And this parametrized fixed point operator will be locally continuous. So in particular, it will preserve embeddings and natural families of embeddings. And it will also satisfy the Conway identities. And the Conway identities are a collection of identities that are very useful for reason that fixed points. So let's begin by reviewing some of the basic definitions underlying this work. So an O category is a category where every HOM set is a DCPO. And where composition of morphisms is continuous. And O categories take their work in the work of take the root in the work of Wanda and Plotkin and Smith. And an example category, O category, is the category DCPO. And also we can make every category into an O category simply by taking the discrete ordering on HOM sets. Now, a functor is going to be locally continuous if its action on morphisms is continuous. And we're going to say that an embedding projection pair is a pair of morphisms E from A to B. And P from B to A, such that the composition of P after E is the identity on A. And the composition of E after P is less than the identity on B. So I mentioned earlier that we already know how to take fixed points. We've known this since the work of Scott in the 70s and layman and Smith in the early 80s in a more general setting. And the idea is given some functor F, what we want to do is output an object fix F, that is a fixed point of the functor F. And the way we do so is by defining an omega chain, that's to say a functor, from the category omega into K. And its action on the object in is going to be the nth iterate of F on the initial object. And the morphisms are going to be given by nth iterates of F on the morphism given by initiality. So more concretely, what this means is we're going to map zero to the initial object and one to F of the initial object and the morphism there is going to be given by initiality. And then what we'll do is to produce the rest of the chain, we'll iteratively apply F to it. And then if the core limit of this omega chain exists, it will be a fixed point of the functor F. Now what we want to do is we want to explore how fixed points of functors relate to each other. Also here, the first link of the chain was given by the initial object. And what we'd like to do is see how fixed points generated by different initial links or first links relate to each other. To do so, we'll define a new category of initial links where objects are triples, big C little C F, where F will be a locally continuous functor and little C will embed big C into F C. Then a morphism of links will be a pair H eta, satisfying the diagram on the slide. And this gives us just what we need to be able to define morphisms of chains. And I want to point out that the diamond on the right is a naturality square. In particular, both paths around it vertically are equal. And so what we'll do is we'll abuse a bit of notation and write eta asterisk H for the pair of equal morphisms. Next, what we can do is we can repeat the same recipe to define a functor omega out of the category of links into the category of omega chains. And its action on a link is going to be iteratively applying the functor to the initial link. And then the action on morphisms is given some morphism H eta between the initial links. What it will do is it will produce a family of morphisms where the component from FNC to GND is just going to be the nth iterative eta that will take us from FN to GN. And then we'll use H to take us from C to D. And now, assuming that K has all the needed omega co-limits and that we've chosen one for each omega chain, what we can do is we can define a generalized fixed point functor. And again, it's just going to be the composition of the co-limit functor with a functor omega. And this functor will be locally continuous. And what we want to do is we want to show that this actually gives us fixed points. So to do so, what we'll do is we'll define a functor that gives us the unfolding of a fixed point. And its action on objects on the initial link CCF is just going to be F applied to the generalized fixed point. And we can extend this to a locally continuous functor. And then what we have is that we have a natural isomorphism from the unfolding to the generalized fixed point. And this result is new to the best of my knowledge. And our interest was originally in parametrized fixed point. So what we can do is we can use this machinery to define a parametrized fixed point operator. So let's first remark that we can embed the category of locally continuous functors into the category of links. And then we can repeat the same recipe to define a parametrized fixed point operator, where given some functor from d cross k to k, what we do is we first curry it, and then we apply the generalized fixed point operator. And this parametrized fixed point is a locally continuous functor. And it also coincides on objects with the usual definitions found, for example, in the domain theory chapter of the handbook of logic and computer science. However, now we have some new machinery that we can use to reason about it. Also, again, we implicitly assumed that k has enough core limits, but it has an initial object and that has strict morphisms. So typically parametrized fixed point operators satisfy something called the fixed point identity. Now, in the case of functors, we have a fixed point identity, but it's only up to natural isomorphism. And so concretely, given some functor f from d cross k to k, we have a natural isomorphism foldf that takes us from f dagger to the enrolling, that is the composition of the f and its dagger. And its components are given by the fold isomorphisms that we saw before a few slides ago. And I want to point out that the definition of fold is natural in f. And a generalization of this result appears, I want to point out, in a paper by Lyndon Hobius et al from last year. And we also have that the dagger operator satisfies something called the parameter identity. And the parameter identity is very useful for showing substitution properties for type interpretations. And it tells us in a sense that the dagger operator is natural in its parameter. So more concretely, let's suppose we have a functor f from d cross k to k and a functor g from c to d. Then what the parameter identity tells us is that the dagger of their composition is equal to taking the composition of the dagger of f and composing it with g. We also have, as a new result of that, the fold isomorphism respects of the parameter identity. And we also have a bit of two categorical structure where if we have some natural transformations, then they too respect the parameter identity. So the way we usually check if fixed points are canonical is by seeing if they define initial algebras and terminal co-algebras. And it's the same here where suppose we have some functor f from d cross k to k, then an f-algebra is going to be a pair g gamma, where g is a functor from d to k, and gamma is a natural transformation from the composition of f and g to g. And then an f-algebra homomorphism from g gamma to h eta is going to be a natural transformation of rho such that the square on the slide commutes. And these form a category where the objects are f-algebras and morphisms are f-algebra homomorphisms. And we can duly define a category of f-co-algebras. And just as we hoped and expected, the parameterized fixed point operator gives us initial f-algebras and terminal f-co-algebras. So in particular, f dagger and fold of f is the initial f-algebra. And given any other f-algebra, the mediating morphism is a natural family of embeddings. And duly, f dagger and the inverse of fold of f is the terminal f-co-algebra, where the mediating morphism from any other f-co-algebra is a natural family of projections. So let's circle back to interpreting recursive session types. The category into which we interpret session types has all the structure we need for the dagger operator. And what we do is we use the dagger operator in properties of products to define the interpretation. And I want to point out that not only is the interpretation a mediating morphism of products, but it's also mediating morphism out of an initial algebra. So by the theorem on the previous slide, this gives us that it is a natural family of embeddings, which is exactly what we wanted. We can also use the parameter identity to show that it respects the substitution property. Now, our goal is always to be able to reason about programs and about interpretations of session types, and the Conway identities are useful for doing so. So the Conway identities are four identities for dagger operations that include the parameter identity, which we've already seen, and also, for example, the composition identity, which gives us parametrized dinaturality. And as a corollary of the results from before and of work by Bloemann Essek on dagger operators through two Cartesian closed categories, we have, as a new theorem, that the dagger operator that we just defined satisfies the Conway identities. And a useful application and consequence of the Conway identities is the pairing identity, which is sometimes known as Bechiches identity. And Bechiches identity is useful because it gives us a way of solving systems of parametrized equations. And it works a bit like a Gaussian elimination where, given a system of equations, we can solve the equations one by one and substitute the results through the rest of the system. And as an application, Bechiches identity is very useful if we want to interpret and reason about mutually recursive session types. So not only are the techniques and results we've presented so far useful for defining the semantics and ensuring that the interpretations all respect to desired properties like substitution, but we can also use them, they also give us a semantics that we can use to reason about programs. And in particular, this semantics is compositional and gives us a notion of program equivalence. And we've used this notion of program equivalence to verify various programs. So for example, we've used it to verify that a process that flips bits in a stream twice is equivalent to the identity. And this is an example where we have to reason both about recursive types and a recursive process. We've also shown that process composition is associative and we've used this semantics to show a large class of eta-like properties for processes. So in summary, we've given a parametrized fixed-point operator that is locally continuous and satisfies the Conway identities. And it's very useful for interpreting recursive session types and session type languages. And through this talk, I've mentioned various pieces of related work and for those who are interested in reading further, here are the references. Thank you for listening.