🤖 AI

Symbolic Informalization: Fluent, Productive, Multilingual

This paper introduces the Informath project, which utilizes a symbolic informalization framework built on a Dedukti hub and Grammatical Framework to reliably convert formal proofs from systems like Agda, Lean, and Rocq into fluent, precise, and multilingual natural language.

Original authors: Aarne Ranta

Published 2026-06-16

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Aarne Ranta

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 Idea: The "Translator" for Math Robots

Imagine you have a brilliant, super-fast robot mathematician. This robot speaks a very strict, precise language called Formal Logic (like Agda, Lean, or Rocq). It can prove theorems with 100% accuracy, but its output looks like a wall of code: forall (a : Int), odd a -> even (a + 1).

To a human, this is unreadable. It's like trying to read a book where every word is a secret code.

Informalization is the process of translating that strict robot code back into Natural Language (English, French, German, etc.) so humans can actually read and understand it.

The paper argues that while we have gotten very good at teaching robots to learn math from human books (using AI), we haven't done a great job of teaching them to explain their work back to us in a way that sounds like a human wrote it. This paper introduces a system called Informath to fix that.

The Three Goals: The "Fluent, Productive, Multilingual" Trio

The author says a good translator system needs three things, which he calls the "Holy Trinity" of this project:

Fluent (Sounds Natural):
- The Problem: Old translators were like bad robots that said, "The set of integers is a set." They were stiff and robotic.
- The Goal: The new system should sound like a math textbook. It should know when to say "Let $x$ be..." instead of "Assume $x$ is...", and it should know how to combine sentences smoothly (e.g., "x and y are even" instead of "x is even and y is even").
- Analogy: Think of the difference between a GPS that says "Turn left. Then drive 500 meters. Then turn right" versus a human giving directions: "Head left, go a block, then take a right." Both get you there, but one is much easier to follow.
Productive (Easy to Build):
- The Problem: Building these translators used to be like hand-carving every single word of a dictionary by hand. It took forever and required a linguist and a computer scientist to work together.
- The Goal: Make it so that a mathematician can just add a few notes to their code, and the system figures out the rest.
- Analogy: Instead of building a house brick-by-brick from scratch, you use a "Lego kit" (called the Resource Grammar Library). You just snap the pieces together, and the system handles the complex engineering (like grammar rules) for you.
Multilingual (Speaks Many Languages):
- The Problem: Usually, if you want a translator for English, you build one. If you want French, you build a totally different one.
- The Goal: Build one "brain" that can speak any language.
- Analogy: Imagine a universal adapter plug. You plug the math code into the middle, and it can output to English, French, German, or Swedish just by swapping the "plug head." You don't need to rebuild the whole machine for every country.

How It Works: The "Hub and Spoke" System

The paper describes a clever architecture to achieve these goals. Think of it as a busy airport hub.

The Hub (Dedukti):
- This is the central airport. All the different "airlines" (Agda, Lean, Rocq) fly their planes (math proofs) here.
- Dedukti is a simple, universal language that acts as the common ground. It strips away the specific quirks of each airline and converts everything into a standard format.
The Translation (Grammatical Framework - GF):
- Once the math is at the hub, it needs to be turned into human speech. This is where GF comes in.
- GF is like a master chef's kitchen. It has a "recipe book" (the grammar) that knows how to cook the math ingredients into a delicious sentence in any language.
- It handles the tricky parts: making sure verbs agree with subjects, changing "is" to "are" for plural, and handling gender in languages like French or German.
The Menu (Symbol Tables):
- This is the secret sauce. The mathematician doesn't need to rewrite the whole recipe book. They just fill out a "menu card" (a symbol table) that says:
  - "When you see the code plus, say 'sum'."
  - "When you see odd, say 'odd'."
- This allows the system to be customized easily without breaking the complex grammar underneath.

The "Magic" of Making it Sound Human

The paper highlights that making math sound natural is harder than it looks. Here are the tricks Informath uses:

