🔢 mathematics

Certifying Galois/monodromy Actions via Homotopy Graphs

This paper presents a certified numerical algorithm that utilizes homotopy path tracking to rigorously compute and verify Galois/monodromy groups for parametrized polynomial systems, demonstrating its effectiveness through extensive experiments on examples from both pure and applied mathematics.

Original authors: Timothy Duff, Kisun Lee

Published 2026-03-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Timothy Duff, Kisun Lee

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 detective trying to solve a massive puzzle, but the puzzle pieces keep changing shape depending on how you hold the box they are in. This is the world of parametric polynomial systems.

In mathematics, these are equations where the answers (the solutions) depend on certain knobs or dials (the parameters). If you turn a dial slightly, the solutions move smoothly. But if you turn the dial in a big circle, the solutions might swap places with each other, like dancers in a choreographed routine.

The paper by Timothy Duff and Kisun Lee is about building a super-accurate, fail-safe robot to watch these dancers and figure out exactly how they swap places. This swapping pattern is called the Monodromy Group (or Galois Group), and it tells us the "personality" or structural complexity of the problem.

Here is the breakdown of their work using simple analogies:

1. The Problem: The "Jumpy" Dancers

In the past, mathematicians used computers to track these solutions. They would draw a line on a map (a path) and tell the computer, "Follow this line and see where the solution ends up."

But computers use "floating-point" math, which is like a slightly blurry camera. Sometimes, the camera gets confused. The solution might look like it's on Path A, but because of a tiny rounding error, the computer thinks it jumped to Path B.

The Analogy: Imagine trying to follow a specific person in a crowded dance hall. If your vision is blurry, you might lose them and accidentally start following a different person who looks similar. If you do this, you'll think the dancers swapped in a pattern that never actually happened. The result is a wrong answer.

2. The Solution: The "Safety Bubble"

The authors' big idea is to stop using blurry cameras and start using Interval Arithmetic.

Instead of saying, "The solution is exactly at point X," they say, "The solution is definitely somewhere inside this tiny, shrinking safety bubble around point X."

The Analogy: Instead of trying to follow a single dancer, you put a glowing, transparent bubble around them. As they move, you shrink and expand the bubble to ensure the dancer never leaves it. Even if the computer makes a tiny mistake, the bubble is big enough to catch the error, guaranteeing the dancer is still inside.
The Krawczyk Test: This is the mathematical "security guard" that checks the bubble. It proves, with 100% certainty, that there is exactly one dancer inside the bubble and no one else.

3. The Map: The "Homotopy Graph"

To figure out the whole dance routine, you can't just watch one circle. You need to watch many loops. The authors build a Homotopy Graph.

The Analogy: Imagine a city map where every intersection is a different setting for your puzzle (different parameter values). The roads connecting them are the paths the solutions travel.
- Vertices (Intersections): Different settings of the knobs.
- Edges (Roads): The paths you travel between settings.
- Saturation: You keep driving these roads until you are absolutely sure you've seen every possible swap between every possible solution.

4. The Result: Certifying the "Galois Width"

Once the robot has safely tracked all the paths on this graph, it can tell you the rules of the dance.

The Group: It tells you the group of all possible swaps. Is it a simple swap? A complex shuffle?
Galois Width: This is a new metric they highlight. Think of it as a measure of structural complexity.
- Analogy: If the dance is just two people swapping, the complexity is low (width 1). If it's a massive, intricate ballet with 20 people swapping in layers, the complexity is high.
- The paper shows that even if you haven't found every single dancer (solution), you can often determine the complexity level (the width) very early on. This is huge because it tells you how hard the problem is before you've even finished solving it.

Real-World Examples They Tested

They didn't just play with abstract math; they tested their robot on real-world problems:

Computer Vision (P3P & 5-point problems): Figuring out where a camera is in 3D space based on a few points. This is crucial for self-driving cars and AR. Their method proved exactly how many ways the camera could be positioned and how complex those possibilities are.
The 27 Lines on a Cube: A classic geometry problem. They proved that on a specific type of curved surface, the 27 lines don't just swap randomly; they follow a very specific, smaller group of rules.
The Mathieu Group (M23): A rare, exotic mathematical object. They used their method to prove that a specific polynomial equation has this rare group as its "dance partner," something that was previously very hard to prove without guessing.

Why This Matters

Before this paper, if a computer said, "I think the answer is X," you had to trust it, hoping the math didn't glitch.
This paper gives you a guarantee. It says, "We didn't just guess; we built a safety bubble around every step. We know for a fact that the solutions moved exactly this way."

It turns a "likely correct" numerical guess into a rigorous mathematical proof, allowing scientists to trust the structural complexity of problems in engineering, physics, and computer vision without fear of hidden errors.

1. Problem Statement

The paper addresses the challenge of computing Galois/monodromy groups for parametrized systems of algebraic equations.

Context: Many problems in applied and computational algebraic geometry can be modeled as $F(x; z) = 0$ , where $x$ represents solutions and $z$ represents parameters. For generic $z$ , there are $d$ isolated complex solutions.
The Challenge: As parameters $z$ traverse a loop in the parameter space (avoiding a branching locus), the solutions $x$ undergo analytic continuation and are permuted. The group of these permutations is the monodromy group (or geometric Galois group).
Current Limitations: While numerical homotopy methods exist to compute these groups, they typically rely on floating-point arithmetic. This introduces the risk of "path jumping" (tracking a solution to the wrong branch), which leads to incorrect group structures. Existing post-hoc certification methods (verifying a single solution) are insufficient to guarantee that the tracking process itself followed a single continuous path without jumping.

