💻 computer science

Formalising the Bruhat-Tits Tree

This paper presents the formalisation of the Bruhat-Tits tree in the Lean Theorem Prover and demonstrates its utility by verifying a result concerning harmonic cochains on the tree.

Original authors: Judith Ludwig, Christian Merten

Published 2026-04-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Judith Ludwig, Christian Merten

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 understand the hidden architecture of a vast, infinite city made of numbers. This city is built on a strange kind of geometry called p-adic numbers, which behave very differently from the number line we use in everyday life. In this city, the most important tool for mapping the streets and buildings is something called the Bruhat–Tits tree.

This paper is a report by two mathematicians, Judith Ludwig and Christian Merten, who decided to build a perfect, error-free digital twin of this tree inside a computer program called Lean. Think of Lean as a super-strict librarian who checks every single step of a mathematical argument to ensure it is logically airtight.

Here is the story of their journey, explained through simple analogies:

1. The Infinite Tree (The Map)

In the real world, trees have branches. In this mathematical world, the "Bruhat–Tits tree" is a giant, infinite structure where every point (vertex) is connected to exactly $p+1$ other points.

The Analogy: Imagine a family tree that never ends. Every person has exactly the same number of children, and the family keeps growing forever.
The Problem: This tree isn't just a drawing; it represents deep secrets about how numbers interact. To understand it, you have to look at "lattices" (which are like grids of points) and see how they fit together.
The Goal: The authors wanted to translate this complex, abstract tree into code that a computer could read and verify. They wanted to prove, with 100% certainty, that the tree is actually a tree (connected, with no loops) and that its geometry is correct.

2. The Magic Key (The Cartan Decomposition)

To build this tree, the authors needed a special tool to sort and organize the messy grids (lattices). They used a mathematical concept called the Cartan decomposition.

The Analogy: Imagine you have a huge, messy pile of LEGO bricks of different shapes and colors. You want to sort them into neat, standard boxes. The Cartan decomposition is like a magical sorting machine. It takes any messy arrangement of bricks and says, "Ah, I can break this down into a standard box, a specific rotation, and another standard box."
The Achievement: The authors taught the computer how to use this "sorting machine" to prove that any two points on the tree have a specific, measurable distance between them. This was the foundation for building the whole tree.

3. Building the Tree in Code

Once they had the sorting machine, they started building the tree in Lean.

The Challenge: In math, you can switch between different ways of looking at a problem easily. In a computer program, you have to be very precise. You can't just say "this grid is that grid"; you have to prove exactly how they are related.
The Solution: They created a digital version of the tree where every connection is verified. They proved that if you walk from one point to another, you can't accidentally loop back to where you started (no cycles), and you can reach any point from any other point (connected).

4. The Test Drive: Harmonic Cochains

Why did they do this? It wasn't just for fun. They wanted to test their new digital tree on a real research problem involving Harmonic Cochains.

The Analogy: Imagine the tree is a giant musical instrument. The "edges" of the tree are strings. A "harmonic cochain" is a specific way of plucking those strings so that the sound (mathematically) balances out perfectly at every junction.
The Experiment: The authors used their computer-verified tree to prove a theorem about these "plucked strings." They wanted to show that for any pattern of sound you want at the junctions, there is a way to pluck the strings to make it happen.
The Result: The computer checked their proof line-by-line and said, "Yes, this is correct!" This gave them confidence that their research was solid and free of human error.

5. Why This Matters

For Mathematicians: It's like building a "flight simulator" for advanced math. Before, mathematicians had to trust each other's complex calculations. Now, they can run the calculation through the "simulator" (Lean) to see if it actually works.
For the Future: The authors are working to put these tools into a giant public library of math code called mathlib. This means other researchers can use their "sorting machine" and "tree builder" to solve even harder problems in number theory and physics.

The Big Picture

Think of this paper as the story of two architects who built a perfect, computer-verified blueprint of a magical, infinite forest. They didn't just draw the trees; they wrote the code that proves the trees exist, grow correctly, and can be used to solve puzzles about how the universe of numbers is structured. They showed that with the right tools, even the most abstract and difficult ideas in mathematics can be made clear, precise, and undeniable.

1. Problem Statement

The paper addresses the formalization of the Bruhat–Tits tree, a fundamental combinatorial object in number theory and arithmetic geometry, within the Lean 4 theorem prover.

Context: The Bruhat–Tits tree is constructed from lattices over a discrete valuation field $K$ (typically a $p$ -adic field). It serves as a geometric tool to study the group $GL_2(K)$ , its subgroups, and their homology. It is also central to the theory of harmonic cochains, which connect to automorphic forms and Drinfeld's upper half-plane.
Gap: Prior to this work, the Bruhat–Tits tree had never been formalized in a proof assistant.
Goal: To formalize the construction of the tree, prove its fundamental properties (being a regular tree), and apply this formalization to verify a specific research result regarding the surjectivity of the Laplacian operator on harmonic cochains.

2. Methodology

