🔢 mathematics

Stone Duality for Monads

This paper establishes a Stone duality for monads by introducing a contravariant idempotent adjunction between ranked monads on $\mathsf{Set}$ and internal categories in locales, which restricts to classical Stone duality and characterizes hyperaffine-unary monads as the fixed points corresponding to ample localic categories.

Original authors: Richard Garner, Alyssa Renata, Nicolas Wu

Published 2026-03-27

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Richard Garner, Alyssa Renata, Nicolas Wu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Shadows vs. Reality

Imagine you are a prisoner in Plato's famous cave. You are chained up, facing a wall. Behind you, a fire burns, and people walk past carrying objects. You only see the shadows of these objects on the wall.

In computer science, Monads are like the rules for how these shadows behave. They describe how a computer program interacts with the world (like reading memory, making random choices, or failing).

The Shadows: The code you write (the syntax).
The Reality: The actual machine state, the memory cells, and the transitions happening as the program runs.

For a long time, computer scientists had a great way to describe the shadows (the code rules), but they struggled to describe the reality (the machine's behavior) in a way that perfectly matched the code, especially for complex, infinite systems.

This paper introduces a magical mirror called Stone Duality. It creates a perfect, two-way translation between:

The Code (Monads): The rules of the game.
The Machine (Localic Categories): The actual transition system of states and moves.

The authors show that for a specific, very important class of programs, these two sides are actually the same thing, just viewed from different angles.

Key Concepts Explained

1. The "Computation" (The Monad)

Think of a Monad as a recipe book for a video game.

It tells you what moves are possible (e.g., "Pick up a key," "Jump," "Open a door").
It tells you the rules (e.g., "You can only jump if you have a key").
The Problem: Sometimes the recipe book is tricky. It might say, "You can open a door," but it doesn't tell you where the door is or what happens if the door is locked. The recipe is perfect, but the reality it describes might be fuzzy or infinite.

2. The "Behavior Category" (The Transition System)

To understand the recipe, we build a Behavior Category.

Imagine a map of the game world.
Points on the map are "States" (e.g., "Player has 5 gold," "Player is in the forest").
Lines connecting points are "Transitions" (e.g., "Buy sword," "Walk north").
This map shows exactly how the game flows from one state to another.

The Twist: In the old days, we tried to draw this map using simple points and lines. But for complex games (like those with infinite memory or randomness), a simple map isn't enough. You need a map with texture and topology—a map where points can be "close" to each other even if they aren't touching, representing "finite information."

The authors use Locales (a mathematical way of describing space without needing actual points) to build this map. Think of a Locale not as a map of dots, but as a map of regions of possibility.

3. The "Retrofunctor" (The Simulation)

Usually, when we compare two maps, we draw arrows from one to the other (a "functor"). But here, the authors use a Retrofunctor.

Analogy: Imagine you are playing a video game, and you want to simulate it on a different console.
A normal map tells you: "If I press 'A' here, I go there."
A Retrofunctor tells you: "If I see that move happen on the big screen, I know exactly what button I must press on my controller to make it happen."
It's a "simulation" or a "reverse lookup." It connects the abstract rules to the concrete moves.

4. The "Scrying" (The Magic Trick)

The paper discovers a special property called Hyperaffine-Unary.

The Problem: In a normal program, to know the result of an action, you usually have to do the action. (e.g., To know if the door opens, you must try to open it).
The Magic: The authors find that for the "perfect" programs, you can Scry (predict) the outcome without doing the action.
Analogy: Imagine a magician who can look at a deck of cards, tell you exactly what the top card is, and then put the deck back exactly as it was, as if nothing happened.
In math terms, this means the program can "peek" at the future state, record the answer, and then "roll back" the state to before it happened.
The paper proves that only programs that can do this "Scrying" have a perfect, one-to-one match with their behavior maps.

The Main Discovery: The Stone Duality

The authors prove a beautiful theorem:

If a program allows "Scrying" (predicting the future without changing the state), then:

The Code (Monad) and the Behavior Map (Localic Category) are mathematically identical.
You can turn the Code into the Map, and turn the Map back into the Code, and you get exactly what you started with.

This is called Stone Duality because it's a modern, super-charged version of a famous 100-year-old math trick that linked logic (Boolean algebras) to geometry (spaces).

Old Duality: Logic $\leftrightarrow$ Simple Spaces (like a cloud of disconnected dots).
New Duality: Complex Computer Programs $\leftrightarrow$ Complex Behavior Maps (with infinite textures).

Why Does This Matter?

Better Debugging: It gives us a new way to look at code. Instead of just reading the rules, we can look at the "shape" of the behavior. If the shape is weird, the code is weird.
New Logic: It helps us build better tools to prove that programs are correct. The authors suggest we can use this to create a new kind of logic (like a "Dynamic Logic") that can reason about programs that interact with the world, even if those programs are infinite or complex.
Unifying Theory: It connects the world of "Syntax" (writing code) with the world of "Semantics" (what the code actually does) in a way that handles infinite complexity gracefully.

Summary in One Sentence

This paper builds a magical mirror that perfectly translates complex computer programs into maps of their behavior, but only works perfectly for programs that have the magical ability to "peek at the future" without messing up the present.

1. Problem Statement

The paper addresses the fundamental question of how to mathematically describe the "reality" or "behavior" underlying a notion of computation, which is typically modeled by a monad $T$ on the category of sets ( $\mathbf{Set}$ ).

The Gap: While Moggi established that monads describe computational effects, and Plotkin & Power refined this via algebraic theories (operations and equations), these descriptions are syntactic. They describe what computations look like but not how they interact with an external state (reality).
The Limitation of Existing Models: Previous work introduced comodels (stateful runners) to model the interaction between programs and state. However, recovering the original monad $T$ $T$ from its category of comodels is difficult.
- If one uses topological categories (for finitary monads), the reconstruction often fails for infinitary monads because it allows "unreasonable" computations that query infinite state in finite time.
- If one uses point-set topology, certain non-trivial monads (e.g., those with constraints like "no two memory cells have the same value" over an infinite domain) collapse to trivial structures because the required state space has no points (is empty), even though the syntax is non-trivial.
The Goal: The authors seek a duality that recovers a monad from a "behavioral" structure (a transition system) and vice versa, specifically handling both finitary and infinitary monads, and identifying the precise conditions under which this recovery is perfect (an equivalence).

2. Methodology

The authors employ a categorical approach combining monad theory, internal categories, locales (point-free topology), and Stone duality.

A. From Monads to Behavior (The Left Adjoint)

Instead of using topological spaces, the authors construct the Localic Behaviour Category ($LBT$) for a ranked monad $T$ .

Objects ( $LB_0T$ ): Defined as the terminal localic comodel. This is a locale generated by "observable behaviors" (natural transformations $\beta: T \to \text{id}$ ). Unlike the topological version, this is a locale (a frame of opens), allowing for "points" that do not exist in the set-theoretic sense (non-spatial locales). This solves the issue of empty state spaces for non-trivial monads.
Morphisms ( $LB_1T$ ): Defined via a sheaf of transitions over $LB_0T$ $L B_{0} T$ .
- They construct a free Grothendieck Boolean power of the set of unary terms ( $T^1$ ).
- They quotient this by a congruence based on trace equivalence (point-free translation of $\beta$ -equivalence).
- The resulting structure is a local homeomorphism $\sigma: LB_1T \to LB_0T$ .
Structure: $LBT$ is an internal category in the category of locales ( $\mathbf{Loc}$ ). The morphisms between these categories are retrofunctors (simulations of transition systems), not standard functors.

B. From Behavior to Monads (The Right Adjoint)

Given a localic category $LC$ (viewed as a transition system), the authors construct a monad $\Gamma_{LC}$ .

Definition: $\Gamma_{LC}(A)$ is the set of global sections of the source map $\sigma: LC_1 \to LC_0$ that are $A$ -indexed and partition the space of objects.
Intuition: A computation in $\Gamma_{LC}$ specifies, for every state, a transition and an output value. This mimics a state monad but tracks the specific transition taken.
Functoriality: This construction forms a contravariant functor $\Gamma: \mathbf{LocRetro}^{op} \to \mathbf{Mnd}_r(\mathbf{Set})$ .

C. The Adjunction

The paper establishes a contravariant idempotent adjunction:
$\mathbf{Mnd}_r(\mathbf{Set}) \underset{\Gamma}{\overset{LB}{\rightleftarrows}} \mathbf{LocRetro}^{op}$

Unit: Maps a monad $T$ to its behavior category $LBT$.
Counit: Maps a localic category $LC$ to the behavior of its sections.

3. Key Contributions

The Localic Behaviour Category ($LBT$):
- Introduced a point-free (localic) construction for the behavior of monads.
- Proved that for infinitary monads, the localic approach is necessary to preserve non-triviality where topological approaches fail (e.g., the "injective memory" example where the set of states is empty, but the locale is non-trivial).
- Showed that for finitary monads, $LBT$ is the spatialization of the previously known topological behaviour category $BT$.
Stone Duality for Monads:
- Proved that the adjunction is idempotent.
- Characterized the fixed points (equivalence) of this adjunction:
  - On the Monad side: Hyperaffine-unary monads. These are monads where every computation $t$ admits a "read-only" or "scrying" operation $\bar{t}$ that predicts the output of $t$ without performing the side effect (rolling back the state). This syntactically characterizes monads with Cartesian closed Eilenberg-Moore categories.
  - On the Category side: Ample localic categories. These are localic categories where the source map is a local homeomorphism and the object locale is ultraparacompact (strongly zero-dimensional).
Generalization of Classical Stone Duality:
- Demonstrated that restricting this duality to Boolean algebras (viewed as monads of partitions) and Stone spaces (viewed as localic categories with only identity morphisms) recovers the classical Stone duality between Boolean algebras and Stone spaces.
Retrofunctors as Morphisms:
- Established that the correct morphisms between localic/topological categories in this context are retrofunctors (which simulate transition systems), rather than standard functors.

4. Results

Theorem 4.4: The construction $T \mapsto LBT$ and $LC \mapsto \Gamma_{LC}$ form a contravariant adjunction between ranked monads and localic categories with retrofunctors.
Theorem 5.8: The adjunction is idempotent. The fixed points are equivalent to:
- $\mathbf{HUMnd}_r$ (Hyperaffine-unary monads) $\simeq$ $\mathbf{AmpLocRetro}$ (Ample localic categories).
- For finitary monads: $\mathbf{HUMnd}_\omega \simeq \mathbf{AmpTopRetro}$ (Ample topological categories).
Recovery of Monads: The monad $\Gamma(LBT)$ is the "hyperaffine-unary completion" of $T$ . It adds "scrying" operations that allow the system to predict outcomes without state change. If $T$ is already hyperaffine-unary, $T \cong \Gamma(LBT)$ .

5. Significance

Theoretical Unification: The paper unifies the theory of computational effects (monads) with the theory of transition systems (categories) via a robust duality. It bridges the gap between syntax (algebraic theories) and semantics (stateful interaction).
Handling Infinitary Effects: By moving to locales (point-free topology), the authors resolve long-standing issues where infinitary constraints make state spaces "empty" in a set-theoretic sense but non-trivial in a computational sense.
New Characterization of Cartesian Closedness: It provides a new, operational characterization of monads with Cartesian closed categories of algebras (hyperaffine-unary monads) via the concept of "scrying" or read-only prediction.
Future Applications (Logic): The authors propose using this duality to construct a Propositional Dynamic Logic (PDL) for monadic programs. In this logic, the localic behaviour category serves as a Kripke model where propositions are clopen sets and programs are transitions. This allows reasoning about programs without requiring the original monad to have "innocent" computations, as the duality naturally completes the monad with necessary propositions.
Scheme Theory of Monads: The paper suggests a path toward a "scheme theory" for monads, where the syntax of effects varies continuously over a base space, analogous to schemes in algebraic geometry.

In summary, the paper establishes that the "true" semantic structure of a computational effect is a localic category, and the process of moving between syntax (monads) and semantics (localic categories) is a Stone duality that is perfect precisely when the computation allows for "predictive" (hyperaffine) operations.