1.1 Formal Judgements

Let us set this up a little more formally. This is a first pass that we’ll have to add features to later. We have the following judgements:

There are two ways to extend a theory: declare a new (dependent) sort, or declare new term.

Construction contexts are ordinary type theoretic contexts: lists of variables with an associated construction as its type; each of which may be dependent on the previous entries.

Each kind of theory extension has an associated “variable rule”, allowing it to be used directly so long as we specify parameters to use for its construction context.

Now, the actual rules for constructions and their terms. First, we have the “inner” variable rule that allows us to use a variable from the current construction context.

The construction formers available are , , , (some) higher inductive types, all taking place within a fixed . Because the language of constructions lacks universes, we will need to compensate by including large elimination rules for inductive types. And because we lack function types, we will likely also need to include an extra “Frobenius” telescope in these induction principles.

1.2 Set-indexed Sorts and Terms

The next step is to get the external world of sets involved. Thus far we are only capable of expressing “finitely axiomatisable” theories, those consisting of a finite collection of sorts and terms. This is not sufficient for many coherent theories encountered in practice, even before we get to geometric theories.

Consider the theory of -modules for a fixed ring . With our current tools we are able to express an abelian group structure on a sort , but scalar multiplication requires a scaling operation for all elements of the set .

Put differently, we need to add a notion of “axiom schema” which allows us to add an axiom for each element of a type, and in the general case this axiom may vary over the elements of the type. While we’re at it, we may as well extend the notion to terms and sorts generally – we’ll handle it through the same facility.

Schemas of this kind are achieved as follows: each sort and term has an ordinary context of types coming before the construction context, so that each sort or term is universally quantified over this context. In the -module example:

On the right-hand side, some of the constructions we have postulated involve operations in the background type theory: we see the multiplication of ring elements in , and addition in . These are not part of the theory being defined, but happening externally to it.

For an example of a “sort schema”, consider the theory of prime filters of a ring , whose classifying topos is the small Zariski topos . Here, we have one sort for each ring element , which we think of as the proposition that the ring element lies in the filter. The remaining terms of the theory are then straightforward translations of the theory in the ordinary style.

Formally, these contexts of types are added to all construction judgements and all the rules for interacting with them.

When using the “variable rules”, we now need to provide parameters to use for the entries in the prefix of types of the construction context:

Besides quantifying over elements of a type in this opaque way, we may wish to make choices based on elements of an inductive type.

For example, the theory of a ring is coherent and finitely axiomatisable. Requiring the ring to have characteristic 0 is still coherent but requires infinitely many terms to specify: we ask that the ring is not characteristic 2, not characteristic 3, and so on. We add one term for each , stating that yields a contradiction.

In order to define in the construction world, we need to be able to do construction-valued induction on the type ; this requires a new induction principle:

Temporarily adopting a more convenient syntax, we might write this as an ordinary pattern match:

And then we can state the term schema that forces the ring to be characteristic 0.

(In this particular example, we could have used a version of the natural numbers definable in the language of constructions, if we choose to include in the class of inductive constructions we allow.)

1.3 The Ax Construction-Former

The feature of geometric logic remaining to be added is infinitary disjunctions, indexed over any type.

The context of types of the last section behaves much like an infinitary disjunction appearing to the left of the turnstile, but we need an equivalent for when an infinitary disjunction appears on the right. For this, we add a new construction former , so that including a term of the construction in a theory is asserting that we have an element of the type .

This is a typical “positive” type former, where the eliminator is designed to give a universal mapping-out property. In this case, to build a construction assuming a term of the construction is the same as giving a construction for every element of the type . Of course, each construction having the extra context zone of types is necessary for this to make sense.

The construction-former is the final missing piece, and we can now capture in syntax all your favourite geometric theories. First, the flip side of the example above: the theory of a ring of finite characteristic. Starting with the theory of a ring , we can add

using the same operation defined above. We assert a term of , corresponding to an element of the type , and then must unwrap it into the context of types before we can use it as we did previously.

An important example we can now capture is the theory of a flat functor from where is a fixed small category. Suppose we have the category provided as a collection of types and functions (not a theory!). In pseudo-Agda notation:

From these we can construct, again purely in type theory, the type of cones with endpoints and , and the type of equalisers of a pair of morphisms.

Then, in our style, we can build the theory of a flat functor from in pieces.

I find this quite nice: the type level and theory level are both captured in the formal language, and the boundary between the two is made totally explicit.

1.4 Internal Theories

Something we’ve done a couple of times now is judged a theory with reference to some type-theoretic parameters. For example, the ring to be used in the theory of an -module, or the data of the category in the theory of a flat functor. These could be provided as closed types and terms, but better would be to allow ourselves to judge a theory internal to an ambient context.

This can be done by sneaking yet another notion of context into our judgements as a prefix, to act as the context that all our work is happening inside:

The above judgements presuppose that holds. This is now sprinkled through all the rules but does not interact with them in any interesting way, other than being present when typing each telescope .¹

We can replay the theories we described above, but properly parameterised over their inputs.

1.5 Judging a Model

Now that we can describe a theory in context, it would be nice if we could express what it means to have a model of that theory. For this, we will introduce a new judgement: , the claim that “models” or “satisfies”² the theory . We can use variables from the ambient context when describing a model, so really this judgement expresses a model-in-context of a theory-in-context.

The rules for producing a model have some moving parts that need to be defined mutually inductively. To build up a model of a theory means providing an appropriate construction in the world of types for each field of the theory.

Each component of a model binds the names in its contexts and . The construction context for each field is interpreted using the components we have already specified for the previous fields of the theory. For example, when describing a model of the theory of a monoid, once we’ve chosen a type to use as the carrier, specifying the operations and equations involves elements of that specific type occurring entirely in the type-theoretic world.

Carrying this out means using admissible operations that have the following shape. Given a model of a theory, we are able to interpret any construction context, construction, and construction substitution in that model, giving a result in the underlying type theory.

This is done by induction on the structure of the constructions involved, so for example:

Once we reach the base cases of the direct use of a sort or a term, the model provides exactly the type or element to be used in that location.

Here, and project the corresponding component of the model.

1.6 Stepping Into a Classifying Topos

Our goal from the start has been to find a way to work in the “internal language of all toposes”. Once we’ve described a theory, we need a way to step into the classifying topos of that theory. We’ll do this by adding a new notion of context extension for the ambient context , which allows us to hypothesise a model of a theory rather than an element of a type.

Working inside the ambient context “” will correspond to working internal to the classifying topos . The universal model of inside is exactly the model , which we will have access to using a variable rule (to be described soon) for these model context extensions. More generally, is a theory internal to the topos specified by the context , and the extended context is then the classifying topos .

So, “” in the judgements and rules we’ve seen so far is now generalised to allow interleaving of ordinary and model context extensions. The “” context appearing in the description of sorts and terms is not generalised in this way; it must only contain ordinary variables.

This new notion of context extension has corresponding weakening and substitution operations, but here we encounter a wrinkle. Semantically, these correspond to pullback along a geometric morphism, which does not commute with all type formers and operations.

This manifests as weakenings and substitutions getting stuck in certain places. In particular, we must make this kind of weakening explicit rather than silent in the syntax of a term.

We have equations that push both of these operations through geometric term and type constructors, but none of the others.

Similarly, these model substitutions push into theories and constructions. By their very nature these are all built out of geometric pieces, with the exception of constructions. Once this shifts us back into the world of types, the model substitution may get stuck again on a non-geometric type former.

We now have the language necessary to specify the variable rule:

That is, we have a theory internal to a topos . Inside the classifying topos there is, from the perspective of , a universal model of the theory . Because the judgement in the conclusion is interpreted in itself, this needs to be adjusted: the theory is pulled back from to , and this cannot be totally silent in general. Then inside , we have a model of this pulled-back theory.

It’s necessary to notate the locations of these explicit weakenings even when the judgement being weakened has no free variables at all. Consider the type . This may have a nontrivial intrinsic “topology”, which varies depending on the topos in which it is constructed. Even in the simplest case of the classifier of the theory of an object, the types and are non-isomorphic, even though and individually.

3.1 Ingo’s Synthetic Quasicoherence

The purpose of this whole exercise was to devise a setting in which we could state Ingo’s quasicoherence principle, and this is where the theory starts to hit the rocks.

