🔢 mathematics

LipschitzSaturation: A Macaulay2 Package for Computing Lipschitz Saturations of Modules and Toric Varieties

This paper introduces the Macaulay2 package *LipschitzSaturation*, which implements efficient algorithms for computing 1-, 2-, and 3-Lipschitz saturations of modules (utilizing a curve-based membership test to overcome computational bottlenecks) and constructs Lipschitz saturations for toric varieties.

Original authors: Guilherme Schultz Netto, Thiago da Silva

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Guilherme Schultz Netto, Thiago da Silva

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 have a magical, shape-shifting sculpture made of invisible threads. This sculpture represents a complex mathematical space, and the threads are the rules that govern how you can move around inside it. Sometimes, these rules are a bit "loose," allowing you to wiggle in ways that feel a little too slippery or unstable. Mathematicians want to tighten these rules to create a "Lipschitz saturation"—a perfectly smooth, stable version of the sculpture where every movement is strictly controlled and predictable.

The paper introduces a new digital tool called LipschitzSaturation, a software package for a computer algebra system named Macaulay2. Think of this package as a high-tech workshop that helps mathematicians figure out exactly which rules need tightening and which parts of the sculpture are already perfect.

The Three Levels of Tightening

The software doesn't just offer one way to fix the sculpture; it offers three distinct levels of "tightening," like adjusting the tension on a guitar string from a loose strum to a perfectly tuned note:

The 1-Lipschitz Saturation (The Strictest Check): This is the most fundamental check. It asks, "If I move from point A to point B, does the distance between my starting and ending points stay proportional?" The software checks this by creating a "double" version of the sculpture (imagine a mirror image) and testing if the rules hold up there.
The 2-Lipschitz Saturation (The Team Check): This level is slightly more relaxed. It checks if the rules hold when you look at the sculpture through different "lenses" or projections. If the rules work for every possible angle you look at, it passes.
The 3-Lipschitz Saturation (The Big Picture Check): This is the broadest check. It looks at the largest possible chunks of the sculpture to see if the rules hold for the whole structure.

The paper proves that these three levels are different. In fact, the 1-Lipschitz version is the strictest, the 2-Lipschitz is a bit looser, and the 3-Lipschitz is the most permissive. The software can tell you exactly which level a specific rule belongs to.

The Speed Bump and the Shortcut

Here is where the story gets exciting. When the mathematicians tried to calculate the 1-Lipschitz saturation using standard algebra, they hit a massive wall. As the shapes got more complex (specifically, as the "degree" of the polynomials grew), the computer would get stuck in an infinite loop of calculations, running out of memory or timing out after 20 minutes. It was like trying to count every single grain of sand on a beach by hand.

The paper's main finding is that they built a clever shortcut to bypass this wall. Instead of checking the whole beach, they decided to walk along a single, specific path (an "analytic curve") drawn through the sand. By testing the rules only along this path, the software could determine the answer almost instantly, regardless of how huge the beach was.

In their tests, this shortcut was a game-changer. For a family of shapes where the complexity grew, the old method took 443.7 seconds for a medium-sized problem and timed out (gave up) for larger ones. The new curve-based method solved the exact same problems in about 0.11 seconds. It turned a task that would make a computer cry into a task that took less time than it takes to blink.

The Toric Puzzle

The package also tackles a different kind of puzzle involving "Toric Singularities." Imagine a grid of dots representing a 3D shape. Sometimes, there are gaps in the grid where a dot should be to make the shape smooth, but it's missing. The software acts like a detective, scanning a finite search space to find exactly which missing dots belong.

It doesn't just guess; it uses a rigorous three-step filter:

It checks if the missing dot fits within the outer boundaries of the shape.
It checks if the dot sits correctly inside a "Newton Polyhedron" (a specific geometric boundary).
It verifies that the dot is a valid combination of the existing dots, using a special mathematical map to ensure it's not just a random number.

In a test case with a 3D shape, the software successfully identified a missing piece at coordinates [3, 3, 0] and added it to the list, confirming that the shape was now complete and smooth.

