💻 computer science

From categorized neural architectures to subexponential proof theory

This paper establishes a framework for deriving a subexponential proof system with cut elimination directly from a categorized, resource-sensitive neural architecture, demonstrating that the resulting logical discipline is sound with respect to the architectural constraints and that the architecture itself forms a symmetric monoidal category.

Original authors: Carlos Ramírez Ovalle

Published 2026-04-01

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Carlos Ramírez Ovalle

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 a master architect designing a very complex, self-learning building (a neural network). Usually, when we try to understand how these buildings work, we look at the math behind the bricks and mortar. But this paper asks a different question: Can we look at the building's blueprint and discover the "rules of logic" that the building itself is following?

The author, Carlos Ramírez Ovalle, says: "Yes." He shows us how to take a neural network, translate its design into a set of strict rules about how information is handled, and then turn those rules into a formal logic system.

Here is the story of the paper, broken down into simple concepts and analogies.

1. The Problem: The "Black Box" of Neural Networks

Neural networks are like giant, magical factories. You put data in, and they spit out answers. But inside, they are messy. They copy data, they throw data away, and they mix data together in ways that are hard to track.

Usually, mathematicians say, "Let's invent a logic system (a set of rules) and try to fit the neural network into it."
This paper flips the script. It says, "Let's look at the neural network first, see how it actually handles its resources (memory, data), and extract the logic from there."

2. The Analogy: The "Zone" System

Imagine the neural network is a large office building with different types of rooms, or "Zones":

The Linear Zone (The "Use-Once" Room): Imagine a room where you are given a single, fragile glass vase. You must use it to do a task, and then it is gone. You cannot copy it, and you cannot throw it away before you use it. If you try to duplicate the vase, it breaks.
The Relevant Zone (The "Copy-Only" Room): Imagine a room with a whiteboard. You can write on it and make as many copies of the notes as you want (copying is allowed). However, you cannot just erase the board and walk away (discarding is forbidden). You must use the information.
The Persistent Zone (The "Library" Room): Imagine a library. You can take a book, read it, copy it, and even throw the copy away if you don't need it anymore. You can also leave the book on the shelf and forget about it. This is the most flexible zone.

In the paper, these are called Zones. The neural network is built with blocks that know exactly which zone they are in.

3. The Process: From Building to Logic

The paper describes a four-step journey to turn this building into a logical system:

Step 1: Categorize the Architecture

The author treats the neural network not just as code, but as a collection of "blocks" connected together. He draws a map (a Category) showing how data flows from one block to another.

Analogy: It's like drawing a subway map where every station is a specific type of room (Zone), and the trains are the data moving between them.

Step 2: The "License" Check

Not every room allows every action. The author looks at the map and asks: "Which rooms allow copying? Which allow throwing things away?"

If the "Persistent Zone" allows copying, the system gives it a License to Copy.
If the "Linear Zone" forbids copying, it gets No License.
This creates a "Coherent Zone Discipline." It's a strict rulebook written by the building itself.

Step 3: Extracting the "Subexponential Signature"

This is the fancy term for the "Rulebook."
In traditional logic, rules are often global (e.g., "You can always copy things"). But in this system, the rules depend on the Zone.

Analogy: Think of a security badge. A badge for the "Library" (Persistent) lets you copy and discard. A badge for the "Whiteboard" (Relevant) lets you copy but not discard. A badge for the "Glass Vase" (Linear) lets you do neither.
The paper proves that if you look at the building's rules, you can mathematically extract this exact set of badges. This is called a Subexponential Signature.

Step 4: Building the Proof System

Once the author has the "Rulebook" (the Signature), he builds a new language of logic (a Sequent Calculus) that matches those rules perfectly.

If the building allows copying in Zone P, the new logic has a "Copy Rule" for Zone P.
If the building forbids discarding in Zone L, the new logic has no rule for discarding in Zone L.

4. The Big Result: "Soundness"

The most important part of the paper is the proof of Soundness.
The author proves that the new logic system isn't just a random guess. It is perfectly aligned with the building.

