Computing a Janet basis

To compute a Janet basis the user should use the class Involutive::JBMill::Builder. To construct a Involutive::JBMill::Builder object the user has to use the standard constructor. For configuration of the building process there are several methods:

• setInput(v) -- v must be a vector<RingElem>. It sets the generating set of the ideal to v.
• setInput(cBegin, cEnd) -- cBegin and cEnd must be a vector<RingElem>::const_iterator and must define a range of RingElem. The method sets the generating set of the ideal to this range.
• setStrategy(strat) -- strat must be a Involutive::StrategyFlag. Possible enums are TQDegree, TQBlockHigh, TQBlockLow and GBCompletion. It defines the algorithm which should be used to compute a Janet basis. If this method is never called the Builder object uses the TQBlockLow strategy.
• setInvolutiveCriteria(crits) -- crits must be a bitset<3>. Every bit represents one of the three involutive criteria. If this method is never called the Builder object uses the first two involutive criteria.
  The methods are chainable, e.g. the user can do the following: builder.setInput(input).setStrategy(Involutive::TQDegree). If the user calls a method more than one time only the input of the last method call is taken into account. To construct a JBMill out of a correctly configured builder object build the user has to use JBMill(build). If the user does not set a input the construction of a JBMill will fail.

Using the JBMill

In the following let elem be a RingElem.

• myReturnJB() -- returns the minimal Janet basis as vector<RingElem>
• myReturnGB() -- returns the minimal Groebner basis as vector<RingElem>
• myPrintMultVar() -- prints the multiplicative variables of every element in the given Janet basis
• myPrintNonMultVar() -- prints the nonmultiplicative variables of every element in the given Janet basis
• myMultVars() -- compute the multiplicative variables of the given Janet basis. It returns a map<PPMonoidElem, vector<bool> > where the key is a LPP of an element in the Janet basis.
• myNonMultVars() -- compute the nonmultiplicative variables of the given Janet basis. It returns a map<PPMonoidElem, vector<bool> > where the key is a LPP of an element in the Janet basis.
• myNonMultVarsOf(elem) -- computes the nonmultiplicative variables of elem which must be a member of the Janet basis. If not we assume that every variable is nonmultiplicative. It returns a vector<bool>.
• IamPommaretBasis -- checks if the Janet basis is also a Pommaret basis. It returns a boolean.
• IamHomogenous -- checks if the Janet basis is also homogeneous. It returns a boolean.
• IamMonomialIdeal -- checks if the Janet basis is also a monomial ideal. It returns a boolean.
• myStandardRepresentation(elem) -- compute the involutive standard representation of elem. It returns pair<map<PPMonoidElem, RingElem>, RingElem>. The first entry of the pair is a map, where the key represents the LPP of an element in the Janet basis and the value the corresponding factor. The second entry of the pair corresponds to the rest.
• myOutputStandardRepresentation(elem) -- computes an involutive standard representation of elem.
• myHilbertPol(elem) -- elem must be a single indent. The method computes the Hilbert polynomial of the ideal in terms of elem.
• myHilbertFunc(n) -- n must be a BigInt. The method computes the dimension of P/I in degree n.
• myHilbertSeries(elem) -- elem must be a single indent of a fraction field. The method computes the Hilbert series of the ideal in terms of elem.
• mySyzygy() -- Compute the first involutive syzygy and returns a FGModule.
• myDim() -- Computes the dimension of P/I.
• myCls(ppelem) -- Computes the class of ppelem which is of type PPMonoidElem. the class starts counting at 0 up to n - 1. The cls of 1 is -1. It returns a long.
• myMinCls() -- Computes the minimal class of all LPP's of the Janet basis as long.
• myMaxCls() -- Computes the maximal class of all LPP's of the Janet basis as long.
• myElementsWithClass(InputCls) -- Computes all elements of the Janet basis where the class of the LPP is InputCls. InputCls is a long and the method returns a vector<RingElem>.
• myComplementaryDecomposition() -- Computes the complementary decomposition of I. it returns vector<pair<PPMonoidElem, vector<bool> > >.
• myStandardPairs() -- Computes the standard pairs of I. it returns vector<pair<PPMonoidElem, vector<bool> > >.
• myJNormalForm(elem) -- Computes the involutive normal form of elem and returns a RingElem.
• myJDivisor(elem) -- Computes the involutive divisor of LPP(elem). If there is an involutive divisor it returns it as RingElem if not the method returns 0.

Examples

• ex-Janet1.C
• ex-Janet2.C

JanetDatastructure

JBSets

The most important algorithm to compute Janet basis is the TQ-Algorithm. There are two variants of it: the basic TQDegree strategy and the more advanced TQBlock strategy. The TQDegree strategy deals with a set T and Q. In short, through the computation the algorithm moves elements mainly from Q to T and vica versa. To deal efficiently with it we introduced the class TQSets. It consists of the sets T (mySetT) and Q (mySetQ) which are ordered. Both are represented as std::multiset. They contain JanetTriple and ordered by the LPP's of them (Because these LPP's are not unique during the computation we choosing std::multiset). The JanetTriple's are not contained directly in the set T and Q itself, as it is very expensive to move them from one set to the other. Therefore there is a third set (myBasicSet) which is implemented as list of JanetTriple's which contains the JanetTriple's itself. The sets T and Q only contain an iterator to a specific position of these sets.

For applying the BlockTQ algorithm we need a third set P (mySetP) which is implemented like T and Q. Due to the similarity we introduced a subclass of TQSets which is called TQPSets. In addition to the new set P it introduces a strategy flag which influences the way how we move elements from Q to P.

In addition to the above mentioned sets TQSets consists of a SparsePolyRing, a ReductionCog and a bitset<3> (myCriteria). myCriteria regulates which involutive criteria shall be applied during the computation. Every bit stands for one single involutive criteria.

JBAlgorithm

JBMill