In the framing that I want to use, his principle gives a universal property to a certain theory living inside any classifying topos ; the “slice theory” . This is the theory of “-algebras”, models of equipped with a homomorphism from the universal model . Because this is happening inside the classifying topos , we are not working with models of exactly; we must explicitly weaken into that extended context.

I won’t attempt a general definition of here. It’s up in the air whether this theory should be defined “observationally” in terms of the theory , that is, computing by induction on the structure of . Or perhaps the quasicoherence principle I’m about to describe will characterise this slice theory completely, and it can be proved inductively is equivalent to the theory of homomorphisms out of .

Phrased both more syntactically and more naively than in the previous post, the induction principle has the following shape:

In words:

Working internally to the classifying topos for , to show a quasicoherent statement about -algebras it suffices to prove the statement for the identity -algebra.

This is highly reminiscent of ordinary path-induction; in order to “map out” of the slice theory , it suffices to give the image at the identity algebra.

We’ve used a judgement that ensures that a context telescope is etale, meaning that it only consists of ordinary context extensions and does not contain any model-extensions. The addition of the etale telescope is necessary to do anything interesting here; the principle holds for any slice of the classifying topos for .

With the above rule in hand, we can attempt to replicate one of Ingo’s proofs of an interesting non-geometric feature of a classifying topos: any two elements of the universal object are not not equal, where “not” is defined in the ordinary way as . (This is only indicative of what the argument will look like; the precise induction rule is not pinned down enough for this to be formal.)

We’ll do this in excruciating detail, with all the judgement-switching made explicit. In search of a contradiction, suppose we have so that ; that is, our context is

The slice theory in this case is the theory of a sort together with, for every element , an axiom . Such a map is exactly a model of , so the slice theory in total is There is certainly a model of this theory given by the identity homomorphism, which in this case is the pair .

Working further inside the classifying topos for this , we can form the “motive” theory: If we substitute the identity model for yielding a model internal only to , the theory reduces all the way to . We certainly have a model of this theory, built easily from :

By the quasicoherence principle, we have a model of for any model . We now choose a specific model to use that solves this problem: the quotient type , given the structure of a -algebra by the function . More precisely, we’re forming the model

Performing the substitution of this model into , we see that induction has given us a model of . Because we do indeed have an element of in the quotient type , this yields a model of , and so an element of . Contradiction!

There are a few issues with the rule as presented above. First, one crucial aspect of the induction principle is that it does not apply to arbitrary motives , only those that are “quasicoherent” over the context; this is the intended meaning of the annotation³. In Ingo’s formulation, this is a restriction on which infinitary coproducts are allowed to appear; in our setting, this corresponds to some restriction on exactly what types are allowed to be used inside .

Here’s an example of something we’re not supposed to be able to write. Suppose we’re again working directly in the object classifier, so , and the slice theory is as above. In the context of and we can write down the theory of a section of :

This certainly has a model when is the identity -algebra, and so quasicoherent induction applied with this motive would summon a section for any -algebra. Worse, the existence of a section would pull back to any morphism in any topos. The culprit in this case is the use of the theory ; this corresponds to an infinitary coproduct that is not quasicoherent over the context. We need some syntactic condition that restricts exactly which types we are allowed to apply to in the motive of the rule, but how to formulate this condition is unclear.

Second: as written, the rule is syntactically unpleasant due to the non-generic shape of the context in the conclusion. The type theorist’s solution is to cut in for the variable in the conclusion (and probably the extra telescope as well). The ordinary justification is that we lose no generality, because if we want to recover the original version of the rule with the variable in the context, we can simply apply the new rule with a context that happens to contain the variable, and use that variable when applying the rule.

Writing out a more familiar example, suppose we have judgements

and we wish to construct using the ordinary path induction rule. When we apply the rule, we are given additional variables in the context to type the motive, and we choose to supply the term (which happens to be a variable) as the target.

In our setting, substituting in for the model variable gets stuck on any non-geometric types used in the motive : we would no longer be able to obtain a result “internal to ” directly, only one pulled back from to an arbitrary model.

This is unsatisfying, but may actually be sufficient in practice. How might we use the resulting model of ? Well, if contains non-positive constructions then we are stuck for now. However, in combination with other models of theories of the form , we may be able to prove a positive fact beneath the . Then is no longer stuck, and we obtain a proof that the fact holds for the model specifically. It is unclear to me how feasible this kind of reasoning would be to do by hand.

Finally, the rule above is actually underpowered compared to the principle described by Ingo. In its original formulation, the conclusion of the quasicoherence principle is not merely that the quasicoherent statement holds for every -algebra, but that there is a proof in geometric logic modulo that the statement holds (again, all happening internal to ).

This distinction is impossible to express in our type theory; we do not have a method of “introspection” that lets us manipulate proofs in this way. When might that additional power come in handy? One situation is when we have a model of not internal to itself, but internal to a topos that is internal to . Because we have a geometric proof of the statement, that proof can be replayed in this inner topos too; and so ought to hold for models of that live there:

Heaping speculation on speculation, we may be able to allow the motive of the induction to also lie in an inner topos. Temporarily removing the cut for , the rule then has exactly the same shape as the left-rule for the ordinary identity type:

Allowing a general telescope subsumes the need for the intermediate etale telescope between and : the contents of can be explicitly weakened and placed into instead.

The rule certainly needs some quasicoherence restriction on the motive , but likely also a restriction on the form of the telescopes that may be used. Exactly what is necessary is a question for the semantics, and I am not the best person to answer it unfortunately.

3.2 Converting Between Styles

Converting between the EMTT style and the all-in-one style of theory is not entirely mechanical. Consider the -theory for the following internal theory: That is, we have an internal theory with one sort for each function . This should correspond to some geometric theory in the base topos, but which one?

Naturally, is not a geometric construction in the theory , and so we cannot write in the old style what would be the natural thing:

Our only option here is to appeal to quasicoherence. We happen to know, via quasicoherence, the non-geometric fact that inside there is an isomorphism . This lets us write the correct all-in-one version of the theory:

Applying this transformation seems difficult to do mechanically!

3.3 Should Model Weakening Be Modal?

One nit in both versions of this type theory is that the rules for model substitution have to be tuned by hand to do the right thing; commuting with certain type and theory constructors but not others.

Here’s an alternative that feels quite natural: we treat weakening past a model context extension as a modal operator that must be introduced and eliminated explicitly. Here’s what that might look like.

We can then aim to prove that certain constructions commute with internally, if we give them sufficiently powerful “crisp” induction principles that can be applied anywhere in the context. For sums, we have the following:

As a derivation tree, we are typing the body of the definition by:

Key here is that we can apply -induction on the term that is well-formed in the prefix of the context that comes before .

Using rather than explicit substitutions to isolate the special nature of geometric constructions feels much more satisfying and uniform than building them into the rules directly. But pushing down this bump in the carpet causes it to pop up elsewhere. First, it introduces a lot of wrapping and unwrapping s, even for the simple theories we’ve seen already.

Additionally, this interferes with the typing of the model variable rule. In context , we should still be able to use the variable directly, giving a model of some theory. What theory is a model of? With explicit weakening, this was . Now, we have to reach into and sprinkle the use of everywhere. A symmetric issue happens when applying model substitution as occurs in the rules for -theories (and elsewhere, in the future). There, the substitution operation has to strip all uses of . I don’t immediately see any blockers to this working out, but it certainly complicates the metatheory.

Finally, this doesn’t help with the model substitution rule, which should get stuck in all the same places as weakening. I have been unable to come up with sensible rules for a modal operator corresponding to model substitution; model substitution doesn’t seem to be “judgementalisable” in the same way that weakening is:

This is not the first time the issue of stuck substitutions has been encountered in dependent type theory. The most similar precursors can be seen in the line of work on guarded dependent type theory, which uses the “later” modality to ensure that recursive definitions are productive. There, delayed substitutions are used to give typing to an applicative structure on that works on dependent functions, not just non-dependent functions. Unfortunately the remainder of the setting is quite different, and I’m not sure what lessons can be drawn.

Even more tantalising is that one of the intended models of guarded dependent type theory is the topos of trees; the classifying topos of an easily described theory. And so, it is possible that the rules of GDTT will one day fall out of geometric type theory as a particular instance.

3.4 Should Model Weakening Be Multimodal?