What the Paper Says (and Doesn't Say)

The authors are very clear about what their tool does and doesn't do. They explicitly state that the standard algebraic method for the 1-Lipschitz saturation is computationally intractable for large problems—it simply fails or takes too long. They do not claim to have fixed the math itself, but rather to have found a way to compute the answer without getting stuck.

The results for the curve-based method are measured and benchmarked. The paper provides concrete numbers showing the time difference between the old method and the new one, proving that the new method is vastly faster for the specific families of problems they tested. For the Toric Singularities, the paper describes an algorithm that constructs the solution, and they demonstrate it works on a specific 3D example.

The paper does not claim this solves every possible math problem in the universe. It focuses specifically on modules (collections of rules) and toric varieties (shapes built from grids). It also doesn't promise that the curve-based shortcut works for every single curve, but rather that it works for the specific types of parametric families that usually cause the computer to crash.

In short, LipschitzSaturation is a new, powerful tool that helps mathematicians smooth out complex shapes. It admits that the old way of doing things hits a brick wall for big problems, but it offers a clever, fast lane that zooms past the traffic, delivering answers in a fraction of a second where the old method would give up entirely.

Technical Summary: LipschitzSaturation Package

Problem Statement

The paper addresses the computational challenges associated with determining Lipschitz saturations in complex analytic geometry and toric varieties. While the theoretical framework for Lipschitz saturation—linking bi-Lipschitz equisingularity to algebraic normalization—was established by Pham, Teissier, Lipman, and others, practical verification remains difficult.

The core problem lies in the computational intractability of standard algebraic methods. Verifying membership in a Lipschitz saturation typically requires complex ideal membership tests via Gröbner basis reductions. As the number of variables or the degrees of generators increase, these calculations become prohibitively expensive, often leading to memory exhaustion or timeouts. This is particularly acute for parametric families where generator degrees grow, causing a combinatorial explosion in Buchberger's algorithm.

Methodology

The LipschitzSaturation package for Macaulay2 (version 1.22+) implements algorithms to compute three distinct saturation notions for modules and a construction algorithm for toric singularities. The methodology is divided into two primary domains:

1. Module Saturation

For an $\mathcal{O}_X$ -submodule $M \subseteq \mathcal{O}_X^p$ , the package computes three saturation levels ( $MS^1, MS^2, MS^3$ ) and an auxiliary "double module" $M^D$ .

Double Module Construction ( $M^D$ ): The package constructs the double module $M^D \subseteq \mathcal{O}_{X \times X}^{2p}$ using generators derived from the original module generators and coordinate differences $(z_i \circ \pi_1 - z_i \circ \pi_2)$ . This reduces the infinite set of elements to a finite generating set.
1-Lipschitz Saturation ( $MS^1$ ):
- Algebraic Criterion: The package employs the $\rho$ functor to translate module membership into an ideal membership problem within a larger polynomial ring. Instead of computing the full integral closure (which is memory-intensive), it utilizes the Northcott–Rees reduction criterion. This transforms the problem into checking if $J^k \subseteq I \cdot J^{k-1}$ for $J = I + \langle z \rangle$ , a task efficiently handled by Gröbner basis arithmetic.
- Geometric/Curve-Based Criterion: To bypass the exponential complexity of the algebraic method for parametric families, the package implements isMS1ElementOnCurve. This method pulls the computation back along a user-supplied analytic curve $\phi: (\mathbb{C}, 0) \to (X \times X, (x, x))$ . By mapping the problem to a univariate ring $\mathbb{Q}[t]$ , the membership test is resolved via polynomial division, achieving near-constant runtime regardless of the degree parameter.
2-Lipschitz Saturation ( $MS^2$ ): This saturation is tested by verifying if the contraction of $h$ with every linear form $\psi$ yields an element in the 1-Lipschitz saturation of the contracted module. For rank 2 modules, this is implemented via the ideal of $2 \times 2$ minors ( $J_2(h, M) \subseteq J_2(M)$ ).
3-Lipschitz Saturation ( $MS^3$ ): This is defined via the containment of ideals of maximal minors: $J_k(h, M) \subseteq (J_k(M))^S$ . The implementation uses Macaulay2's minors and integralClosure commands to test this directly.

2. Toric Singularities

For toric varieties, the goal is to construct the generator of the saturated algebra $\Gamma^S$ given a semigroup generator matrix $\Gamma$ .

Finite Search Space: The algorithm operates within a finite lattice grid determined by the maximum coordinate values of the original generators and the dual cone $\sigma^\vee$ .
Filtering Pipeline: Candidates are filtered through three rigorous criteria:
1. Projection Bounds: Ensuring the candidate's projection on cone facets does not exceed the maximum projection of original generators.
2. Newton Polyhedron Check: Mapping the problem to a homogenized cone in $\mathbb{Z}^{d+1}$ to eliminate elements below the characteristic boundary.
3. Module Map Verification: Using a homological constraint via a module map $\phi: \mathbb{Z}^n \to \mathbb{Z}^d$ to verify the candidate is a valid integer linear combination of generators, avoiding arithmetic failures inherent in standard scalar modulo checks.

Key Contributions

Implementation of Three Saturation Levels: The package provides the first systematic implementation for computing $MS^1$ , $MS^2$ , and $MS^3$ for modules, including the necessary auxiliary construction of the double module.
Curve-Based Optimization: The introduction of isMS1ElementOnCurve addresses the primary bottleneck of the algebraic approach. Benchmarks on the Fernandes–Ruas family demonstrate that while the algebraic method times out for parameters $n \geq 10$ , the curve-based method maintains a runtime of approximately 0.1–0.2 seconds even for $n=100$ .
Toric Saturation Algorithm: The package extends Lipschitz saturation theory to toric singularities by providing an algorithm that constructs saturated generators through a multidimensional filtering approach, scaling more efficiently than naive exhaustive searches.

Results

Performance: In the module setting, the curve-based membership test achieves near-constant time complexity for parametric families, whereas the purely algebraic method exhibits exponential growth in runtime and memory usage.
Correctness: The package correctly distinguishes between the three saturation levels. For example, in the provided case study, an element $h$ was found to be in $MS^2$ and $MS^3$ but not in $MS^1$ , confirming the strict inclusion $MS^1 \subsetneq MS^2 \subseteq MS^3$ .
Toric Validation: The algorithm successfully identified missing monomial generators (e.g., $[3, 3, 0]^T$ ) in a 3D non-isolated singularity, confirming the theoretical expectations for arbitrary dimensions.

Significance

The paper positions LipschitzSaturation as a necessary tool for bridging the gap between the abstract theory of Lipschitz equisingularity and practical computation. By encapsulating the overhead of Gröbner basis reductions and offering a specialized curve-based alternative, the package makes the verification of Lipschitz saturation properties feasible for examples that were previously computationally intractable. It provides a clean, user-facing interface for researchers working on bi-Lipschitz equisingularity, normalization, and toric singularities, allowing them to test membership and construct saturated algebras without manually managing the complex underlying algebraic machinery.