🔢 mathematics

Formalizing $A_1^{(1)}$ Curve Neighborhoods in Lean 4

This paper presents an axiom-free formalization in Lean 4 of combinatorial curve neighborhoods for type $A_1^{(1)}$ affine flag manifolds by encoding them through the Coxeter system of the infinite dihedral group, ultimately providing a verified and fully computable framework for these neighborhoods.

Original authors: Yihe Huang, Sizhe Cui, Jiaqi Wang, Jujian Zhang

Published 2026-04-28

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Yihe Huang, Sizhe Cui, Jiaqi Wang, Jujian Zhang

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 "Digital Architect" of Infinite Patterns: A Simple Guide

Imagine you are playing a complex board game on an infinite, branching path. In this game, every move you make follows strict rules, and certain "neighborhoods" of spaces are special because they represent the most efficient ways to travel.

In high-level mathematics, researchers study these "neighborhoods" to understand the geometry of complex shapes (like "affine flag manifolds"). However, the math used to describe these paths is so intricate that even the smartest mathematicians can make a tiny "typo" in their logic—like a single wrong turn on a map that leads you miles away from your destination.

This paper describes how a team of researchers used a powerful computer language called Lean 4 to build a "Digital Architect" that can check these mathematical maps with 100% perfection.

1. The Problem: The "Infinite Maze"

The researchers are looking at a specific mathematical structure called Type $A_1^{(1)}$ . Think of this as an infinite, two-way hallway that stretches forever in both directions.

In this hallway, there are two types of "steps" you can take: a Rotation (a smooth turn) and a Reflection (a sudden flip). To find a "Curve Neighborhood," you are essentially asking: "If I start at point A and I'm only allowed to spend a certain amount of 'energy' (degree), what are the furthest, most important landmarks I can reach?"

Calculating this by hand is like trying to solve a Rubik's Cube that is infinitely large and changes its colors every time you move it. It’s easy to lose track of whether you’ve taken an even or odd number of steps.

2. The Solution: The "Perfect Referee" (Lean 4)

Instead of just writing the answer on a chalkboard and hoping it's right, the authors used Lean 4.

Think of Lean 4 not as a calculator, but as a super-strict referee. In a normal math paper, a mathematician might say, "It is obvious that this pattern repeats every two steps." A human might agree, but a mistake could be hiding there. Lean 4 refuses to move forward until you prove exactly why it repeats, step by step, with no room for "obvious" assumptions.

The researchers didn't just tell the computer the answer; they taught the computer the entire rules of the game:

They taught it how to count steps (Length).
They taught it how to track "energy" usage (Degree).
They taught it how to recognize the "hallway" (The Coxeter System).

3. The Breakthrough: From Theory to "Live" Math

The coolest part of this paper is that they didn't just build a "checker"—they built a "simulator."

Usually, formal math is "static"—it's a proof that sits on a page. But because the researchers wrote their code so cleanly, they turned the math into something computable.

They created a bridge between Abstract Logic (the "Why") and Raw Computation (the "How"). Because the computer now truly "understands" the rules of this infinite hallway, you can actually ask it: "Hey, if I start here and use this much energy, show me exactly which landmarks I can hit," and the computer will instantly give you the correct list.

Summary: Why does this matter?

Imagine if every bridge ever built had to be checked by a computer that didn't just "guess" based on previous bridges, but actually re-simulated every single atom and bolt to ensure it wouldn't fall.

That is what these researchers have done for this specific branch of geometry. They have moved the math from the "sketchpad" of human intuition into a "digital vault" of absolute, machine-verified certainty. They have turned a complex, error-prone manual calculation into a perfect, automated tool.

Technical Summary: Formalizing $A_1^{(1)}$ Curve Neighborhoods in Lean 4

Problem Statement

In the study of quantum Schubert calculus for affine flag manifolds, combinatorial curve neighborhoods are fundamental geometric objects. For the specific case of type $A_1^{(1)}$ , these neighborhoods can be encoded within the moment graph of the infinite dihedral group $D_\infty$ . While explicit combinatorial formulas for these neighborhoods exist (notably by Mihalcea and Norton), the proofs involve intricate combinatorial arguments—such as parity checks, word length verifications, and Bruhat order manipulations—that are prone to human error. The core challenge is to provide a rigorous, machine-checked formalization of these neighborhoods and their governing formulas.

Methodology

The authors employ Lean 4 and Mathlib to build a complete, axiom-free formalization. Their approach follows a hierarchical construction:

Algebraic Foundation: Instead of treating $D_\infty$ as a simple group, they endow it with a CoxeterSystem instance by defining a specific Coxeter matrix over $\text{Fin } 2$ . This allows them to leverage abstract Coxeter theory while maintaining a direct link to the geometric group.
Constructive Length Functions: To bridge the gap between non-constructive abstract definitions and practical computation, they implement an explicit_length function based on reduced words (alternating sequences of generators $s_0, s_1$ ). They formally prove that this constructive function is equivalent to the abstract Coxeter length.
Graph-Theoretic Modeling: The moment graph is modeled using an inductive definition of HasIncreasingChain, where edges are defined by root reflections and degrees are tracked via a component-wise additive monoid.
Arithmetic Reduction: To handle parity lemmas (which are often handled intuitively in informal proofs), the authors reduce geometric constraints to Presburger arithmetic in $\mathbb{N}$ . This allows the use of Lean’s omega tactic to discharge complex linear arithmetic goals.
Computational Bridge: To move from existence proofs to actual calculation, they implement a "computable slice" of the logic. By establishing explicit bounds on the Coxeter length of elements in the set $A_d(u)$ , they transform infinite search spaces into finite sets (Finset), enabling the use of #eval for direct computation.

Key Contributions

Axiom-Free Formalization: A complete Lean 4 library that defines $D_\infty$ as a Coxeter system and formalizes the underlying moment graph.
Verification of Core Lemmas: The formal proof of the Parity of Chains lemma, which dictates how degrees accumulate across edges in the moment graph.
Proof of the Main Theorem: A machine-checked proof of the characterization of the curve neighborhood $\Gamma_d(u)$ as the set of maximal elements in the algebraically defined set $A_d(u)$ (multiplied by $u$ ).
Executable Implementation: The development of a fully verified, computable version of the curve neighborhood algorithm that can be executed within the Lean environment.

Results

The formalization successfully recovers and verifies the results of Mihalcea and Norton. Specifically:

The authors proved that the abstract definition of curve neighborhoods (based on graph reachability) is equivalent to the algebraic definition (based on length and degree).
The implementation allows for the instantaneous computation of neighborhoods. For example, the system correctly evaluates $\Gamma_{\langle 2,2 \rangle}(1) = \{r(2), r(-2)\}$ and $\Gamma_{\langle 2,3 \rangle}(s_0) = \{sr(-3)\}$ , matching known mathematical expectations.

Significance

This work demonstrates that complex combinatorial geometry and quantum Schubert calculus are amenable to formal verification. By successfully bridging high-level geometric reasoning with low-level list manipulation and computational execution, the paper provides a blueprint for formalizing other Kac-Moody group structures. It offers a reusable, mechanically verified framework that ensures absolute certainty in the calculation of algebraic neighborhoods, which is critical for further research in quantum K-theory and representation theory.