Another option is to use the modal frameworks MTT or MATT to produce a type theory, taking the “mode theory” to be the entire category of toposes and (inverse image parts of) geometric morphisms. Finite diagrams of toposes are the intended application of MATT, and so we are only doing something new if we mix in the ability to specify new modes and mode morphisms as we go. But as a first step, let’s write out MATT in a syntax closer to what we’ve already seen above.

Each context is annotated with a theory specifying the topos in which it lives. We’ll suppose there is a judgement for geometric morphisms (representing the geometric morphism ), with rules to be determined, and which doesn’t interact with the contexts at all.

To have the MATT variable rule we need a syntactic notion of 2-cell between geometric morphisms, and if we are presenting morphisms as “theories in context”, it’s difficult to make sense of what this would mean.

The general inverse image modality would look like the following:

With rules along these lines we could probably do some very basic examples, such as the object classifier . But as written there’s no advantage over just using MATT directly, so I’m not sure this is going anywhere useful.

Compositional stock-flow diagrams

The previous release added the ability to compose Petri nets by sharing places. This release continues in that vein, adding the ability to compose stock-flow diagrams by sharing stocks. As a result, all logics in CatColab now support composing models in the variable sharing paradigm.

With all this composition, we might need something to make sense of the compositional structures that we can now create…

Composition pattern visualisation

… and that’s what a new analysis lets us do. The composition pattern analysis visualises the way in which your notebooks have been composed, as an undirected wiring diagram. A composition pattern gives a high-level summary of how a model is constructed from components.

Systems of polynomial ODEs

Quantitative analyses of models are important, whence our efforts to implement and extend well known ones such as Lotka–Volterra, Kuramoto, and mass action. However, in keeping with the core design decisions of CatColab itself, we want users to be able to define their own ODE semantics.

The first step towards this is to be able to treat systems of ODEs as models of a theory in their own right, giving ODE systems first-class status in CatColab. The mathematical details of this idea are sketched out in RFC-0001 (more on RFCs below!), but the short story is that you can now build arbitrary systems of polynomial ODEs as models, compose them, view the derived equations, and simulate them.

As a toy example, we can “define” and as solutions to a system of two polynomial ODEs:

We can then use compositionality of models to “import” these trigonometric functions into a new model, which is an ODE model of an entirely fictional system that I made up with very scientific names and equations:

Backend for Julia and AlgebraicJulia

AlgebraicJulia is an ecosystem of packages for category-theoretic modeling and simulation, building on the Julia programming language. In this release, we added a Julia compute service to our backend infrastructure. At this time, the Julia service is exercised only by a proof-of-concept analysis that converts a diagram over a schema into a tabular instance by invoking machinery in Catlab.jl. In the future, we will use the Julia service to provide advanced simulation capabilities, such as for agent-based models (AlgebraicABMs.jl) and partial differential equations on manifolds (Decapodes.jl).

Notebook history

When you made changes to your notebook, snapshots are now stored of the notebook history. This means that you can undo/redo changes, as well as view the entire history and jump back and forwards between time-stamped edits.

Public RFCs

Those interested in the development of CatColab can already follow our pull requests and issues on GitHub, as well as our conversations on our Zulip. But sometimes the best format for a discussion is closer to that of a blog post, or extended abstract, where a single author describes their vision for a feature, and often the mathematics supporting it, and then shares it with the rest of the team (and the wider community). Such discussions are now recorded as requests for comment (RFCs) and can be found at next.catcolab.org/rfc. To quote from that page:

A distinctive feature of RFCs compared to other kinds of documentation is that they represent a design at a particular point in time, as envisioned by a particular person. Thus, an RFC should have a date and an author, and there is no expectation that an RFC will be updated over time as its implementation inevitably evolves.

The format of an CatColab RFC is not yet standardized. In organizing the RFCs written so far, we’ve been inspired by the RFC template used by the Rust language.

Composition of Petri nets

Two major features in the previous release were Petri nets and composing models of discrete theories. This release brings these two together! We have extended CatColab’s DoubleTT implementation to enable composing models of modal theories, which means in particular that Petri nets can now be composed along places. As a tiny example, we can start by instantiating the standard SIR model and then add a new state and transition to obtain an SIRV model.

Unbalanced mass-action ODE systems, and equation visualisation

When working with ODE semantics for a model, it’s useful to know which equations are actually being simulated. Doing this by hand is time consuming and error prone, and this is exactly the kind of task that computers are very good at doing. The mass-action dynamics analysis (available for stock-flow diagrams and Petri nets) will now show you the equations generated by your model, with either generic symbolic parameters or numerical parameter values from your simulation.

The mass-action dynamics analysis also has two new settings increasing its generality: mass conservation and rate granularity. This reflects a new (non-standard) capability for mass-action dynamics that do not preserve mass. You can read more about unbalanced mass-action in this blog post and its sequel.

SQL schema definitions

The mathematical history of CatColab can be traced in part to the categorical approach to database theory, as explained by David Spivak and Brendan Fong in Chapter 3 of Seven Sketches in Compositionality. Much of our recent focus has been on quantitative scientific modeling, but we do intend to keep expanding the database capabilities of CatColab. Thanks to Matt Cuffaro, you can now generate SQL schema definitions in several dialects from a schema model in a CatColab. You can read more about this feature in the schema help pages.

Improved graph layouts

To visualise models we make use of graph layout algorithms, which are notoriously sensitive to input data and parameters. Now, in addition to the Graphviz layout engine, you can choose to use ELK (via the package elkjs). This gives you another option to choose from. We have found that ELK’s layered algorithm is particularly well suited to Petri nets.

Rust backend

Following a backend re-architecture, syncing of Automerge documents is now provided by the new Rust crate samod instead of the Node package automerge-repo. This means that 100% of the CatColab backend is now written in Rust 🦀

Document corruption fix

There was a pretty terrible bug related to the rich text editor, which could result in Automerge documents becoming corrupted and thus un-openable. This bug was fixed upstream thanks to the Ink & Switch team. We also now have better systems in place to detect corrupted documents should similar problems arise in the future.

2.1 The exercise

Let me start with the usual disclaimer: I am not an immuno-epidemiologist. In fact, I’m not even close, and have spent the last few months realising how little biology I actually know. But for the purpose of this exercise, this is actually a good thing because it gives an example of the kind of problem that I’m interested in studying: how can people sitting on opposite sides of a domain-specialist boundary better communicate? To be a bit more concrete, if I read a paper on a specific model in immuno-epidemiology and see some graph-like diagrams and systems of ordinary differential equations — things that I understand comparatively well — how can I be more sure that I’m not completely misinterpreting them? One of my preferred ways of teaching/learning is to flip things around and have the student explain things to the teacher, amongst other reasons because this often highlights key misunderstandings that can easily go unnoticed. I think the same thing can work well here:

Anyway, enough preamble. The model in the paper is almost given by the system of ODEs (Hoyer-Leitzel et al. 2023, Equation 1) where the coefficients are described in the parameter table (Hoyer-Leitzel et al. 2023, Table 1), e.g.  is the “viral production rate”, is the “viral clearance rate” , and so on. I say “almost” because I have omitted a smoothing term that multiplies the three appearances of the monomial. The use of this smoothing term is actually one of the novel parts in the paper, and does raise a non-trivial question to the categorical modeller, but I’m going to save that story for another day.

Alongside these quantitative parts, there’s a more high-level diagram (Hoyer-Leitzel et al. 2023, fig. 1) explaining the general processes described by the model, reproduced below.

So here’s what we’re going to do: we’re going to draw our own version of the diagram, building it up bit by bit by grouping together terms in the system of ODEs, using the context given in the parameter table. What this will entail is “pairing up” terms in the ODEs to demarcate them as individual processes. The point is that we will likely not end up doing this in a biologically-correct way, but this method ensures that we have to make some specific choices and commit to these assumptions.

2.2 Rebuilding the model

Looking at the diagram, there’s some interaction between target cells , the virus , and the infected cells . An educated guess tells me that viruses do something to target cells to turn them into infected cells and maybe get “used up” in the process, so this interaction will probably turn up in the equations for , , and . Having heard of mass-action dynamics from e.g. (Baez and Pollard 2017), I would guess that the corresponding terms in the ODEs will be proportional to the product of the inputs, i.e. . Putting this all together, it seems fair to assume that we have a correspondence between the circled part of the diagram and the boxed terms in the equations below:

Looking at the parameter table, we see that and correspond to “rate of viral loss per target cell” and “rate of conversion from target cells to infected cells per virion”, respectively. This seems to confirm our conclusion, so let’s start drawing a diagram for ourselves.