If the logic says, "You can copy this data," it is because the building's design actually allows that copy to happen.
If the logic says, "You cannot throw this away," it is because the building's design physically prevents that discard.

It's like saying: "We didn't invent the rules of the game; we just wrote down the rules that the players were already following."

5. Why Does This Matter?

Usually, when we try to make AI safer or more understandable, we try to force it to follow human logic. But human logic might not fit the AI's design.

This paper suggests a better way: Listen to the AI.
By looking at how a neural network is actually built (how it handles memory and context), we can derive a logic that is naturally suited to it. This could help us:

Design better AI: If we know the logic of a specific architecture, we can build networks that are more efficient.
Explain AI decisions: We can use this logic to prove exactly why an AI made a certain decision based on its resource constraints.
Create new math: It bridges the gap between the messy world of engineering (neural nets) and the clean world of pure math (logic).

Summary

Think of this paper as a translator.

Input: A neural network with different types of memory (some reusable, some disposable).
Process: The author maps the network's "permissions" (what it can and cannot do with data).
Output: A new, custom-made logic system that perfectly describes those permissions.

The paper proves that this translation is accurate, consistent, and mathematically solid. It shows that the "logic" of a neural network isn't something we have to force onto it; it's already there, waiting to be read from the blueprint.

1. Problem Statement

The paper addresses a fundamental gap in the intersection of category theory, machine learning, and logic. While categorical deep learning has successfully provided semantics for neural architectures (viewing them as compositional structures), and categorical logic has established how categories generate proof systems, the reverse direction remains largely unexplored: Can one derive a specific logical discipline directly from the resource-sensitive behavior of a neural architecture?

Current approaches often start with a pre-existing logic (e.g., Linear Logic) and search for a semantic model. This paper argues that for resource-sensitive architectures (where some inputs are reusable, some discardable, and some linear), the logic should be extracted from the architectural constraints rather than imposed upon them. The specific challenge is to formalize a pipeline where a categorized neural architecture yields a subexponential signature and a corresponding proof theory without assuming the logic in advance.

2. Methodology

The author proposes a four-stage construction pipeline:
$\text{Architecture Family} \longrightarrow \text{Categorized Architecture} \longrightarrow \text{Subexponential Signature} \longrightarrow \text{Proof Theory}$

A. Categorical Formalization of Architectures

Typed Resource Contexts: The author defines contexts as finite lists of pairs $(z, A)$ , where $z$ is a "zone label" (representing memory or context type) and $A$ is a type from a base category $\mathcal{C}$ (e.g., vector spaces).
Parametrised Resource Blocks: Neural blocks are modeled as morphisms $(P, \phi): \Gamma \to \Delta$ , where $P$ is a parameter object and $\phi$ is a map $P \times [[\Gamma]] \to [[\Delta]]$ .
The Architectural Category ( $\mathbf{Arch}_Z$ ): The paper constructs a category where objects are contexts and morphisms are equivalence classes of parametrised blocks (identifying blocks that differ only by isomorphic reparametrization). It is proven that $\mathbf{Arch}_Z$ is a Symmetric Monoidal Category (SMC).

B. Coherent Zone Disciplines

To capture resource sensitivity (copying, discarding, coercion), the author introduces a Coherent Zone Discipline ( $\mathcal{L}ic$ ) on $\mathbf{Arch}_Z$ . This discipline consists of:

A preorder $\preceq$ on zones (refinement).
Zone Coercions: Morphisms allowing data to move from a refined zone to a coarser one.
Licensed Discards ( $W_{\mathcal{L}ic}$ ): A subset of zones where data can be discarded (weakening).
Licensed Diagonals ( $C_{\mathcal{L}ic}$ ): A subset of zones where data can be duplicated (contraction).

Crucially, these permissions are not arbitrary; they are structural morphisms explicitly present in the architectural category.

C. Extraction of Subexponential Signature

From the disciplined category, the author extracts a Subexponential Signature $\Sigma_{\mathcal{L}ic} = (Z, \preceq, W, C)$ .

