Modules over relative monads for syntax and semantics

We give an algebraic characterization of the syntax and semantics of a class of languages with variable binding. We introduce a notion of 2-signature: such a signature specifies not only the terms of a language, but also reduction rules on those terms. To any 2-signature $S$ we associate a category of “models” of $S$. This category has an initial object, which integrates the terms freely generated by $S$, and which is equipped with reductions according to the inequations given in $S$. We call this initial object the language generated by $S$. Models of a 2–signature are built from relative monads and modules over such monads. Through the use of monads, the models—and in particular, the initial model—come equipped with a substitution operation that is compatible with reduction in a suitable sense. The initiality theorem is formalized in the proof assistant Coq, yielding a machinery which, when fed with a 2-signature, provides the associated programming language with reduction relation and certified substitution.

💡 Research Summary

The paper presents a categorical framework that simultaneously captures the syntax and semantics of programming languages with variable binding. Traditional monadic approaches model both contexts and terms within a single category (typically Set), which makes it difficult to incorporate reduction relations that naturally live in a preorder. To overcome this, the authors adopt the notion of relative monads (Altenkirch et al., 2010), focusing on the embedding functor Δ : Set → Pre that sends a set X to the preorder (X, δ_X) where δ_X is the smallest preorder (the diagonal). This functor is fully faithful and left‑adjoint to the forgetful functor U : Pre → Set, allowing contexts to remain plain sets while terms acquire a preorder structure representing reduction.

On top of a relative monad they define modules, which generalize the usual monad‑module construction to the relative setting. An arity is encoded as a list of natural numbers, each entry indicating how many variables are bound in the corresponding argument. A module associated with an arity carries the appropriate substitution action derived from the Kleisli operation of the underlying relative monad. The paper develops the usual constructions (derived modules, composition, etc.) for these relative‑monad modules, showing that they behave analogously to the classical case.

The central novelty is the introduction of 2‑signatures. A 1‑signature S specifies the raw syntax (the set of term constructors) via a family of arities. A 2‑signature (S, A) augments S with a set A of inequations (also called half‑equations). Each inequation E = (α, γ) assigns to any representation R of S a pair of parallel morphisms α_R, γ_R in a suitable category of preorders; the inequation is satisfied when α_R ≤ γ_R. Because the target category is Pre, the inequality expresses a reduction step. The authors restrict attention to classic inequations, a class that includes the usual β‑ and η‑rules and is closed under propagation into subterms. This restriction guarantees that the set of inequations is not contradictory and that a model can be built.

The main theorem states that for any 2‑signature (S, A) consisting of a 1‑signature and a set of classic inequations, the category of its representations (i.e., relative‑monad models that satisfy all inequations) possesses an initial object. This initial object is precisely the programming language generated by the signature: it contains the freely generated syntax together with the smallest preorder closed under the given reduction rules. The proof proceeds in two stages. First, the authors adapt the initiality result of Hirscho​witz and Maggesi (2007) for pure syntax to the relative‑monad setting, using the adjunction Δ ⊣ U to transport the initial algebra from Set‑monads to Δ‑relative monads. Second, they show that adding classic inequations preserves initiality by constructing a quotient preorder that enforces the inequations while retaining the universal property.

All definitions and proofs are formalized in Coq. The paper details how arities are represented as lists, how representations are encoded as records containing a relative monad and a family of module morphisms, and how morphisms of representations are defined. The authors implement both the “no‑inequation” case (yielding the pure syntax) and the full 2‑signature case. As a running example they formalize the untyped λ‑calculus with β‑reduction (and optionally η‑reduction), denoted Λβ. The initial representation of Λβ is shown to be the usual λ‑terms equipped with the reflexive‑transitive closure of β‑reduction, matching the classical Barendregt‑Barendsen presentation.

In the related‑work discussion the paper positions itself among nominal approaches (Gabbay‑Pitts), higher‑order abstract syntax (HOAS), nested datatypes (Fiore et al.), and previous monad‑module frameworks. The key distinction is the explicit separation of contexts (sets) and terms (preorders) via relative monads, which enables a clean integration of reduction semantics without sacrificing the algebraic elegance of initiality. The authors also note that their framework can be combined with other categorical semantics, such as the 2‑category approach of Hirshowitz (2011), and suggest extensions to typed languages, richer rewriting systems, and alternative relational structures beyond preorders.

The conclusion emphasizes that the Coq‑verified initiality theorem provides a generic machinery: given any 2‑signature, one can automatically obtain a certified language definition, its substitution operation, and its reduction relation. This opens the door to systematic language prototyping, mechanized metatheory, and potentially to the generation of verified compilers or interpreters directly from categorical specifications. Future work includes handling more general inequations, integrating typing disciplines, and exploring connections with operadic and higher‑categorical models of syntax and semantics.