flowchart LR
  T("`**T**arget cells`") --> X[infection]
  V("`**V**irus`") --> X
  X --> I("`**I**nfected cells`")
  classDef transition fill:#53b6b2
  class X transition

flowchart LR
  T("`**T**arget cells`") -->|𝛽'| X[infection]
  V("`**V**irus`") -->|𝛽| X
  X -->|𝛽'| I("`**I**nfected cells`")
  classDef transition fill:#53b6b2
  class X transition

flowchart LR
  T("`**T**arget cells`") -->|𝛽'| X[infection]
  V("`**V**irus`") -->|𝛽| X
  X -->|𝛽'| I("`**I**nfected cells`")
  V -->|𝜇| Y{{antibody-virion binding}}
  A("`**A**ntibodies`") -->|𝜇'| Y
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X transition
  class Y death

flowchart LR
  I("`**I**nfected cells`")
  F("`Inter**f**erons`")
  X{{I-F interaction}}
  Y[interferon production]
  Z{{interferon degradation}}
  I -->|𝜅| X
  F -->|0| X
  I -->|0| Y
  Y -->|𝑞| F
  F -->|𝑑| Z
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X death
  class Y transition
  class Z death

flowchart LR
  V("`**V**irus`")
  I("`**I**nfected cells`")
  F("`Inter**f**erons`")
  X[1]
  I -->|𝛿| X
  X -->|𝑝| V
  X -->|𝑞| F
  classDef transition fill:#53b6b2
  class X transition

flowchart LR
  V("`**V**irus`")
  I("`**I**nfected cells`")
  F("`Inter**f**erons`")
  X{{2a}}
  Y[2b]
  I -->|𝛿| X
  I -.-> Y
  Y -->|𝑝| F
  Y -->|𝑞| V
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X death
  class Y transition

flowchart LR
  V("`**V**irus`")
  I("`**I**nfected cells`")
  F("`Inter**f**erons`")
  X{{3a}}
  Y[3b]
  Z[3c]
  I -->|𝛿| X
  I -.-> Y
  I -.-> Z
  Y -->|𝑝| F
  Z -->|𝑞| V
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X death
  class Y transition
  class Z transition

flowchart LR
  subgraph source
    direction LR
    I1("`**I**nfected cells`")
    V1("`**V**irus`")
    F1("`Inter**f**erons`")
    X1{{3a}}
    Y1[3b]
    Z1[3c]
    I1 -->|𝛿| X1
    I1 -.-> Y1
    I1 -.-> Z1
    Y1 -->|𝑝| F1
    Z1 -->|𝑞| V1
  end
  subgraph target
    direction LR
    V2("`**V**irus`")
    I2("`**I**nfected cells`")
    F2("`Inter**f**erons`")
    X2{{2a}}
    Y2[2b]
    I2 -->|𝛿| X2
    I2 -.-> Y2
    Y2 -->|𝑝| F2
    Y2 -->|𝑞| V2
  end
  source -->|morphism| target
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X1 death
  class Y1 transition
  class Z1 transition
  class X2 death
  class Y2 transition
  classDef box fill:#fff,stroke:#555
  class source box
  class target box

flowchart TB
  subgraph dagger ["Diagram (†)"]
    direction LR
    V("`**V**irus`")
    B("`**B**-cells`")
    X[X]
    V -.-> X
    X -->|"𝑚₁(1-𝐵)"| B
  end
  classDef transition fill:#53b6b2
  class X transition
  classDef box fill:#fff,stroke:#555
  class dagger box

flowchart TB
  subgraph ddagger ["Diagram (‡)"]
    direction LR
    V("`**V**irus`")
    B("`**B**-cells`")
    X[X]
    Y[Y]
    V -.-> X
    X -->|𝑚₁| B
    V -.-> Y
    B -->|𝑚₁| Y
  end
  classDef transition fill:#53b6b2
  class X transition
  class Y transition
  classDef box fill:#fff,stroke:#555
  class ddagger box

flowchart LR
  V("`**V**irus`")
  subgraph boxed ["V–B interaction"]
    X[X]
    Y[Y]
  end
  B("`**B**-cells`")
  V -.-> X
  X -->|𝑚₁| B
  V -.-> Y
  B -->|𝑚₁| Y
  classDef transition fill:#53b6b2
  class X transition
  class Y transition
  classDef box fill:#fff,stroke:#555
  class boxed box

flowchart LR
  V("`**V**irus`")
  T["V–B interaction"]
  B("`**B**-cells`")
  V -.-> T
  T --> B
  B --> T
  classDef boxed-transition fill:#53b6b2
  class T boxed-transition

flowchart TB
  T("`**T**arget cells`")
  V("`**V**irus`")
  I("`**I**nfected cells`")
  F("`Inter**f**erons`")
  A("`**A**ntibodies`")
  B("`**B**-cells`")
  X0[⚠️ target-cell growth ⚠️]
  X1[infection]
  X2{{interferon interference}}
  X3[virus production]
  X4[interferon production]
  Z3{{F death}}
  Y1[B-cell activation]
  Y2[antibody response]
  Y3[antibody-virion binding]
  Z1{{V death}}
  Z2{{I death}}
  Z4{{A death}}
  Z5{{B death}}
  T --> X0
  I --> X0
  X0 --> T
  T -->|𝛽'| X1
  V -->|𝛽| X1
  X1 -->|𝛽'| I
  I -->|𝜅| X2
  F -.-> X2
  I -.-> X3
  X3 -->|𝑝| V
  I -.-> X4
  X4 -->|𝑞| F
  V -.-> Y1
  Y1 -->|"⚠️ 𝑚₁(1-𝐵) ⚠️"| B
  B -.-> Y2
  Y2 -->|𝑚₃| A
  V -->|𝜇| Y3
  A -->|𝜇'| Y3
  V -->|𝑐| Z1
  I -->|𝛿| Z2
  F -->|𝑑| Z3
  A -->|𝑟| Z4
  B -->|𝑚₂| Z5
  classDef transition fill:#53b6b2
  classDef death fill:#ddd,color:#555
  class X0 transition
  class X1 transition
  class X2 death
  class X3 transition
  class X4 transition
  class Y1 transition
  class Y2 transition
  class Y3 transition
  class Z1 death
  class Z2 death
  class Z3 death
  class Z4 death
  class Z5 death

2.1 Example: The flow

Consider the flow on generated by . Its phase portrait is shown in Figure 1.

Consider the following maximal invariant sets: Since the compact neighborhoods are attracting neighborhoods the following sets are attractors. As in any dynamical system, the empty set is always an attractor and a bottom element of the attractor lattice, ordered by inclusion. Thus, the attractor lattice for this system is shown in Figure 2.

Even though and are maximal invariant sets they not attractors. Note that and are compact neighborhoods but they are not attracting. This one-dimensional system illustrates attractors and their lattice structure.

3.1 Decoupled case: vs. 

To study the relationship between the attractor lattice of a product system and the attractor lattices of its components, we begin with the following decoupled system

Their attractor lattices are shown in Figure 3.

A natural question is how the cartesian product compares to the attractor lattice of the product system. The comparison is shown in Figure 4.

Notice that contains strictly more elements than . To connect the two lattices we just compared, it helps to introduce the idea of realization maps. Our goal is therefore to construct a suitable realization map that connects the two lattices. For instance, pairs involving the empty set such as or are both realized as the empty set in . On the other hand, pairs not involving the empty set are faithfully realized; for example, This discrepancy motivates the introduction of the realization map next. Given two attractors and , we can form their Cartesian product . This motivates the map

The map is a meet–semilattice homomorphism. However, it is not injective because of pairs that include the empty set. To fix this, we identify all such pairs using . After this identification, we obtain the induced map which is now injective.

One important result here is that this map is not always surjective. This means that there are emergent attractors in the product system that cannot be written as a direct product of attractors from the two subsystems. We will next look at an explicit example of this.

3.2 Corners the product forgot

To see why surjectivity fails, consider the following decoupled system with phase space . Its phase portrait is shown in Figure 5. Each subsystem has the attractors , , and .

Now, the realization map of this example is shown in Figure 6.

