Package cc.redberry.rings.poly.multivar

Class GroebnerBases

java.lang.Object
cc.redberry.rings.poly.multivar.GroebnerBases
public final class GroebnerBases
extends Object
Groebner bases.
Since:
2.3

  • Field Details

  • Method Details

    • GroebnerBasis

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> GroebnerBasis​(List<Poly> generators, Comparator<DegreeVector> monomialOrder)
      Computes Groebner basis (minimized and reduced) of a given ideal represented by a list of generators.

      The implementation switches between F4 algorithm (for graded orders) and Hilbert-driven Buchberger algorithm for hard orders like LEX. For polynomials over Q modular methods are also used in some cases.

      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order
      Returns:
      Groebner basis

    • GroebnerBasisInGF

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> GroebnerBasisInGF​(List<Poly> generators, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries)
      Computes Groebner basis (minimized and reduced) of a given ideal over finite filed represented by a list of generators.

      The implementation switches between F4 algorithm (for graded orders) and Hilbert-driven Buchberger algorithm for hard orders like LEX.

      If a non null value for Hilbert-Poincare series hilbertSeries is passed, it will be used to speed up computations with some Hilbert-driven criteria.

      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order
      hilbertSeries - optional Hilbert-Poincare series (may be null)
      Returns:
      Groebner basis

    • GroebnerBasisInZ

      public static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,​MultivariatePolynomial<BigInteger>> GroebnerBasisInZ​(List<MultivariatePolynomial<BigInteger>> generators, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries, boolean tryModular)
      Computes Groebner basis (minimized and reduced) of a given ideal over Z represented by a list of generators.

      The implementation switches between F4 algorithm (for graded orders) and Hilbert-driven Buchberger algorithm for hard orders like LEX. For polynomials in less or equals than three variables modular algorithm is used.

      If a non null value for Hilbert-Poincare series hilbertSeries is passed, it will be used to speed up computations with some Hilbert-driven criteria.

      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order
      hilbertSeries - optional Hilbert-Poincare series (may be null)
      Returns:
      Groebner basis

    • GroebnerBasisInQ

      public static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ​(List<MultivariatePolynomial<Rational<BigInteger>>> generators, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries, boolean tryModular)
      Computes Groebner basis (minimized and reduced) of a given ideal over Q represented by a list of generators.

      The implementation switches between F4 algorithm (for graded orders) and Hilbert-driven Buchberger algorithm for hard orders like LEX. For polynomials in less or equals than three variables modular algorithm is used.

      If a non null value for Hilbert-Poincare series hilbertSeries is passed, it will be used to speed up computations with some Hilbert-driven criteria.

      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order
      hilbertSeries - optional Hilbert-Poincare series (may be null)
      Returns:
      Groebner basis

    • ConvertBasis

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> ConvertBasis​(List<Poly> generators, Comparator<DegreeVector> desiredOrder)
      Converts basis into a basis for desired monomial order

    • minimizeGroebnerBases

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> void minimizeGroebnerBases​(List<Poly> basis)
      Minimizes Groebner basis. The input should be a Groebner basis

    • removeRedundant

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> void removeRedundant​(List<Poly> basis)
      Computes reduced Groebner basis

    • syzygy

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> Poly syzygy​(Poly a, Poly b)
      Computes syzygy of given polynomials

    • syzygy

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> Poly syzygy​(GroebnerBases.SyzygyPair<Term,​Poly> sPair)
      Computes syzygy of given polynomials

    • isGroebnerBasis

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> boolean isGroebnerBasis​(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder)
      Check whether specified generators form Groebner basis of given ideal

    • normalSelectionStrategy

      public static Comparator<GroebnerBases.SyzygyPair> normalSelectionStrategy​(Comparator<DegreeVector> monomialOrder)
      Normal selection strategy: chose syzygy with the less lcm(fi.lt(), fj.lt()) with respect to monomialOrder

    • withSugar

      public static Comparator<GroebnerBases.SyzygyPair> withSugar​(Comparator<GroebnerBases.SyzygyPair> initial)
      Add sugar to selection strategy: pick syzygy with less sugar first, break tie with the initial strategy

    • defaultSelectionStrategy

      public static Comparator<GroebnerBases.SyzygyPair> defaultSelectionStrategy​(Comparator<DegreeVector> monomialOrder)
      Default selection strategy (with or without sugar)

    • BuchbergerGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> BuchbergerGB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder)
      Computes minimized and reduced Groebner basis of a given ideal via Buchberger algorithm. It uses normal strategy for graded orders and sugar strategy for lexicographic.

    • BuchbergerGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> BuchbergerGB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder, Comparator<GroebnerBases.SyzygyPair> strategy)
      Computes minimized and reduced Groebner basis of a given ideal via Buchberger algorithm.
      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order
      strategy - selection strategy

    • HilbertGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> HilbertGB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries)
      Hilbert-driven algorithm for Groebner basis computation
      Parameters:
      generators - generators of homogeneous ideal
      monomialOrder - monomial order
      hilbertSeries - Hilbert-Poincare series

    • HilbertConvertBasis

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> HilbertConvertBasis​(List<Poly> groebnerBasis, Comparator<DegreeVector> desiredOrdering)
      Converts Groebner basis to a given monomial order using Hilbert-driven algorithm

    • HilbertGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> HilbertGB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder)
      Hilbert-driven algorithm for Groebner basis computation
      Parameters:
      generators - generators of homogeneous ideal
      monomialOrder - monomial order

    • HilbertGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> HilbertGB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder, cc.redberry.rings.poly.multivar.GroebnerBases.GroebnerAlgorithm<Term,​Poly> baseAlgorithm)
      Hilbert-driven algorithm for Groebner basis computation. It computes first Groebner basis for some easy monomial order to find Hilbert-Poincare series of the ideal and then runs Hilbert-driven algorithm to obtain the result.
      Parameters:
      generators - generators of homogeneous ideal
      monomialOrder - monomial order
      baseAlgorithm - algorithm used to compute basis for some "simple" order

    • GroebnerBasisWithOptimizedGradedOrder

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> GroebnerBasisWithOptimizedGradedOrder​(List<Poly> ideal)
      computes Groebner basis in GREVLEX with shuffled variables

    • GroebnerBasisWithOptimizedGradedOrder

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> GroebnerBasisWithOptimizedGradedOrder​(List<Poly> ideal, cc.redberry.rings.poly.multivar.GroebnerBases.GroebnerAlgorithm<Term,​Poly> baseAlgorithm)
      computes Groebner basis in GREVLEX with shuffled variables

    • GroebnerBasisRegardingGrevLexWithPermutation

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> GroebnerBasisRegardingGrevLexWithPermutation​(List<Poly> ideal, cc.redberry.rings.poly.multivar.GroebnerBases.GroebnerAlgorithm<Term,​Poly> baseAlgorithm, MonomialOrder.GrevLexWithPermutation order)
      computes Groebner basis in GREVLEX with shuffled variables

    • optimalOrder

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> Comparator<DegreeVector> optimalOrder​(List<Poly> ideal)
      Deduce the optimal order for GB algorithms

    • F4GB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Term,​Poly> F4GB​(List<Poly> generators, Comparator<DegreeVector> monomialOrder)
      Computes minimized and reduced Groebner basis of a given ideal via Faugère's F4 F4 algorithm.
      Parameters:
      generators - generators of the ideal
      monomialOrder - monomial order to use

    • isMonomialIdeal

      public static boolean isMonomialIdeal​(List<? extends AMultivariatePolynomial> ideal)
      Check whether all specified generators are monomials

    • isHomogeneousIdeal

      public static boolean isHomogeneousIdeal​(List<? extends AMultivariatePolynomial> ideal)
      Check whether ideal is homogeneous

    • leadTermsSet

      public static List<DegreeVector> leadTermsSet​(List<? extends AMultivariatePolynomial> ideal)
      List of lead terms of generators

    • HilbertSeriesOfLeadingTermsSet

      public static GroebnerBases.HilbertSeries HilbertSeriesOfLeadingTermsSet​(List<? extends AMultivariatePolynomial> ideal)
      Computes Hilbert-Poincare series of specified ideal given by its Groebner basis

    • HilbertSeries

      public static GroebnerBases.HilbertSeries HilbertSeries​(List<DegreeVector> ideal)
      Computes Hilbert-Poincare series of monomial ideal

    • ModularGB

      public static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,​MultivariatePolynomial<BigInteger>> ModularGB​(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder)
      Modular Groebner basis algorithm. The algorithm switches between modular Chinese remainder techniques as described in Elizabeth A. Arnold, "Modular algorithms for computing Groebner bases", Journal of Symbolic Computation 35 (2003) 403–419 and sparse Groebner basis reconstruction with linear algebra (solveGB(List, List, Comparator)).

    • ModularGB

      public static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,​MultivariatePolynomial<BigInteger>> ModularGB​(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries)
      Modular Groebner basis algorithm. The algorithm switches between modular Chinese remainder techniques as described in Elizabeth A. Arnold, "Modular algorithms for computing Groebner bases", Journal of Symbolic Computation 35 (2003) 403–419 and sparse Groebner basis reconstruction with linear algebra (solveGB(List, List, Comparator)).
      Parameters:
      hilbertSeries - optional Hilbert-Poincare series of ideal

    • ModularGB

      public static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,​MultivariatePolynomial<BigInteger>> ModularGB​(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder, GroebnerBases.HilbertSeries hilbertSeries, boolean trySparse)
      Modular Groebner basis algorithm. The algorithm switches between modular Chinese remainder techniques as described in Elizabeth A. Arnold, "Modular algorithms for computing Groebner bases", Journal of Symbolic Computation 35 (2003) 403–419 and sparse Groebner basis reconstruction with linear algebra.
      Parameters:
      ideal - ideal generators
      monomialOrder - monomial order
      hilbertSeries - optional Hilbert-Poincare series of ideal
      trySparse - whether to try sparse reconstruction in particularly small resulting bases via solveGB(List, List, Comparator)

    • ModularGB

      public static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,​MultivariatePolynomial<BigInteger>> ModularGB​(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder, cc.redberry.rings.poly.multivar.GroebnerBases.GroebnerAlgorithm modularAlgorithm, cc.redberry.rings.poly.multivar.GroebnerBases.GroebnerAlgorithm defaultAlgorithm, BigInteger firstPrime, GroebnerBases.HilbertSeries hilbertSeries, boolean trySparse)
      Modular Groebner basis algorithm. The algorithm switches between modular Chinese remainder techniques as described in Elizabeth A. Arnold, "Modular algorithms for computing Groebner bases", Journal of Symbolic Computation 35 (2003) 403–419 and sparse Groebner basis reconstruction with linear algebra.
      Parameters:
      ideal - ideal generators
      monomialOrder - monomial order
      modularAlgorithm - algorithm used to find Groebner basis mod prime
      defaultAlgorithm - algorithm used to find Groebner basis if modular algorithm failed
      firstPrime - prime number to start modulo iterations
      hilbertSeries - optional Hilbert-Poincare series of ideal
      trySparse - whether to try sparse reconstruction in particularly small resulting bases via solveGB(List, List, Comparator)

    • solveGB

      public static <Term extends AMonomial<Term>,​ Poly extends AMultivariatePolynomial<Term,​ Poly>> List<Poly> solveGB​(List<Poly> generators, List<Collection<DegreeVector>> gbSkeleton, Comparator<DegreeVector> monomialOrder)
      Sparse Groebner basis via "linear lifting". Given a generating set and a skeleton of Groebner basis (may be computed via mod prime etc.), it build a system of equations and finds a true Groebner basis, or return null if the system was not solvable.
      Parameters:
      generators - generators
      gbSkeleton - skeleton of true reduced Groebner basis
      monomialOrder - monomial order