CommutativeAlgebra: new triangular decomposition wrapper

Author: YueRen

docs/oscar_references.bib

@@ -1550,6 +1550,15 @@ @Article{Haz12
   doi           = {10.3390/axioms1020149}
 }
 
+@MastersThesis{Hil99,
+  author        = {Hillebrand, D.},
+  title         = {Triangulierung nulldimensionaler Ideale - Implementierung und Vergleich zweier Algorithmen},
+  note          = {Refereed by Prof. Dr. H.M. Moeller},
+  address       = {Fachbereich Mathematik},
+  year          = {1999},
+  school        = {Universitaet Dortmund}
+}
+
 @Article{Hul22,
   author        = {Hulpke, Alexander},
   title         = {The perfect groups of order up to two million},
@@ -2001,6 +2010,21 @@ @Book{Lan70
   year          = {1970}
 }
 
+@Article{Laz92,
+  author        = {Lazard, D.},
+  title         = {Solving Zero-Dimensional Algebraic Systems},
+  journal       = {Journal of Symbolic Computation},
+  volume        = {13},
+  number        = {2},
+  pages         = {117--131},
+  year          = {1992},
+  month         = feb,
+  doi           = {10.1016/S0747-7171(08)80086-7},
+  urldate       = {2025-03-28},
+  copyright     = {https://www.elsevier.com/tdm/userlicense/1.0/},
+  langid        = {english}
+}
+
 @PhDThesis{Lev05,
   author        = {Viktor Levandovskyy},
   title         = {Non-commutative Computer Algebra for polynomial algebras: Gröbner bases, applications and
@@ -2118,6 +2142,21 @@ @Book{Mar18
   doi           = {10.1007/978-3-319-90233-3}
 }
 
+@Article{Moe93,
+  author        = {Moeller, H. Michael},
+  title         = {On Decomposing Systems of Polynomial Equations with Finitely Many Solutions},
+  journal       = {Applicable Algebra in Engineering, Communication and Computing},
+  volume        = {4},
+  number        = {4},
+  pages         = {217--230},
+  year          = {1993},
+  month         = dec,
+  doi           = {10.1007/BF01200146},
+  urldate       = {2025-03-28},
+  copyright     = {http://www.springer.com/tdm},
+  langid        = {english}
+}
+
 @Article{Nik79,
   author        = {Nikulin, V. V.},
   title         = {Integer symmetric bilinear forms and some of their geometric applications},

docs/src/CommutativeAlgebra/ideals.md

@@ -256,9 +256,16 @@ equidimensional_hull(I::MPolyIdeal)
 equidimensional_hull_radical(I::MPolyIdeal)
 ```
 
+### Triangular Decomposition
+
+```@docs
+triangular_decomposition(::MPolyIdeal, ::Symbol)
+```
+
+
 ## Homogenization and Dehomogenization
 
-Referring to [KR05](@cite) for definitions and technical details, we discuss homogenization and dehomogenization in the context of $\mathbb Z^m$-gradings. 
+Referring to [KR05](@cite) for definitions and technical details, we discuss homogenization and dehomogenization in the context of $\mathbb Z^m$-gradings.
 
 ```@docs
 homogenizer(P::MPolyRing{T}, h::VarName; pos::Int=1+ngens(P))  where T

src/Rings/mpoly-ideals.jl

@@ -1572,6 +1572,88 @@ function equidimensional_hull_radical(
   return ideal(R, unique!(iso.(gens(res))))
 end
 
+################################################################################
+#
+#  triangular decomposition
+#
+################################################################################
+
+@doc raw"""
+    triangular_decomposition(I::MPolyIdeal; algorithm::Symbol=:Lazard)
+
+Return a triangular decomposition of a zero-dimensional `I`.
+
+The default algorithm is `:Lazard` based on [Laz92](@cite).  Algorithm `:LazardFactorized` further
+factorizes each polynomial in the output of `:Lazard`. Algorithm `:Moeller` is based on [Moe93](@cite)
+and Algorithm `:MoellerHillebrand` is based on [Hill99](@cite).
+
+# Examples
+```jldoctest
+julia> R, (x1,x2,x3,x4,x5) = polynomial_ring(QQ, [:x1,:x2,:x3,:x4,:x5]);
+
+julia> I = ideal([x1+x2+x3+x4+x5,
+                  x1*x2+x2*x3+x3*x4+x1*x5+x4*x5,
+                  x1*x2*x3+x2*x3*x4+x1*x2*x5+x1*x4*x5+x3*x4*x5,
+                  x1*x2*x3*x4+x1*x2*x3*x5+x1*x2*x4*x5+x1*x3*x4*x5+x2*x3*x4*x5,
+                  x1*x2*x3*x4*x5-1]);
+
+julia> triangular_decomposition(I)
+4-element Vector{MPolyIdeal{QQMPolyRingElem}}:
+ Ideal (x5^5 - 1, x4 - x5, x3^2 + 3*x3*x5 + x5^2, x2 + x3 + 3*x5, x1 - x5)
+ Ideal (x5^5 - 1, x4 - x5, x3 - x5, x2^2 + 3*x2*x5 + x5^2, x1 + x2 + 3*x5)
+ Ideal with 5 generators
+ Ideal with 5 generators
+
+julia> triangular_decomposition(I, :LazardFactorized)
+13-element Vector{MPolyIdeal{QQMPolyRingElem}}:
+ Ideal (x5 - 1, x4 - 1, x3 - 1, x2^2 + 3*x2 + 1, x1 + x2 + 3)
+ Ideal (x5 - 1, x4 - 1, x3^2 + 3*x3 + 1, x2 + x3 + 3, x1 - 1)
+ Ideal (x5 - 1, x4^2 + 3*x4 + 1, x3 + x4 + 3, x2 - 1, x1 - 1)
+ Ideal (x5 - 1, x4^4 + x4^3 + x4^2 + x4 + 1, -x3 + x4^2, -x2 + x4^3, x1 + x4^3 + x4^2 + x4 + 1)
+ Ideal (x5^2 + 3*x5 + 1, x4 - 1, x3 - 1, x2 - 1, x1 + x5 + 3)
+ Ideal (x5^2 + 3*x5 + 1, x4 + x5 + 3, x3 - 1, x2 - 1, x1 - 1)
+ ⋮
+ Ideal (x5^4 + x5^3 + x5^2 + x5 + 1, x4 - x5, x3 - x5, x2^2 + 3*x2*x5 + x5^2, x1 + x2 + 3*x5)
+ Ideal (x5^4 + x5^3 + x5^2 + x5 + 1, x4 - x5, x3^2 + 3*x3*x5 + x5^2, x2 + x3 + 3*x5, x1 - x5)
+ Ideal with 5 generators
+ Ideal (x5^4 + x5^3 + x5^2 + x5 + 1, x4^2 + 3*x4*x5 + x5^2, x3 + x4 + 3*x5, x2 - x5, x1 - x5)
+ Ideal with 5 generators
+
+julia> triangular_decomposition(I, :Moeller)
+4-element Vector{MPolyIdeal{QQMPolyRingElem}}:
+ Ideal (x5^5 - 1, x4 - x5, x3 - x5, x2^2 + 3*x2*x5 + x5^2, x1 + x2 + 3*x5)
+ Ideal with 5 generators
+ Ideal with 5 generators
+ Ideal (x5^5 - 1, x4 - x5, x3^2 + 3*x3*x5 + x5^2, x2 + x3 + 3*x5, x1 - x5)
+
+julia> triangular_decomposition(I, :MoellerHillebrand)
+4-element Vector{MPolyIdeal{QQMPolyRingElem}}:
+ Ideal (x5^5 - 1, x4 - x5, x3 - x5, x2^2 + 3*x2*x5 + x5^2, x1 + x2 + 3*x5)
+ Ideal with 5 generators
+ Ideal with 5 generators
+ Ideal (x5^5 - 1, x4 - x5, x3^2 + 3*x3*x5 + x5^2, x2 + x3 + 3*x5, x1 - x5)
+
+```
+"""
+function triangular_decomposition(I::MPolyIdeal, algorithm::Symbol=:Lazard)
+  @req dim(I)==0 "The ideal must be zero-dimensional."
+  R = base_ring(I)
+  G = ideal(groebner_basis(I; ordering=lex(R), complete_reduction=true))
+  Gsing = singular_generators(G,lex(R))
+  if algorithm==:Lazard
+    Ts = Singular.LibTriang.triangL(Gsing)
+  elseif algorithm==:LazardFactorized
+    Ts = Singular.LibTriang.triangLfak(Gsing)
+  elseif algorithm==:Moeller
+    Ts = Singular.LibTriang.triangM(Gsing)
+  elseif algorithm==:MoellerHillebrand
+    Ts = Singular.LibTriang.triangMH(Gsing)
+  else
+    error("algorithm allowed are :Lazard, :LazardFactorized, :Moeller, or :MoellerHillebrand")
+  end
+  return [ideal(R, T) for T in Ts]
+end
+
 #######################################################
 @doc raw"""
     ==(I::MPolyIdeal, J::MPolyIdeal)

src/exports.jl

@@ -1657,6 +1657,7 @@ export transitive_group_identification, has_transitive_group_identification
 export transitivity
 export transport
 export transportation_polytope
+export triangular_decomposition
 export trivial_character
 export trivial_divisor
 export trivial_divisor_class