However, the product system admits additional attractors that do not arise as simple Cartesian products. In particular, there is a “corner” attractor which is a result of the interaction of both systems. It belongs to but is not in an image of . Interestingly, the missing attractor can be recovered algebraically: If we close the image of under joins, we obtain the full lattice in the continuous case. One of my projects was to investigate whether the following equivalence holds: where denotes join-closure. However, for discrete maps, this remains only a sublattice of .

This shows that while the map provides a faithful embedding of the product of lattices into the combined system lattice, it does not capture all attractors of the product system in general: new attractors may appear that are not simple products.

Petri nets

Petri nets are important and widely used graphical formalism for modeling processes that can consume and emit typed tokens, from concurrent computer systems to biochemical reaction networks. To quote from catcolab.org/help/logics/petri-net:

Petri nets were invented to express discrete-event dynamical systems with concurrency, or networks of resources and processes, describing how various states (called places) relate to one another in terms of transitions. Each transition has incoming and outgoing arrows (called arcs) connected to places, which describe the input and output places of the transition (respectively).

One way of understanding Petri nets is through their token semantics. We place a number of “tokens” in each place and then check all the transitions to see if all their input places have a token: if so, then we can “fire” the transition, moving the tokens from the input places to the output places; if not, then nothing happens. In many classical references the token semantics are built directly in to the definition of Petri nets (often called a marking or tokening), but an unmarked Petri net is already itself a useful formal gadget, analogous to how can be useful to consider an ordinary differential equation without giving its initial conditions.

Quite a few category theorists have written about Petri nets; some of John Baez’s blog posts give a pretty comprehensive overview. There is a plethora of literature concerning Petri nets in all their various flavours and guises, and it’s a non-trivial task to try to figure out where different sources actually agree or disagree. The version that we currently have implemented in CatColab is that of free presentations of symmetric monoidal categories, though you don’t need to actually care about this in order to be able to use them.

For an example, below is a screenshot (and a link to the CatColab notebook) of a Petri net describing the pathway by which a certain bacteria breaks glucose down into lactate, taken from an introductory book on systems biology.

With this new logic there come also three new analyses, thanks to some grand efforts:

1. ODE simulation based on population-level mass-action dynamics
2. Stochastic simulation based on individual-level mass-action dynamics (thanks to Matt Cuffaro!)
3. Model checking of sub-reachability from initial state (thanks to Kris Brown!)

For full details, you can read the Petri nets documentation, but in brief the first analysis checks whether or not certain tokening states can be reached from a given initial state, and the second and third analysis simulate so-called mass-action dynamics, which envisions Petri nets as describing concentrations of quantities and the reactions that can take place between them. The third analysis, in particular, in particularly exciting, since it is the first instance of a stochastic analysis inside CatColab.

Compositional models (of discrete theories)

Something that we at Topos have been talking about for a while as a fundamental capability of a categorical approach to modelling (far from just in conversations about CatColab) is the ability to compose models. If somebody has made a model describing some system, which I then want to view as a component of my other system, I would like to able to instantiate it and use it within my model. This is now possible for certain theories¹ in CatColab!

As a small example, we can create a causal loop diagram with two variables, one positive link, and one negative link: This is a “toy model” (or, more properly, a motif) for a general predator–prey scenario, where an increase in the population of prey can cause an increase in the population of predators (more food for them to eat), but such an increase can cause a decrease in the population of prey (more predators to eat them).

Now say we want to actually build a two-level model, where we have foxes, rabbits, and grass. Here the foxes and rabbits form a predator–prey relationship, as do the rabbits and grass, so we would like our model to reflect this symmetry. In CatColab, we have a new cell type: Instantiate. This lets us import an existing model and bind its exposed variables to those in our larger model, as we show in the screenshot below.

Even this relatively simple example illustrates the idea that many complex models are built out of a library of such “standard components”.

Those of you familiar with object-oriented programming, or structs in languages like C or Rust, might find the notation rather suggestive, where we write Rabbit–Grass.feeds to refer to the feeds arrow in the Rabbit–Grass instantiation. This blog post isn’t the place to delve properly into this analogy, but we will at least mention some of the mathematics here.

Under the hood, the compositional models feature of CatColab is based on recent work by Owen Lynch on DoubleTT (where the TT stands for type theory), which is what allows for our implementation of instantiation. The test.dbltt.snapshot example showcases some of the functionality of DoubleTT. For example, we can define a type called Graph as

type Graph := [
  V : Entity,
  E : Entity,
  src : (Id Entity)[E, V],
  tgt : (Id Entity)[E, V]
]

and we are then able to define a type called Graph2 as

type Graph2 := [
  V : Entity,
  g1 : Graph & [ .V := V],
  g2 : Graph & [ .V := V]
]

which results in the type that we get from taking two copies of Graph and “gluing them along their vertex object”, i.e. the type of a graph with two colours of edges.

Documents and landing page

Since joining our team not so long ago, Kaspar Bumke has been hard at work in overhauling the user experience. One of my personal biggest complaints was that every time I opened up CatColab it created a new blank document, which was compounded by the fact that there was no ability to delete documents. Both of these usability problems, amongst others, have now been solved!

The landing page for CatColab is now a nice splash page with all the useful links, including one to “My documents”, and when viewing your documents you can soft delete them (i.e. move them to a recycling bin and recover them at a future date). This is just the start of a much larger project focussed on improving UI/UX around documents.

Rich text and UI refresh

As in the screenshot of the L. lactis glycolysis Petri net model above, analyses open in a side-pane as opposed to a whole new page, making it much easier to understand how analyses change as you modify the underlying model. With v0.4, this panel-based navigation is now present throughout all of CatColab! Not only that, but analysis documents are now first-class, in the sense that they can be named, permissioned, and shared just like any model document can.

Another thing from the Petri net screenshot that’s a bit more subtle, but just as useful, is the capability to have rich-text cells within a model. This means that we can support not just formatting like bold and italic, but also links and mathematics (rendered with KaTeX). Getting this to work has been remarkably subtle, and it’s really thanks to Jason Moggridge for fixing the myriad of little frustrating bugs that blocked us from releasing this for so long. The basic issue is that our rich-text support is based on automerge-prosemirror, which uses features of the Automerge document format going beyond standard JSON. So we had to re-architect our backend to make Automerge docs, rather JSON objects, the source of truth. This was supported by our friends over at Ink & Switch, who are the lovely people behind Automerge itself.

2.1 Example: polynomial functors

Especially simple are expressions subject to no equations, which correspond to freely generated -sets (presented by generators and no relations).

For instance, suppose we are interested in a binary expression , a binary expression , a binary expression , and a unary expression , together satisfying no equations.

This corresponds to a -set where, as always, is the set of expressions filled with elements of .

In this example, may be described by the formula Here is the set of -tuples of elements of , that is, the set of functions , counting the possible ways of filling an -ary expression with elements. The functor with formula itself is the -set presented by a single -ary generator and no relations.

(This is the Yoneda lemma: representable -valued functors are free on one generator.)

In general, such freely generated -sets are called polynomials, since they are described by formulas

2.2 Technical aside: support

Suppose is a -set and . If as usual we interpret as an expression filled with elements of , a simple question to ask is: which elements of appear in ?

For instance, in either of the earlier examples, the expression features only the element . The expression on the other hand features only the element , and the expression features both elements and . This seems to be a simple idea, but it is actually subtle.

This means that can be expressed such that it only features elements of . Above, is a strong support of but neither nor .

Perhaps counterintuitively, it is not necessary for to have a smallest strong support. In fact, strong supports are not in general even closed under finite intersections. Consider a unary expression subject to the equation , effectively eliminating the dependence of the expression on . This corresponds to a -set such that is empty if is empty and otherwise has one element.

Although the subsets and of are both strong supports of the expression , their intersection, the empty subset, is not.

A slightly different definition can partially resolve this defect. To aid readability we use the “action” notation to denote where and .

This means whenever and agree on , their relabeling actions agree on , i.e.  only “depends on” elements in . With this definition, one can show that any finite intersection of supports of is again a support of .

(The two definitions are extremely close: strong support implies support, and conversely support implies strong support for all subsets that are nonempty.)

However, it is still not necessary for to have a smallest support, if we consider infinite expressions. Consider an expression involving a sequence of infinitely many elements, subject to the infinitely many equations

effectively eliminating the dependence of the expression on any single . In the corresponding -set , the set consists of “sequences in modulo eventual agreement”: two sequences are equivalent if they agree on all but finitely many indices. Here a sequence with infinitely many distinct elements has no smallest support, because a support is a subset including all but finitely many of the elements in the sequence, and there is no smallest such subset.

