💬 NLP

ZX-Calculus:Trace-Indexed Dependent Types and Epistemic Semantics

This paper introduces ZX-Calculus, a conservative extension of Martin-Löf Dependent Type Theory that integrates trace-indexed types, presheaf non-monotone semantics, and constructive AGM belief revision, providing a Coq-verified framework that establishes key theorems while revealing a fundamental tension between path-dependent belief revision and functor consistency.

Original authors: Peng Chen

Published 2026-06-03

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Peng Chen

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

Imagine you are trying to build a computer program that doesn't just know facts, but also remembers how it learned them, can change its mind when it gets new information, and can prove that its changes make sense.

This paper, titled "ZX-Calculus," proposes a new mathematical language (an extension of a system called MLTT) to do exactly that. The author, Peng Chen, treats knowledge not as a static list of facts, but as a movie that plays out over time.

Here is the breakdown of the paper's ideas using simple analogies:

1. The Movie Reel (Trace Types)

The Problem: In most computer systems, if you ask "What is the current state?", the system tells you the answer but forgets the history. It's like looking at a single photo of a car crash; you see the damage, but you don't know if the driver was speeding or if the brakes failed.
The Solution: The paper introduces "Trace Types." Think of this as a movie reel instead of a photo.

Every time the system learns something or changes, a new "frame" is added to the reel.
The system doesn't just store the final state; it stores the entire sequence of events (the "trace") that led there.
The Innovation: The paper compares this to an existing method called "Star(Step)." The author argues that while both methods can describe the same path, their "remote controls" (interfaces) are different. The new method (FinTrace) has a button that lets you press "Event" directly. This makes it much easier to ask questions like, "What happened specifically when the 'Fire Alarm' event occurred?" without having to dig through layers of code to find it.

2. The Eraser and the Notebook (Sheaf Semantics & Non-Monotonicity)

The Problem: In traditional logic, once you prove something is true, it stays true forever. But in the real world, knowledge is non-monotonic. If I believe "It is raining" because I see a cloud, and then I step outside and see the sun, my belief changes. The old belief isn't just "wrong"; it's retracted.
The Solution: The paper uses a concept called "Sheaf Semantics." Imagine a notebook where you write down what you know.

As time passes (the "trace" gets longer), you might have to erase a sentence you wrote earlier because new evidence contradicts it.
In math, usually, you can't "erase" a proof without breaking the system. This paper creates a special kind of notebook where "erasing" is a structural feature, not a bug.
The Key Insight: The paper proves that the rules of the notebook (the logic) remain perfect and stable, even though the content (the beliefs) can change or disappear. It separates the "rules of writing" from the "content of the story."

3. The Rational Debater (AGM Belief Revision)

The Problem: When a smart agent (like a robot or a person) gets new information that contradicts what they believe, how should they change their mind? They shouldn't just delete everything and start over; they should keep as much of their old knowledge as possible while accepting the new truth. This is called the AGM framework (named after three logicians).
The Solution: The paper builds a constructive algorithm (a step-by-step recipe) for this process.

The "Entrenchment" Ladder: Imagine every belief you have is on a rung of a ladder. Some beliefs are very deep (like "2+2=4" or "The sun rises in the east"). Others are shallow (like "It is raining today").
The Algorithm: When new information arrives (e.g., "The sun is setting in the east"), the system looks at the ladder. It starts removing the shallowest beliefs first until the conflict is resolved. It only touches the deep beliefs if absolutely necessary.
The Proof: The paper provides a rigorous mathematical proof that this algorithm works perfectly and follows all the rules of rational belief change. It even proves that this works even when you have to handle complex "AND" and "OR" combinations of new information.

4. The Glitch in the System (BP-comp Failure)

The Problem: The authors tried to see if this whole system could be described as a single, smooth, continuous flow (a "sheaf"). They wanted to know: "If I update my beliefs step-by-step (A to B, then B to C), is it the same as updating directly from A to C?"
The Result: No. The paper proves that for this specific type of belief revision, the order matters.