2. Methodology

The authors propose a certified numerical algorithm that fuses homotopy path tracking with interval arithmetic to rigorously guarantee the correctness of the computed monodromy action.

A. Certified Path Tracking

Instead of standard floating-point tracking, the algorithm uses interval arithmetic and the Krawczyk method to enclose solution paths.

Interval Enclosure: The algorithm constructs a sequence of interval boxes $I_k$ that strictly contain the solution path $x(t)$ over time intervals $[t_{k-1}, t_k]$ .
Krawczyk Test: For each step, a Krawczyk operator is computed. If the test passes, it mathematically proves the existence of a unique solution within the interval box, ensuring the path did not jump to a different branch.
Predictor-Corrector: The method employs a predictor (using Hermite interpolation based on previous steps) to estimate the next point and a refinement loop (Algorithm 2) to tighten the interval radius until the Krawczyk test is satisfied.

B. Homotopy Graph Framework

The algorithm builds upon a graph-based framework where the parameter space is discretized into a graph:

Vertices: Generic parameter points $z_i$ .
Edges: Paths (linear segments) connecting vertices $z_i$ and $z_j$ .
Edge Correspondence: By tracking solutions along an edge $e=(z_i, z_j)$ , the algorithm establishes a bijection (correspondence) between the solution sets at $z_i$ and $z_j$ .
Saturation: The graph is "saturated" when every solution at every vertex has been tracked to every other vertex via the graph edges.

C. Monodromy Extraction

Once a saturated homotopy graph is constructed:

A spanning tree is rooted at a base vertex $z_0$ .
For every non-tree edge (forming a fundamental cycle), the algorithm composes the edge correspondences to generate a permutation of the solutions at $z_0$ .
The set of these permutations generates the monodromy group (or a subgroup thereof).

3. Key Contributions

Rigorous Certification: The primary contribution is the first algorithm that certifies the monodromy action itself, not just the final solutions. By using interval arithmetic to prevent path jumping, the computed permutations are mathematically guaranteed to be correct.
Experimental Approach to Group Recovery: Unlike previous works attempting to algorithmically determine the full group structure, this approach focuses on rigorously certifying the action of a subgroup. Even if the full group is not recovered, the method provides rigorous bounds on group invariants.
Galois Width: The authors leverage the concept of Galois width ($gwp(G)$), a measure of structural complexity. They prove that the Galois width of the computed subgroup is a lower bound for the true Galois width of the full monodromy group. This allows for rigorous claims about the problem's complexity even with partial data.
Implementation: The authors implemented the framework in Julia using the Nemo.jl and Arb libraries for arbitrary-precision interval arithmetic.

4. Experimental Results

The authors tested the algorithm on a diverse set of problems ranging from pure mathematics to computer vision.

Univariate Families: Tested on generic polynomials and those with symmetries (e.g., palindromic, even degrees).
- Result: Success rates in recovering the exact group and Galois width increased with the number of nodes in the homotopy graph. Notably, Galois width was often recovered correctly even when the full group or all roots were not found.
Belyi Function (Mathieu Group $M_{23}$ ):
- Result: Successfully certified that the monodromy group of a specific degree-23 Belyi polynomial is the sporadic Mathieu group $M_{23}$ . This resolved a problem requiring high-precision estimates that were previously difficult to guarantee.
27 Lines on a Cubic Surface:
- Result: Verified the intransitive monodromy group $S_2 \times S_2$ acting on the 27 lines of a symmetric cubic surface, confirming the decomposition of the solution variety into distinct orbits.
Nearest Point on a Surface:
- Result: Certified that the Galois group contains the imprimitive group $S_4 \wr S_2$ , demonstrating the utility of the method for Euclidean distance degree problems.
Computer Vision (P3P and 5-Point Relative Pose):
- Result: Rigorously certified the monodromy groups for the Perspective-3-Point problem ( $S_2 \wr S_4 \cap A_8$ ) and the 5-point relative pose problem ( $S_2 \wr S_{10} \cap A_{20}$ ). These are minimal problems in computer vision where the number of solutions is small but the symmetry structure is complex.

5. Significance

Reliability in Algebraic Geometry: The paper bridges the gap between fast, heuristic numerical methods and rigorous symbolic computation. It allows researchers to trust numerical results regarding group structures without needing to perform expensive symbolic elimination.
Complexity Analysis: By providing a certified lower bound on Galois width, the method offers a new tool for assessing the intrinsic difficulty of solving parametrized systems before a full solution set is found.
Applications: The framework is applicable to any problem modeled as a parametrized polynomial system, with immediate relevance to robotics, computer vision, and enumerative geometry.
Scalability: While certified tracking is slower than floating-point tracking due to smaller step sizes, the experiments show it is computationally feasible for problems with dozens of solutions and complex group structures.

In summary, Duff and Lee provide a robust, mathematically sound framework for computing monodromy groups, transforming numerical homotopy methods from heuristic tools into certified algorithms capable of proving structural properties of algebraic systems.