Although may not have a smallest support, it does have a filter of supports. That is, supports are closed under supersets and finite intersections, analogous to the neighborhoods of a point in a topological space. (Conversely, for any filter on a set , one can construct a -set on an -ary generator whose supports are the subsets of in , via appropriate relations.)

In summary, an infinite expression (modulo equality) may have no particular smallest set of elements it depends on. Thus an operation may only depend on ever-shrinkingly small subsets of its inputs. Dually, a co-operation might output an “infinitesimal neighborhood”, in the sense that only elements within ever-shrinkingly small subsets of its outputs have assigned values. For this reason there is a close relationship between topological spaces and coalgebraic structures.

3.1 Directed multigraphs

Directed multigraphs (a.k.a. quivers) can be modeled as coalgebras, using an edge co-operation and a vertex co-operation.

The edge co-operation has two outputs ( and ), and the vertex co-operation has zero outputs. Together these two expressions and generate a polynomial (i.e. freely generated) -set:

Pictured below is a directed multigraph with four edges and four vertices, providing an example of a coalgebra . In this case the set has ten elements, four of which are assigned the edge co-operation, each thus outputting two elements, and six of which are assigned the vertex co-operation, each thus outputting no elements.

Not all coalgebras of this -set cohere as directed multigraphs: it is necessary to impose the additional condition that the two outputs of each edge are vertices, not edges. The the ability to specify such conditions on coalgebras is provided by the concept of a comonad.

Note that a directed multigraph may be equivalently described as a functor -set (a functor ) where is the category:

In general, -sets for any category can be modeled as coalgebras of a polynomial -set. Namely, there is a co-operation for each object, whose outputs are all the arrows out of the object.

(In the directed graph example above, the identity arrows were omitted from the co-operations for simplicity. If they were included, then would become an operation with three outputs , , and , and would become an operation with one output . The corresponding polynomial -set has formula .)

Additional associativity and unit constraints are needed to ensure the elements and assigned co-operations cohere as a -set. For any category , there is a comonad on whose coalgebras are -sets. In fact, it was noticed only relatively recently (Ahman and Uustalu 2016) that comonads on given by polynomial formulas are precisely the same as (small) categories.

Viewing a -set as a coalgebra, the co-operation assigned to an element specifies the type of the element and produces at once all elements derived from that type. The same intuition may be applied to more general coalgebras of -sets.

3.2 Undirected multigraphs

There are coalgebraic structures besides -sets, for example undirected multigraphs.

In this case the two vertices output by the edge co-operation are unordered pair instead of an ordered pair. The generating co-operations and are as before, but this time with the relation . The undirected multigraph below is an example of a coalgebra for the presented endofunctor.

As in the case of directed multigraphs, there is a comonad on whose coalgebras are undirected multigraphs. Perhaps it is reasonable to call this a “generalized category” , for which “-sets” are undirected multigraphs.

3.3 Sheaves

This final example is intended to whet your appetite, so do not be disturbed if some aspects remain puzzling.

A sheaf is a way of gluing regions of a topological space together into a larger space that locally resembles the original space. It can be modeled as a coalgebra, using a co-operation for each point of , outputting the points in its “infinitesimal neighborhood”.

That is, sheaves over are coalgebras for a -set generated by a co-operation in for each point whose supports (see earlier section) are exactly the neighborhoods of . More specifically,

where is the neighborhood filter of . In terms of generators and relations, this -set is defined as follows: for each point , there is a -ary generator for each neighborhood , all of which are identified so as to only retain dependence on the elements that are within arbitrarily small neighborhoods of . This determines a co-operation that essentially outputs an infinitesimal neighborhood’s worth of elements.

Again, additional associativity and unit constraints on a coalgebra are needed to ensure that the coalgebra coheres as a sheaf, and again this is captured via comonad structure. For any topological space , there is a comonad on , with the above formula, whose coalgebras are sheaves over , and the topological space can be recovered from the comonad. In this way, like categories, topological spaces are identified with a certain class of comonads on .

In fact, topological spaces play the same role in relation to general comonads on as preorders do to categories. To learn about this analogy and related curiosities, stay tuned for the upcoming paper

where we will push as far as we can the perspective that comonads on are a common generalization of both categories and topological spaces.

2.1 Axioms and Rules of PLTL

Suppose we have a countable set of atomic propositions, denoted . We can then consider all the well-formed formulae constructed from using (assuming a classical logic), which achieves the propositional part of PLTL.

Suppose we wish to consider how the truth value of propositions may change over time. How should we interpret time?

One way to view time is as a linear timeline in countably many discrete steps, starting from the present and heading to the future. We observe this as a -sequence of time instants for , where marks the present moment.

At each time instant , we evaluate whether a proposition is true or not at that instant. We also consider how the future looks from : this leads to defining the notation , which is simply the linear timeline starting from time instant . Thus, we formally view as the subset of well-formed PLTL formulae which are true at that time instant.

We introduce two temporal connectives alongside the two classical connectives and : , a unary operator denoting the neXt time instant, and , a binary operator where denotes holding , from which we can recursively build well-formed formulae of PLTL from and the atomic propositions in .

The truth of a PLTL formula is evaluated at these -sequences. We define if and only if the formula is true of the sequence by recursion:

• ,
• if and only if , for any atomic ,
• if and only if ,
• if and only if and ,
• if and only if ,
• if and only if there is some such that and for each , .

We then define satisfiablity and logical validity, , as usual. We also define two derived temporal connectives: for a future operator and for a guarantee/global operator.

There is also, of course, a syntactic side to this story²; what we just described is a sound and complete semantics for the associated notion of proof (Reynolds (2001)). We use this deductive system to define a notion of derivability in the usual manner.

2.2 Free-Forgetful Adjunctions of Algebras and (Po)Sets

Let us observe the following adjunctions and the fact that Boolean algebras and Heyting algebras may be seen as the respective algebras for classical and intuitionistic logic:

One may ask for an analogy with PLTL. To this aim, we must answer what a PLTL algebra is, what the morphisms between PLTL algebras are, and what the free construction of a PLTL algebra looks like on a poset. This will allow us to consider PLTL algebras as a category, which we can use to temporalise statements later!

2.3 The Eilenberg-Moore Category of PLTL Algebras

Of course⁵, this construction is functorial, and we may observe the following free-forgetful adjunction:

From this adjunction, we obtain a monad , where: * sends a poset to a poset corresponding to the free PLTL algebra of ; * is the unit that sends to ; and, * is the multiplication that maps a formula-of-formulae to a formula.

It is worth explaining further with some examples. First, observe that elements of are equivalence classes of PLTL formulae, generated by elements of , which are themselves equivalence classes of PLTL formulae over . Examples include:

• 
• 
• .

Intuitively, collapses a formula-of-formulae into a formula by interpreting each inner equivalence class as any element of , such as , in , then evaluating the formula as an equivalence class. For example, with the first example above:

• The constants are .
• Applying , we map each inner equivalence class to an element of , such as . Thus, .
• Then, we evaluate this as an equivalence class, so:

Similarly, and

That this works is because the equivalence class of a formula-of-formulae in does not depend on the choice of representatives of the inner equivalence classes.

As with any free-forgetful adjunction, we may now consider the Eilenberg-Moore category induced by this monad , whose objects are -algebras .

One may understand an object of as a poset equipped with an interpretation map, where the generators of (so the elements of ) are interpretated as themselves and a consistent interpretation is chosen for formulae, subject to the requirement that evaluating these formulae respects substitution.

One can then prove an equivalence between and , thus showing a PLTL algebra is practically the same as an -algebra.

2.4 Hyperdoctrines and Temporalisation

Here is how everything relates to José’s work (see Siqueira 2025)!

Suppose the following set-up:

• is a comonad on , so is a monad on ,
• is a monad on , which represents a modality acting on such as , and
• is a hyperdoctrine. That is, a functor to that encodes a flavour of logic, such as classical or intuitionistic propositional logic.

In his recent work, José Siqueira proved that (regular) hyperdoctrines are the same as symmetric monoidal double functors with a companion commuter property. Further, we know that the 2-category admits the construction of algebras; i.e, the inclusion has a right adjoint where is the 2-category whose:

• objects are monads in the 2-category , i.e monads on double categories with respect to pseudo double functors and tight transformations;
• 1-cells are lax morphisms of such monads;
• 2-cells are 2-morphisms of monads.