The Analogy: Imagine you are navigating a maze. If you turn left then right, you end up in a different spot than if you turn right then left.
The paper shows that "updating beliefs" is like navigating a maze. You cannot simply skip steps. The "Direct Update" is often different from the "Step-by-Step Update."
The Fix: Instead of forcing the system to be a smooth flow, the authors define a new, slightly looser structure called SSRS (Single-Step Revision System). This structure admits that "history matters" and that you must process updates one step at a time. They prove that their belief system fits perfectly into this new structure.

5. The Verification (Coq Mechanisation)

The author didn't just write these ideas down; they built a digital proof-checker (using a tool called Coq).

They wrote 34 complete mathematical proofs that verify their claims.
They proved that the "Step-by-Step" system (SSRS) works and that the "Direct Update" fails, exactly as they predicted.
This is like having a robot lawyer check every single step of a legal argument to ensure there are no loopholes.

Summary

This paper builds a mathematical engine for dynamic knowledge.

It treats history as a first-class citizen (you can't just look at the present; you must look at the path).
It allows beliefs to be retracted without breaking the logic system.
It provides a rational recipe for changing your mind when you get new info.
It proves that history matters: you can't always skip steps when updating your knowledge.

The ultimate goal is to create a foundation for systems that can learn, adapt, and reason about their own changes in a way that is mathematically guaranteed to be consistent.

Technical Summary: ZX-Calculus

Problem Statement

Classical epistemic logic and standard operational semantics face three fundamental limitations when modeling dynamic, knowledge-evolving systems:

Traces as Meta-Objects: Execution traces are typically treated as meta-level objects rather than first-class data within the type system. While Homotopy Type Theory (HoTT) offers invertible paths and session types characterize protocols, they lack a native mechanism to represent directed, non-invertible causal histories where the specific sequence of events is a primary constituent of the type.
Monotonicity vs. Non-Monotonicity: Standard type theories are monotone; adding information never invalidates previous proofs. However, epistemic knowledge is inherently non-monotone (retractable). Directly adding non-monotone proof rules to a type theory destroys normalization and consistency.
Constructive AGM Revision: Existing constructive approaches to belief revision (e.g., in Dynamic Epistemic Logic or non-monotone reasoning) often lack executable algorithms for partial meet contraction, fail to package contraction results with correctness witnesses as dependent types, or operate in static frameworks without trace-indexed semantics.

Methodology

The paper proposes ZX-Calculus, a conservative extension of Martin-Löf Dependent Type Theory (MLTT). It does not alter MLTT's core structural rules but introduces new type structures and semantic interpretations to integrate three layers:

Trace-Indexed Types: An inductive family FinTrace representing finite execution traces as constructive objects.
Sheaf Semantics: Interpreting trace-indexed propositions as contravariant sheaves over a free trace category, allowing for semantic non-monotonicity via non-surjective restriction maps while preserving proof-theoretic monotonicity.
Constructive AGM Revision: A type-theoretic implementation of the AGM (Alchourrón–Gärdenfors–Makinson) belief revision framework, utilizing $\Sigma$ -types to package belief sets with constructive proofs of adherence to AGM postulates.

The framework is verified using a Coq mechanization comprising 34 complete proofs, with specific focus on the failure of sheaf composition in sequential revision and the coherence of single-step revision systems.

Key Contributions

1. Trace Types and Interface Design

The paper introduces FinTrace, an inductive family of finite traces between states.

Comparison with Star(Step): The authors prove that FinTrace is isomorphic to the Kleene closure Star(Step) as path collections (Proposition 3.2). However, they are not judgementally equal.
Interface Advantage: The structural eliminator TraceElim takes the event label e : Event as an explicit parameter in its step function. This contrasts with StarElim, which requires unpacking a $\Sigma$ -type to recover event information. This design choice elevates event-causal structure to a native component of trace induction, facilitating event-driven sheaf semantics and deterministic replay.
Meta-Theory: The paper establishes a Canonicity framework via logical relations and reducibility candidates. A critical technical contribution is the Transport Lemma (Lemma 3.12), which ensures reducibility is stably transported under trace extension. The full mechanization of the RC-elim step for higher-order motives is noted as future work.

2. Sheaf Semantics and Non-Monotonicity

The paper interprets knowledge as a presheaf over the trace category $\mathbf{bTf}$ .

Separation Theorem: Theorem 4.5 demonstrates a clear separation between proof-theoretic monotonicity (which is preserved) and semantic non-monotonicity. Knowledge invalidation is modeled as the non-surjectivity of restriction maps, not as logical contradiction.
Initial CwF: The term model is proven to be the initial Category with Families (CwF) (Theorem 4.8), establishing a syntactic universal property where the syntax uniquely determines the semantic interpretation.

3. Constructive AGM Belief Revision

The paper provides the first explicit constructive algorithm for partial meet contraction in MLTT (Algorithm 6.3).

Algorithm 6.3: This algorithm iteratively removes the least-entrenched beliefs to satisfy contraction conditions (C1–C4). It is fully verified to inhabit the $\Sigma$ -type Selτ(ψ), which packages the resulting belief set with proofs of its correctness.
Disjunctive Entrenchment Lemma: Lemma 6.7 provides a fully self-contained constructive proof that the entrenchment of a disjunction is equivalent to the maximum entrenchment of its disjuncts. This lemma is essential for proving the complex AGM postulates R7 and R8.
Complete AGM Postulates: The paper proves that the trace-indexed revision system satisfies all eight classical AGM postulates (Theorems 6.9–6.12), embedding classical AGM theory into a dynamic, event-driven framework.

4. Integration and Coherence

A central tension is identified: the "minimal change principle" of AGM revision is path-sensitive, whereas sheaf semantics requires path-invariant composition (BP-comp).

BP-comp Failure: Theorem 7.1 proves that the belief revision functor $B_{AGM}$ is not a sheaf; the composition law fails for sequential AGM revision. A Coq-verified countermodel is provided.
Single-Step Revision Systems (SSRS): To resolve this, the paper introduces SSRS (Definition 7.2), a weaker structure that discards global composition constraints but retains well-defined single-step updates. Theorem 7.4 proves that $B_{AGM}$ is a valid SSRS, establishing a coherent integration of traces, sheaves, and belief revision within this intermediate framework.

Results and Verification

Coq Mechanization: The paper includes a Coq formalization with 34 complete proofs and zero admits for the core integration results: the BP-comp Failure Theorem and SSRS Coherence.
Proof Status:
- Complete: Proposition 3.2, Lemmas 3.12/3.13, Algorithm 6.3 correctness, AGM postulates R1–R8, Disjunctive Entrenchment Lemma, BP-comp Failure, and SSRS Coherence.
- Pending Mechanization: The RC-elim step of the Canonicity Theorem (Theorem 3.14) is currently supported by a hand-verified argument; full mechanization is listed as future work.

Significance and Claims

The paper claims to provide a conservative extension of MLTT that unifies historical traces, non-monotone knowledge evolution, and constructive belief revision without disrupting the underlying type theory's meta-theoretic stability.

Unification: It demonstrates that "how the system reached its current state" can be a native constituent of the type system, allowing for constructive reasoning about history-dependent properties.
Dynamic Epistemic Logic: By embedding AGM revision into a trace-indexed framework, the system generalizes classical AGM theory to describe the knowledge evolution of real cognitive agents, where different event sequences induce different epistemic entrenchment structures.
Foundational Rigor: The work clarifies the structural tension between sheaf functoriality and belief revision, proposing SSRS as the correct categorical model for dynamic belief systems.
Constructive Verification: Unlike classical AGM which relies on existential definitions, this framework provides executable algorithms and constructive witnesses for belief contraction, making the revision process computationally verifiable.

The paper concludes that ZX-Calculus offers a verifiable foundation for dynamic knowledge, retraction mechanisms, and runtime monitoring, with future work directed toward full semantic completeness, infinite trace extensions, and the completion of the remaining Coq obligations.