The authors utilized Lean 4 and the mathlib4 library, leveraging its existing foundations in linear algebra, graph theory, and commutative algebra.

A. Mathematical Framework

General Setting: Instead of restricting to $\mathbb{Q}_p$ , the formalization works over any discrete valuation ring $R$ with fraction field $K$ .
Cartan Decomposition: A crucial prerequisite is the formalization of the Cartan decomposition for $GL_n(K)$ $G L_{n} (K)$ . This states that any invertible matrix can be decomposed into $k_1 t k_2$ $k_{1} t k_{2}$ , where $k_1, k_2 \in GL_n(R)$ $k_{1}, k_{2} \in G L_{n} (R)$ and $t$ $t$ is a diagonal matrix with entries being powers of the uniformizer $\varpi$ $ϖ$ .
- Proof Strategy: A Gaussian-type algorithm (inductive linear algebra) rather than the Smith normal form, allowing it to work over general valuation rings.
Lattice Construction:
- Vertices are defined as equivalence classes of $R$ -lattices in $K^2$ under homothety (scalar multiplication).
- Edges are defined via a distance function $d(L, L') = n - m$ , derived from the unique integers in the basis transformation between two lattices (Proposition 3.1).
Graph Structure: The tree is formalized as a SimpleGraph where adjacency is defined by distance 1.

B. Formalization Techniques & Challenges

Type Handling: The authors navigated the distinction between submodules of $K^2$ $K^{2}$ and abstract lattices. They developed three perspectives on lattices:
1. As free $R$ -submodules of $K^2$ .
2. As spans of $K$ -bases.
3. As spans of columns of $GL_2(K)$ elements.
- Key Insight: They found that working with bases of $K^2$ (Perspective 2/3) rather than submodules directly allowed for better use of Lean's equality induction principles, avoiding complex type coercions (.val) during proofs.
Group Actions: Formalized the transitive action of $GL_2(K)$ and the non-transitive action of $SL_2(K)$ (which preserves a parity/orientation of vertices).
Acyclicity Proof: Proving the graph is a tree required showing it is connected and acyclic. Acyclicity was proven by showing that any trail can be transformed into a "standard chain" via the group action, implying the graph distance equals the path length.

3. Key Contributions

A. Formalization of the Cartan Decomposition

Provided a rigorous proof of the Cartan decomposition for $GL_n(K)$ over discrete valuation rings.
Established the uniqueness of the diagonal component (up to permutation), ensuring the disjointness of double cosets.
Integrated elementary matrix API (swaps, valuations) into the library.

B. Construction of the Bruhat–Tits Tree

Defined the vertex set as a quotient of lattices.
Defined the edge set and distance function based on the Cartan decomposition.
Theorem: Proved that the resulting graph is a regular tree of degree $q+1$ (where $q$ is the cardinality of the residue field).
Formalized the transitive action of $GL_2(K)$ and the stabilizer subgroups.

C. Verification of Harmonic Cohains Result

Applied the tree formalization to verify the surjectivity of the Laplacian on the space of harmonic cochains.
Generalization: While the research context involved $\mathbb{Z}$ , the formalization generalized the result to any commutative ring $A$ and any $A$ -module $M$ .
Proof: Constructed an explicit preimage for any function on vertices using an inductive argument on the distance from a root vertex, utilizing "outward edge cones."

4. Results

Codebase: Approximately 8,000 lines of Lean code organized into five folders (Graph, Lattice, etc.).
Theorems Proven:
- Existence and uniqueness of the Cartan decomposition.
- The Bruhat–Tits graph is a connected, acyclic, regular tree.
- The Laplacian map $\Delta: \text{Maps}(E(T), M) \to \text{Maps}(V(T), M)$ is surjective for trees with minimum degree $\ge 2$ .
Efficiency: The formal proof of the Laplacian surjectivity was highly efficient, requiring less than 750 lines of code for 140 lines of LaTeX text (a ratio significantly better than the rest of the project), demonstrating the maturity of the underlying graph theory in mathlib.

5. Significance

First of its Kind: This is the first formalization of the Bruhat–Tits tree in any proof assistant, filling a gap in the formalization of graduate-level number theory.
Research Support: The project demonstrates that formal methods can support active research. The authors used the formalization to verify a result about rigid analytic theta cocycles, uncovering that the result holds for arbitrary modules, not just $\mathbb{Z}$ -modules.
Mathlib Integration: The authors plan to integrate the Cartan decomposition and the theory of lattices into the main mathlib library. This will provide foundational tools for future formalizations in representation theory and the Langlands program.
Methodological Insight: The paper highlights the importance of choosing the right "perspective" (e.g., working with bases vs. submodules) to make formal proofs tractable in dependent type theory, offering a blueprint for formalizing complex algebraic geometry concepts.

In summary, the paper successfully bridges advanced arithmetic geometry and formal verification, providing a verified foundation for the Bruhat–Tits tree and demonstrating the utility of theorem provers in verifying and generalizing current mathematical research.