The sets $W$ and $C$ are reconstructed directly from the existence of discard and diagonal morphisms in the licensed family.
Theorem 2.18 proves that this reconstruction is faithful: the extracted signature exactly matches the zones designated by the architectural discipline.

D. Proof Theory and Soundness

Tensorial Sequent Calculus ( $T\mathcal{Z}_{\Sigma}$ ): A proof system is defined based on the extracted signature. It includes rules for tensor product ( $\otimes$ ), unit ( $I$ ), and zone-indexed weakening/contraction rules ( $W_z, C_z$ ).
Cut Elimination: The paper proves that the extracted calculus admits cut elimination (Theorem 3.7), relying on the fact that the tensorial fragment is closed under cut-free derivations in the ambient subexponential logic.
Soundness: The main semantic result (Theorem 4.8) demonstrates that every derivation in the extracted logic corresponds to a morphism in the "Licensed Diagram Class" of the original architectural category. The structural rules of the logic are interpreted precisely by the discard and diagonal morphisms licensed by the architecture.

3. Key Contributions

Architectural Category Definition: The formal definition of $\mathbf{Arch}_Z$ , a symmetric monoidal category of zone-labelled parametrised blocks, providing a rigorous categorical semantics for resource-sensitive neural components.
Extraction Mechanism: A novel method to read off a subexponential signature from categorical data. Unlike traditional approaches where the logic is fixed, here the logic is an invariant of the architectural resource policy.
Faithful Reconstruction: Proof that the extracted weakening and contraction zones ( $W, C$ ) are exactly those where the architecture permits discarding and duplication, ensuring no "accidental" structural rules are introduced.
Soundness Theorem: A rigorous proof that the extracted proof theory is sound with respect to the original categorized architecture. The logical rules are not just semantically valid; they are implemented by the specific structural morphisms (discards/diagonals) of the architecture.
Concrete Instantiation: The application of this framework to a minimal two-block neural network (involving persistent memory, retrieved context, and linear observation), demonstrating how different input roles (persistent vs. linear) induce specific substructural logical rules.

4. Results

Theorem 2.10: $\mathbf{Arch}_Z$ is a symmetric monoidal category.
Theorem 2.18: The reconstructed structural classes ( $W_{\mathcal{L}ic}, C_{\mathcal{L}ic}$ ) are identical to the designated zones ( $W_{\mathcal{L}ic}, C_{\mathcal{L}ic}$ ) in the discipline, proving the extraction is faithful.
Theorem 3.7: The extracted tensorial calculus $T\mathcal{Z}_{\Sigma}$ admits cut elimination.
Theorem 4.8 (Soundness): For every derivation $\pi$ in the extracted calculus, there exists a morphism $[[\pi]]$ in the licensed diagram class of the architecture. Specifically, the interpretation of weakening uses the licensed discard, and contraction uses the licensed diagonal.
Example 4.11: A concrete demonstration showing how a neural architecture with distinct memory types (persistent, relevant, linear) naturally yields a logic with corresponding subexponential rules (copy/discard allowed for persistent, copy-only for relevant, linear for observation).

5. Significance

This paper represents a foundational shift in the "Neural Architecture $\to$ Category $\to$ Logic" program.

Direction of Explanation: It reverses the standard paradigm. Instead of asking "What logic models this network?", it asks "What logic is forced by this network's resource discipline?"
Resource Sensitivity: It provides a mathematically crisp way to handle differentiated memory and context in neural networks (e.g., distinguishing between weights that can be reused, inputs that can be dropped, and features that must be consumed exactly once).
Subexponential Logic: It validates subexponential linear logic not just as an abstract tool, but as a natural consequence of architectural constraints.
Future Work: The paper sets the stage for richer logical fragments (e.g., adding linear implication via internal homs) and the design of neural architectures guided by specific logical constraints derived from their intended resource behaviors.

In summary, the paper establishes that subexponential structure is not a postulate but a derived property of categorized neural architectures, offering a rigorous bridge between the structural design of deep learning systems and the proof-theoretic properties of resource-sensitive logics.