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

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	GroebnerBases.HilbertSeries	Hilbert-Poincare series HPS(t) = P(t) / (1 - t)^m
static interface	GroebnerBases.MinimizationStrategy	Strategy used to reduce and minimize basis in the intermediate steps of Buchberger algorithm
static class	GroebnerBases.SyzygyPair<Term extends AMonomial<Term>,Poly extends cc.redberry.rings.poly.multivar.MonomialSetView<Term>>	Abstract critical pair: used with different Poly type for Buchberger and F4 algorithms

Field Summary

Fields

Modifier and Type	Field	Description
static GroebnerBases.MinimizationStrategy	NO_MINIMIZATION	no any minimization at intermediate steps, just keep all track of generators as is

Method Summary

Modifier and Type	Method	Description
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.
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.
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
static Comparator<GroebnerBases.SyzygyPair>	defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder)	Default selection strategy (with or without sugar)
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.
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.
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.
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.
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.
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
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> List<Poly>	GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal)	computes Groebner basis in GREVLEX with shuffled variables
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
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
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
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.
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
static GroebnerBases.HilbertSeries	HilbertSeries(List<DegreeVector> ideal)	Computes Hilbert-Poincare series of monomial ideal
static GroebnerBases.HilbertSeries	HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal)	Computes Hilbert-Poincare series of specified ideal given by its Groebner basis
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
static boolean	isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal)	Check whether ideal is homogeneous
static boolean	isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal)	Check whether all specified generators are monomials
static List<DegreeVector>	leadTermsSet(List<? extends AMultivariatePolynomial> ideal)	List of lead terms of generators
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> void	minimizeGroebnerBases(List<Poly> basis)	Minimizes Groebner basis.
static cc.redberry.rings.poly.multivar.GroebnerBases.GBResult<Monomial<BigInteger>,MultivariatePolynomial<BigInteger>>	ModularGB(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder)	Modular Groebner basis algorithm.
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.
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.
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.
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
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> Comparator<DegreeVector>	optimalOrder(List<Poly> ideal)	Deduce the optimal order for GB algorithms
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> void	removeRedundant(List<Poly> basis)	Computes reduced Groebner basis
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".
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> Poly	syzygy(GroebnerBases.SyzygyPair<Term,Poly> sPair)	Computes syzygy of given polynomials
static <Term extends AMonomial<Term>,Poly extends AMultivariatePolynomial<Term,Poly>> Poly	syzygy(Poly a, Poly b)	Computes syzygy of given polynomials
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

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NO_MINIMIZATION

public static GroebnerBases.MinimizationStrategy NO_MINIMIZATION

no any minimization at intermediate steps, just keep all track of generators as is

Method Detail

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