Aggregation (The "And" Trick):
- Robot: "x is even. x is divisible by 3."
- Human: "x is even and divisible by 3."
- The system knows how to merge these sentences so they flow better.
In Situ Quantification (The "Hidden" Variable):
- Robot: "For all numbers n, n is even or n is odd."
- Human: "Every natural number is even or odd."
- The system realizes you don't need to repeat the word "number" every time. It hides the variable where it's obvious, just like a human would.
Symbolic vs. Verbal:
- Sometimes, math is best written with symbols (like $x + y = z$ ), and sometimes with words ("the sum of x and y"). The system knows when to use which. It can even generate LaTeX code (the standard for math typesetting) automatically.

What the Paper Actually Claims (and What It Doesn't)

What it DOES:

It successfully built a system (Informath) that can take formal math proofs and turn them into fluent, natural-sounding text in multiple languages.
It proved that you can make this system "productive" (easy to use) by using pre-built grammar libraries and simple symbol tables.
It showed that this works for undergraduate-level math (arithmetic, algebra, topology) and even some advanced topics (homotopy type theory), though the advanced stuff is harder.
It demonstrated that this system can be used to generate data to help train AI models (LLMs) to do math better.

What it DOES NOT claim (based strictly on the text):

It does not claim that the system is perfect for all of mathematics yet. The author admits that covering the "entire ordinary language of mathematics" is a huge, ongoing goal.
It does not claim that the system can currently handle every proof system perfectly. Systems like Isabelle or Mizar are mentioned as future challenges because they work differently than the ones currently supported.
It does not claim that the system replaces human mathematicians. It is a tool to help humans read what the computer has done.

The Bottom Line

The paper concludes that informalization is not easy. It's not just the reverse of formalization. While formalization (human to robot) can be checked automatically for errors, informalization (robot to human) is tricky because "sounding natural" is subjective and complex.

However, by using a "hub" system (Dedukti) and a "universal grammar" (GF), the author shows we can build a translator that is reliable (it doesn't hallucinate facts), flexible (it speaks many languages), and efficient (it doesn't require a team of linguists to build). It turns the robot's cold code back into a warm, readable story.

Technical Summary: Symbolic Informalization

Problem Statement

The paper addresses the challenge of symbolic informalization: the reliable conversion of formal mathematics (machine-checked proofs and theorems) into fluent, natural language without loss of precision. While neural methods (Large Language Models) have advanced autoformalization (informal to formal), they suffer from "hallucinations" and cannot guarantee that the formalized theorem matches the original text. Conversely, while formalization results can be automatically verified, the inverse process—informalization—is often difficult to automate symbolically.

Previous attempts at symbolic informalization have been criticized for three main reasons, which this paper identifies as the core requirements for a successful system:

Fluency: Outputs often lack the diversity and flexibility of natural language, appearing rigid.
Productivity: Systems are difficult to design and implement.
Multilinguality: Approaches often fail to scale across different formal languages or natural languages.

The paper argues that informalization is not merely "easy" translation but a complex research problem requiring a balance between semantic soundness (preserving meaning) and linguistic completeness (covering the full range of mathematical expression).

Methodology: The Informath System

The paper introduces Informath, a system built on an interlingual architecture to address the three goals of fluency, productivity, and multilinguality.

1. Architecture

Informath utilizes a two-stage interlingua approach:

Formal Interlingua (Dedukti): Serves as a hub between various proof systems (Agda, Lean, Rocq). Dedukti is a minimalistic logical framework with dependent types and rewrite rules. It acts as the source of truth for the formal content.
Linguistic Interlingua (Grammatical Framework - GF): Handles the natural language side. GF is a grammar formalism based on a logical framework similar to Dedukti, designed for multilingual translation.

The workflow is: Proof System $\to$ Dedukti $\to$ GF Abstract Syntax $\to$ Natural Language.

2. Multilinguality

Multilinguality is achieved by mapping the Dedukti abstract syntax to GF abstract syntax, which is then linearized into concrete natural languages.

Shared Abstract Syntax: The core mathematical concepts are defined in a language-independent abstract syntax tree (AST) within GF.
Resource Grammar Library (RGL): Informath leverages the GF RGL, which provides pre-defined linguistic structures (inflection, agreement, syntactic rules) for approximately 40 languages. This allows the same abstract syntax to be rendered correctly in English, French, German, Swedish, etc., handling grammatical variations (e.g., gender, case, number) automatically.

3. Productivity

To address the difficulty of implementation, Informath employs a deployment stack that abstracts away the complexity of GF and Haskell code for end-users:

Symbol Tables (.dkgf): The highest and most accessible layer. Users define lexical annotations mapping Dedukti constants to GF functions or string templates. This allows non-linguists to extend the system to new mathematical concepts without writing grammar rules.
Smart Paradigms: The RGL generates inflection tables from basic word forms, reducing the need for manual lexical entry.
Modular Code: The system separates the stable core (MathCore, handling semantic soundness) from the extensible extensions (MathExtensions, handling linguistic completeness).

4. Fluency and Natural Language Generation (NLG)

To achieve fluency, Informath moves beyond basic Controlled Natural Languages (CNLs) by implementing a multi-step NLG pipeline:

Content Determination & Text Planning: Deciding what to say and in what order.
Aggregation: Merging atomic facts (e.g., converting "x is even and x is prime" to "x is even and prime").
Lexical Choice: Selecting appropriate words via symbol tables.
Surface Realization: Generating the final string using GF linearization.
Ranking: The system generates thousands of variant expressions for a single formal statement. These are ranked using a penalty function based on tree size, depth, token count, and stylistic rules (e.g., avoiding sentences starting with symbols). This ensures the output is compact and natural-sounding.

The grammar is divided into MathCore (a minimal CNL covering all Dedukti constructs) and MathExtensions (approximating the full language of mathematics). The system supports complex features such as:

Variable-binding constants: Handling quantifiers and integrals via Higher-Order Abstract Syntax (HOAS).
In situ quantification: Placing quantifiers within predicates (e.g., "every natural number is even").
Symbolic Notation: Generating LaTeX macros for symbolic parts while keeping verbal parts natural.

Key Contributions

The Informath System: A working implementation demonstrating that symbolic informalization can be fluent, productive, and multilingual.
Interlingual Architecture: A novel use of Dedukti and GF as dual interlinguas to decouple formal logic from linguistic variation.
Low-Code Extension: A symbol-table-based mechanism allowing users to extend the system to new mathematical domains without modifying the core grammar or compiler code.
Handling Ambiguity: A strategy for managing the inherent ambiguity of natural language (e.g., scope of quantifiers, conjunctions) by generating multiple variants and using type-checking or ranking to resolve them, rather than enforcing rigid, unambiguous rules that sacrifice fluency.

Results

The paper reports on the current state of Informath:

Coverage: The system covers undergraduate mathematics (arithmetic, set theory, algebra, topology) and has been tested on the "100 theorems" project.
Multilingual Output: It successfully generates fluent text in English, French, German, and Swedish from the same Dedukti source.
Case Studies:
- Homotopy Type Theory: A case study on a HoTT book revealed challenges with third-party translators (Agda to Dedukti) that explode code complexity due to universe levels. However, once converted, Informath successfully handled the informalization, including complex "propositions as types" scenarios.
- Synthetic Data: Informath was used to generate synthetic data to fine-tune an LLM (Qwen2.5-7B-Instruct), resulting in improved autoformalization performance compared to the baseline.
Limitations: The system is not yet linguistically complete (it does not cover all of ordinary mathematical language) and proof informalization remains a work in progress, particularly regarding the ordering and omission of proof steps.

Significance and Claims

The paper claims that symbolic informalization is a necessary complement to neural autoformalization. While LLMs can generate formal code, they cannot guarantee correctness; symbolic informalization provides a reliable, explainable bridge that allows human users to interact with formal systems in natural language without seeing the underlying code.

The authors modestly conclude that while Informath achieves a level of fluency beyond basic CNLs, full coverage of the ordinary language of mathematics remains a distant goal. The primary open challenges are the ranking of the growing number of generated variants and the informalization of proofs. The paper emphasizes that unlike formalization, which can be automatically verified, informalization requires inherent reliability and expert knowledge, making the development of such tools a significant but necessary endeavor for the future of human-readable machine-checked mathematics.