Now, if preserves pullbacks, then induces a monad on the double category of spans over via the span construction:

Similarly, we get an induced monad in . Then, we get a pseudo double functor whenever we have a map of monads from to by the 2-functoriality of .

It is also known that . Therefore, a map of monads from on to on induces a symmetric monoidal double functor from to , which is the same as an existential hyperdoctrine. This therefore allows us to consider coalgebras of as contexts for a hyperdoctrine with semantics in -algebras.

With this result in mind, let us apply this to our situation, in which , is the functor that sends an object to its collection of subobjects in and a morphism in to , and is the monad induced by the free-forgetful adjunction between and , with unit and multiplication as before.

The key intuition is to view the comonad on as providing an interface, so that provides a notion of a predicate on this interface. With the result described before, we may then upgrade this predicate to a temporal predicate on systems.

Thus, we ask for which ⁶ comonads (so interfaces) we can upgrade, given our which provides a notion of predicate (in classical propositional logic). That is, for which is such that there exists a natural transformation such that the following diagrams commute:

For us, important examples may come from considering the cofree comonad on various polynomial functors, denoted as defined in Libkind and Spivak (2024). Let us consider such an example below.

2.5 Future Directions

From here, there are many natural research directions to explore.

We had provided a category of PLTL algebras, , based on constructing the Lindenbaum-Tarski algebra of the theory of propositional linear temporal logic. As stated before, PLTL is one of many possible temporal logics, grounded in a specific philosophical interpretation of time as starting from the present and extending to the future in discrete, countable time steps. There are many other temporal logics of interest, and we ask whether they may undergo a similar treatment to PLTL. Of particular note are the following logics:

• Intuitionistic Linear Temporal Logic, as explored in Balbiani et al. (2019) and Fernández-Duque, McLean, and Zenger (2024), which may allow us to upgrade classical predicates on states to intuitionistic temporal predicates on streams.
• Doxastic Logic, as explored in Rönnedal (2018) or Zhang et al. (2025), which may allow us to hold epistemic predicates on streams as opposed to temporal predicates.
• Computation Tree Logic, as explored in Reynolds (2001), which may allow us to consider predicates on branches of streams, as opposed to only a linear timeline of streams as we currently see with the stream comonad.

With any monad in our set-up, a natural question is which comonads allow for the hyperdoctrine to be a map of mornads, such that this upgrade of predicates is possible. This is particularly interesting when we allow to be the cofree comonad of polynomial functors .

As described before, it could be the case that, for , the only polynomial functors for which allows for such a construction is when for : that is, for unary polynomials with no constants. Though limiting, it suggests that we ought to consider other logics (such as CTL) which can account for more sophisticated system behaviours (primarily, branching behaviours).

We can also change the hyperdoctrine itself to reflect the underlying logic that we temporalise via PLTL. Primarily, if one develops a hyperdoctrine that accounts for a static form of doxastic logic, then setting to be a monad induced by a free-forgetful adjunction of temporal algebras (such as PLTL) allows one to consider a dynamic or temporal doxastic logic that can apply to systems. In Dagnino and Rosolini (2021), they show that modal interior operators may be constructed from adjunctions in the 2-category of doctrines. Likewise, one could instead consider a temporal hyperdoctrine , then upgrade it with a doxastic monad. That there may be two ways to approach this might imply two interpretations of a logic affected with temporal and doxastic modalities, the priority of which depends on the set-up. This suggests a potentially novel way to define dynamic doxastic or temporal doxastic logics.

1.1 Graphs

Our first example of an incrementalized query is in the context of relational databases. We will focus in particular on databases with the schema , whose instances are (directed, multi-)graphs. The kind of query we can incrementalize is a conjunctive query, such as “give me all pairs of edges such that the target of the first edge is the source of second edge”. Interestingly, we can represent this query with a graph itself, , now regarded as a “pattern” rather than a piece of concrete data. Call this query .

Thinking of the query itself as a special graph also illuminates what answers to our query look like: applying our query to some graph is tantamount to finding all graph homomorphisms . The data of each such homomorphism (an assignment of vertices and edges) can be thought of as binding the variables that live in to the values in . For example, if , then the answers to the query are:

• (shorthand for )¹
  
• 

One way to describe how a graph can evolve over time is a rewrite rule: for us, a rewrite rule is a graph homomorphism where the domain is the pattern and the codomain is the replacement. In the following example, we consider a rule, , which says “given some edge, construct a path of length two which goes from its source to its target”. The pattern of the rule says “given an edge from to ” and the replacement of the rule says “add in a new path of length two going from to ”. An example application of this rule to some graph, , requires a match to specify how the rule is to be applied, as shown below.

So, if our non-incremental query is “what are all paths of length two?”, the incrementalization problem is “If I assume I have all the paths of length two in some arbitrary and I apply the rule (which yields some as result), what should I do to find the new paths of length two in ?”

Given that we already had and , the matches which we need to discover are and . This can be seen by inspection, but we need an algorithm to do this for an arbitrary and match . Keeping and fixed, it’s possible to intuitively deduce the optimal thing to do: there are three independent ways to get a new answer for by applying to an arbitrary graph :

1. One which will always be introduced by the rule directly ( in our example)
2. One per outgoing edge from the target of the edge we apply to (this yields just in our example)
3. One per incoming edge into the source of the edge we apply to (this yields no matches in our example)

1.2 Datalog

A Datalog program has a collection of facts about some ground terms as well as rules for deriving new facts from old ones. As shown in the previous post, we can think of the execution of a Datalog program categorically as a sequence of pushouts in a category . This is a natural case for applying incremental query updating, since applying rules then triggers new rules which can be applied.

For example, consider the rule, : path(X,Z) :- path(X,Y), edge(Y, Z).

Applying makes possible new match possibilities for ’s preconditions. Can we say how to specifically look for new composable path + edge pairs in light of applying to an arbitrary input? Yes, the solution is to look for outgoing edges from whatever vertex was Z in the previous rule application.

1.3 Other examples

This post focuses only on incremental updating with respect to rules which purely ‘add things’ in some sense. A followup post will discuss rules which merge or delete, which will be required to talk about some other interesting applications of this approach, including:

• E-graphs (e-saturation steps as applying rewrite rules, incremental hom search to speed up e-matching)
• Regex
• Multiset rewriting (Martens et al. 2023)

2.1 A dictionary for category theory concepts

Informal term	Categorical analogue
Setting for incremental search problem	An (adhesive2) category
Pattern / Query	An object,
State of the world / set of facts	An object
Pattern match of in	A morphism
Answer set to a query in state
An (additive) rewrite rule, with pattern and replacement	A monomorphism
Application of a rewrite rule to state with matched via	A pushout of and

2.2 Algorithm

Describing an algorithm categorically is a double-edged sword — we’re abstracting away from implementation details, with the benefits of getting to the essence of the algorithm and making it possible to apply it in a wide variety of settings. On the other hand, the algorithms do need to eventually be implemented, details and all. A balance is struck below by making certain informal computational assumptions about the category we work in: namely we can compute certain things, like small (co)limits, with some known computational complexity in whichever we instantiate our algorithm.

With reference to variables in the above table, our algorithm’s job is to systematically find new answers to in while avoiding any work that might recover the answers we already had in . More formally, the basic case of the incremental search problem is: when we are given as above at runtime, we need to compute (where denotes post-composition).

2.3 Solving the basic case

2.4 An optimization when has complements

The previous algorithm might be unsatisfactory in two ways:

1. There are a lot of ways to express as a pushout. We have to iterate over all of them.
2. It might seem wasteful that we had to filter candidates by those which formed a pullback square, just because adhesive cube side faces are always pullbacks.

We can address both these issues when has complements.

Once we have this structure, we can succinctly express the optimized algorithm. We solve the incremental problem by doing the same procedure as before with two changes:

1. Only consider decompositions where .
2. Allow all of the the extensions of the partial map from to to be maps used to induce new matches .

2.5 Batch update from multiple rule firings

We can apply many additive rewrites at once with a single colimit, rather than as an artificially-ordered sequence of pushouts.

A match into the result of multiple simultaneous rewrites has a corresponding decomposition of the pattern into a colimit of subobjects of the same shape. The case induced adhesive ‘multicube’ is shown below:

