Raphaël Sterbac Blog

8th Week

Tue, 31 Mar 2026 09:55:03 +0100

Postponed casts and unification

Last week, I continued reading about pattern unification and tried to figure things out by reading Andras' code for “Observing definitional equality”. I am slowly trying to integrate it to my code, but for now this is clearly at an early stage, and I am a bit struggling to figure things out from Andras’ code as there is a lot going on there, with a lot of features implemented all at once. I will continue working on this more thoroughly this week.

7th Week

Sun, 22 Mar 2026 16:33:36 +0000

Formulating natural universe hierarchies

I’ve been working on finding a concise way to formulate the natural universe hierarchy, such that all the structural rules follow from functoriality and naturality condition. The idea is to work in a logical framework to specify the signature of our theory in a categorical way. This was a lot of fun ! Maybe there are also interesting ideas to get from the paper A Generalized Algebraic Theory for Type Theory with Explicit Universe Polymorphism, that I should probably try to read at some point.

6th Week

Tue, 17 Mar 2026 08:59:32 +0000

Implementing the Fuss-Free hierarchy

I have been continuing my implementation of the fuss-free hierarchy this week, Last week, I added synthesis rule for Pi and U, but that is not necessary if we write another function ‘checkTy’ which corresponds to a new judgment in the bidirectional typing algorithm, which checks a term against Type. We can also add an optional size to this judgement, which tells the elaborator to check it against $Small_i$ and produces a small type. I have implemented all of that, and it seems to be working! I still need to put my implementation to more tests though.

5th Week

Tue, 10 Mar 2026 09:44:43 +0000

Implementing the Fuss-Free hierarchy

I have been tinkering with implementation a bit this week, reading Andras Kovacs elaboration zoo code and trying to understand bidirectional elaboration and evaluation in practice. This lead me to try modifying his implementation of implicit cumulative universes to work with the Fuss-Free hierarchy in the core, thus elaborating the implicit user syntax to the fuss-free hierarchy.

This was simply an implementation of the elaboration rules I previously wrote on paper, but I got to see how this would work in practice. For example, in the practical implementation, it appears that a synthesis rule is needed for Pi and U, to infer types in things like : ’let f : U 1 -> U 1 = \A. A’, where we need to infer the universe level of ‘U 1 -> U 1’. To do this, I wrote infer rules giving the code of the corresponding type in the smallest universe possible. However this is only needed
for the ’let’ case, so maybe this is ok.

4th Week

Sun, 01 Mar 2026 18:07:33 +0000

Starting to write a paper

I’m glad to say that I started working on a paper with Jon, which will cover some of the stuff written here and aiming at clarifying the state of affairs when it comes to cumulative hierarchies of universes in dependent type theory and proof assistants, with a focus on both theoretical and practical aspects.

This work will partially use ideas from my previous internship focusing on the equivalence between Tarski and Russell universe, work I will be presenting at TYPES 2026 this year.

Third week

Mon, 23 Feb 2026 12:52:43 +0000

Equivalence between Fuss-Free and Tarksi

When showing that we can translate from a strict Tarski hierarchy to the Fuss-free formulation, we can’t define $Small_i$ as a proper type internally. To solve this issue, we can show this direction of the equivalence result by a semantics argument, showing that the syntactic category with family (CwF) $\mathcal{T}_T$ of the strict Tarski theory is a model of the fuss-free hierarchy. To do this, we define $Small_i$ as the characteristic map of the monomorphism $\text{El}_i$. Then, this satisfies the smallness rules of the fuss-free formulation, and we can define the coding map as a pullback map of the cartesian square defining the characteristic map $\text{Small}_i$. So now the equivalence result is completely proven!

Second Week

Sun, 15 Feb 2026 18:03:24 +0000

Elaboration of the universe hierarchy

When elaborating the “fuss-free” universe hierarchy, we need a mode switch for checking neutral types against the smallness judgement. This might cause unexpected issue to have two mode switch, and will not be well-behaved with unification and sub-typing (just like the issue for the algebraic hierarchies).

Hence, we need to introduce casts to tell the type checker to try to lift to another universe instead of trying to unify something. Also, from the elaboration perspective, the “fuss-free” hierarchy is not of a great help after all. The smallness judgement and code for type connective can be elaborated easily but we have to much downsides with the smalness judgement needing a mode switch and being not needed anyway.

First Week

Thu, 05 Feb 2026 18:03:24 +0000

Subtyping and Parametrised Inductive Types

On Tuesday, which was my first proper day, I focused on the potential issues we could encounter when adding structural subtyping and Parametrised Inductive types. A typical and pathological example of the latter is the list datatype $\text{List}(A)$.

If we allow the user to deduce $l : \text{List}(U_{i+1})$ from $l : \text{List}(U_{i})$, then we would also have both $nil_{i} : \text{List}(U_{i+1})$ and $nil_{i+1} : \text{List}(U_{i+1})$. However, we wouldn’t have $nil_{i} = nil_{i+1}$, unless we add the equation. This breaks canonicity for inductive types, and could lead to weird error messages on the user-side such as Could not unify nil and nil.

First Post

Tue, 03 Feb 2026 09:13:35 +0000

First post !