Our algorithm generalizes: at compile-time enumerate possible nontrivial decompositions of with the above shape and all interactions of subobject morphisms with rewrite rules. At runtime, some finite family of rewrite rules (e.g. ) will have been executed with corresponding matches . We loop over possible partial multicubes and look for morphisms that lead to pullback faces above all of the matches, each of which uniquely results in a new match .

WarningOptimized version when has complements

There is also an optimized batch algorithm that requires just looking for maps that commute with all and rather than filtering for ones which furthermore satisfy a pullback property. In brief, we require : this codifies that we want each interaction to be as small as possible.

2.6 Nonmonic matches

Nonmonic matches can implicitly quotient parts of the pattern, leading to new possible ways a match for a pattern could be created. For every possible , we can compute the corresponding quotiented rule at compile time. At runtime, we epi-mono factorize any nonmonic match and use the previous algorithm with the quotiented rule. This is shown schematically below:

By factoring the pushout square into a pushout of epis and a pushout of monos, we can ignore the top pushout square and pretend our rewrite rule was all along, now with a monic match . A particular example is shown below.

Applying our triangle rule to a loop rather than an edge between distinct vertices leads to a new kind of path of length two that can appear (the two newly-introduced edges, but now in the opposite order), which wouldn’t be detected by our algorithm using the unquotiented rule.

1.1 First example category: graphs

The objects of are directed multigraphs (hereafter: graphs). A graph consists in a set of vertices and a set of edges , where each edge has designated source and target vertex given by functions and .¹ Morphisms in are graph homomorphisms.²

• The path graph of length two, , can be thought of as a piece of data.
  • We can informally put labels on the vertices to help us refer to parts of the graph.³
  • E.g. this (very same) graph could also have been drawn as .
• However, we can also think of this same graph, , as representing a conjunctive query, one which could be applied to other graphs: “Find me an edge () and an edge () such that ’s target equals ’s source.”
  • In this case, the labels are like variable names.
  • In this post, we mark this attitudinal distinction by labeling graphs we are thinking as queries with letters. Graphs thought of as data will be labeled with numbers.

Above are two attitudes one can take towards a graph. An attitude one can take towards a morphism from a query to data is that of a pattern match, i.e. an answer to the query . If we take a different attitude to this morphism , thinking of it as between two different queries, we would call the morphism a rewrite rule. An example rewrite rule is . This rule is saying “if you give me a vertex, , I can turn it into a vertex with a loop.”⁴

Applying this rewrite rule morphism to some graph , requires choosing whether or or . This is precisely the data of a match morphism from into . Suppose we take the map which represents : taking the pushout has the effect of substituting for , yielding . There is no such loop in , but applying the rewrite rule makes the minimal change to required to make the answer true.

Let’s look at one more example: the rule “if you gave me an edge, I could give you path of length two which has the same source and target”. Applying this rule requires a match morphism assigning two variable vertices and one variable edge:

Note because this rule didn’t bind anything to , it’s not obvious what label we should informally give the newly introduced vertex. If we applied the rule multiple times, we would continue to generate a new vertex (and two new edges) each time.

1.2 Second example category: Datalog

Let’s attempt to understand the logic programming language Datalog categorically. The key concepts here are relation, fact, constant, variable, rule, and query. For example one can write some facts about a binary edge relation and constants v1, v2, and v3.

edge(v1,v1). edge(v3,v3). edge(v1,v2). edge(v3,v2).

When someone writes a Datalog program, there is a starting set of ground facts (which are facts about constants). There are also rules, which have two parts, known as the head and the body (written HEAD :- BODY.⁵). We can think of the body as the preconditions of the rule and the head as the postcondition(s).⁶ An example of a rule (which involves both variables and constants) is:

edge(v1,X) :- edge(X,X), edge(X,v2).

This says that: “if you give me any vertex with a self loop and edge into v2, I’ll give you an edge from v1 into ”. If we ran the Datalog program with this rule and the ground facts above, we would derive the fact that edge(v1,v3) because, if one queries the preconditions, one can get an answer X=v3 which then gets plugged into the postcondition. One can imagine making these moves until there are no further changes in the set of facts: this is called the Herbrand model of the Datalog program. The sets of facts which we encounter along the way to the Herbrand model are called Herbrand interpretations (hereafter: interpretations).

We want to think of the initial collection of ground facts as an interpretation, an update that brings us closer to the Herbrand model as a morphism of interpretations, the rule as a morphism preconditions -> postconditions of interpretations, and the finding of a set of terms that satisfies the preconditions as a morphism of interpretations preconditions -> current_interpretation. Furthermore, we want this update morphism to shake out as the result of taking the pushout in this category. Let’s craft a definition to make this happen!

Tip definition (concrete)

Fix some signature assigning arities to a set of relation symbols. Let be some set of constants. We define (hereafter just and will be implicit) to be the category of interpretations and interpretation morphisms, where:

• An interpretation consists of a set of ‘variables’, as well as relations on for every relation symbol of arity .
• A morphism of interpretations is a function , assigning variables to either constants or variables,⁷ that preserves whatever relations are in .

So to interpret the example rule above as a morphism , we must take to be edge(X,X), edge(X,v2) and to be edge(v1,X), edge(X,X), edge(X,v2). Note that, because these rules tell us how to add facts (never removing them), we should always think of the preconditions as implicitly included in the postconditions. We have and with the morphism data the function sending , which preserves the relations in because extends the set of facts of .

It will be easier to show that this category has pushouts when defined in a more abstract way.

Tip definition (abstract)

Given a signature we define the category to contain an object as well as morphisms for each . There is an associated finite limit sketch which adds limit cones asserting that its models have, for each , that are jointly monic.⁸

We define to be the the category of models of , which is subcategory of . As a category of limit sketch models, is a reflective subcategory whose reflector quotients each , merging together elements that agree on all values of . Reflective subcategories of cocomplete categories are cocomplete, with colimits computed by first including into the larger category, performing the colimit there, and then applying the reflector to coerce the result back into the subcategory.

Constants are handled via coslicing: let be , where is the functor with and for all . Note that coslices of categories with pushouts have pushouts, computed in the base category.

Consider interpretations that have just a binary edge relation. These are pretty similar to graphs as defined in the previous section; however, there is no notion of multiple edges. Also the vertices can have fixed, stable identities: although the graph is isomorphic / not meaningfully different from because the labels are not meaningful, an interpretation whose only fact is edge(v1,v2) will not be isomorphic in to one whose only fact is edge(v2,v1), if v1 and v2 are constants.

To see these pushouts in action, consider applying the rule above, using the depicted match morphism (i.e. answer X=v3 to the query of the rule’s preconditions). Note we distinguish variables from constants by using red for variables:

Note that X=v1 was also a valid answer to the query. However, in , the pushout does nothing, rather than adding another loop to v1:

Each answer to the query of a Datalog rule’s preconditions is a potential way to ground the rule, which can potentially add a new fact and bring one’s interpretation closer to the Datalog program’s Herbrand model.

A common extension, Datalog, allows for the heads of rules to introduce new terms. For example, the rule “if you gave me an edge, I could give you path of length two which has the same source and target” is expressed as:

edge(X,Z), edge(Z,Y) :- edge(X,Y). # note "Z" not in body of rule!

This is actually the natural interpretation of , though we could restrict to a subcategory which has no ability to introduce terms: to do this we would require all rule morphisms to have their underlying function be of the form .

5.1 Rewriting over a fixed diagram

The simplest rewrites change the e-diagram without changing the diagram it is over. Given a rewrite rule of the form

along with a match of its left-hand side, namely any map in , we take a pushout

to obtain a new e-diagram over . We use the fact that initial functors are stable under pushout.

TipRule: congruence reduction

Each morphism in generates a rewrite rule

that can be applied in this fashion to perform congruence reduction in .

TipRule: equation introduction

Any path equation in , say , generates a rewrite rule

where the checkmark indicates that the square in the indexing category itself commutes. Thus, at the expense of using diagram shapes that are not free, we can apply an equation in using a single initial functor, rather than a span of initial functors as in previous post.

5.2 Rewriting the diagram itself

Given a rewrite rule in as above along with a match , now in , we produce a compatible match in by post-composing with . We then apply the rule along both matches by taking two pushouts, which the pasting law for pushout squares allows us to express as:

The result is a new e-diagram over the new diagram and, by construction, is weakly equivalent to the original diagram . Again, we use that initial functors are stable under pushout.