PBMill.H, StabilityAlgorithm.H introduce several classes for computing and working with Pommaret Basis.
The normal user should only use the classes Involutive::PBMill and Involutive::PBMill::Builder to interact with Pommaret bases.
To compute a Pommaret basis the user should use subclasses of Involutive::PBMill::Builder.
The user can choose between four subclasses:
Converter -- It takes a Janet basis and casts it to a Pommaret basis. This builder object does not perform a coordinate transformation.
DeltaRegularTransformator -- It takes a generating set and transforms it to a delta-regular Pommaret basis via coordinate transformations.
StableLTITransformator -- It takes a generating set and transforms it to a Pommaret basis via coordinate transformations, such that the leading ideal is stable.
StronglyStableLTITransformator -- It takes a generating set and transforms it to a Pommaret basis via coordinate transformations, such that the leading ideal is strongly stable.
==== Using Involutive::PBMill::Converter ====
To construct a Involutive::PBMill::Converter object the user has to use the standard constructor.
The only configuration method is setJBMill(mill) where mill is a JBMill.
It sets the JBMill which should be transformed to a PBMill.
If builder is a configured Converter object the user can construct a new PBMill with PBMill(builder).
==== Using Involutive::PBMill::DeltaRegularTransformator ====
To construct a Involutive::PBMill::DeltaRegularTransformator 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.
setJanetStrategy(strat) -- strat must be a Involutive::StrategyFlag. Possible enums are TQDegree, TQBlockHigh, TQBlockLow (default) or GBCompletion. During the computation we compute Janet bases. This Flag controls which algorithm should be used to compute these Janet bases.
setStrategy(strat) -- strat must be a Involutive::DeltaRegularTransformator::StrategyFlag. Possible enums are SingleWithPermutation, SingleWithoutPermutation, AllWithPermutation and AllWithoutPermutation. It defines the algorithm which should be used to compute delta-regular coordinates. If this method is not called the Builder object uses the SingleWithoutPermutation strategy.
If builder is a configured DeltaRegularTransformator object the user can construct a new PBMill with PBMill(builder).
The computation of delta-regular coordinates will be done during the construction of PBMill.
==== Using Involutive::PBMill::StableLTITransformator and Involutive::PBMill::StronglyStableLTITransformator====
The construction and usage of StableLTITransformator and StronglyStableLTITransformator is nearly the same than for the DeltaRegularTransformator. The only difference is the method setStrategy(strat). There are only two possible enums of type StableLTITransformator (or StronglyStableLTITransformator): Single (default) or All.
The methods are chainable, e.g. the user can do the following: builder.setInput(input).setStrategy(Single). If the user calls a method more than one time only the input of the last method call is taken into account.
=== Using the PBMill ===
In addition to the methods of the baseclass JBMill the class PBMill defines the following methods. Let I be the ideal generated by the Pommaret basis:
myReturnPB() -- returns the minimal Pommaret basis as vector<RingElem>
myDepth() -- returns the depth of I as long.
myProjDim() -- returns the projective dimension of I as long.
mySocle() -- returns the socle of I as vector<RingElem>.
myExtremalBettiNumbers() -- returns the extremal betti numbers of I as map<pair<long, long>, long>.
myMaxStronglyIndependentSet() -- returns the unique maximal strongly independent set of P/I as vector<RingElem>.
IamCohenMacaulay() -- tests if I is Cohen-Macaulay. Returns a bool.
myRegularity() -- returns the regularity of I as long.
mySatiety() -- returns the satiety of I as long.
mySaturation() -- returns the saturation of I as vector<RingElem>.
The Pommaret basis is always a Janet basis, too. Therefore the datastructures for represententing a Pommaret basis are the same than for the Janet bases. Everything of the following lives in the namespace CoCoA::Involutive.
This file defines all necessary things for dealing with Pommaret bases.
This class has as base class JBMill. It does not introduce new data members, because the representation of a Pommaret basis is the same than for a Janet basis. The main differnce between these to classes is that PBMill only accept generating sets in delta-regular coordinates. In addition to that it implements some methods which are only appliccable when we have a Pommaret basis.
This class is designed to construct a Pommaret basis.
The goal of this class is to separate the construction of the PBMill from its representation.
The 'Gang of Four' (Gamma, Helm, Johnson, Vlissides - Design Patterns) served
as template for the construction.
The corresponding pattern is called Building Pattern.
This class is purley virtual. The real implementation is in the subclasses.
To construct a PBMill out of the builder object the user can call a constructor of PBMill with a configured builder object.
This class is a subclass of PBMill::Builder. It trys convert a JBMill direclty to a PBMill, without changing coordinates.
This class is a subclass of PBMill::Builder. It is again a purley virtual class. It acts as base class for all Builder-classes which applying coordinate transformations to get a specific stability position.
This class is a subclass of PBMill::Transformator. It transforms a Janet basis to a Pommaret basis with delta-regular coordinates. The user can choose between four different strategies which are definied in the enum PBMill::DeltaRegularTransformator::StrategyFlag.
This class is a subclass of PBMill::Transformator. It transforms a Janet basis to a Pommaret basis with stable leading ideal. The user can choose between two different strategies which are definied in the enum PBMill::StableLTITransformator::StrategyFlag.
This class is a subclass of PBMill::Transformator. It transforms a Janet basis to a Pommaret basis with strongly stable leading ideal. The user can choose between two different strategies which are definied in the enum PBMill::StronglyStableLTITransformator::StrategyFlag.
This class provides an interface for computing different stability positions. It defines a method to compute a Janet basis (which is in our case always a Pommaret basis as well)for a given input, and a method to get a JanetContainer which should contain the computed Janet basis. Also it contains as basic data the polynomial ring and the PPMonoid. Every class which computes a stability position has to be a subclass of this class.
This class is a subclass of StabilityAlgorithm. It should transform the given ideal into delta-regular coordinates. The algorithm to compute delta-regular coordinates is quite simple. It checks if the given input is delta-regular. If not it changes the coordinates (only changes from x_i to x_i+x_j) and checks it again, until it reaches delta-regular coordinates. In addition to that it there is an enum DeltaRegular::UsagePermutations, where the user can decide whether we also use variable permutations as transformation. The computation of transformations like x_i -> x_i + x_j is implemented in the method DoComputeImage which is virtual.
This class is a subclass of DeltaRegular. The implementation is almost the same than DeltaRegular. The only difference is the method DoComputeImage. This class also computes transformation like x_i -> x_i + x_j_1 + ... + x_j_s.
This class is a subclass of StabilityAlgorithm. It should transform the given ideal into coordinates, such that the leading ideal is stable. The algorithm to compute this coordinates is quite simple. It checks if the given input are in the correct position. If not it changes the coordinates (only changes from x_i to x_i+x_j) and checks it again, until it reaches suitable coordinates. The computation of transformations like x_i -> x_i + x_j is implemented in the method DoComputeImage which is virtual. In addition to that the check if the position is correct is again a virtual method.
This class is a subclass of StableLTI. The implementation is almost the same than StableLTI. The only difference is the method DoComputeImage. This class also computes transformation like x_i -> x_i + x_j_1 + ... + x_j_s.
This class is a subclass of StableLTI. It should transform the given ideal into coordinates, such that the leading ideal is strongly stable.
The implementation is almost the same than StableLTI. The only difference is the check of coordinates. It replaces the check of stability by a check of strong stability.
This class is a subclass of StronglyStableLTI. The implementation is almost the same than StronglyStableLTI. The only difference is the method DoComputeImage. This class also computes transformation like x_i -> x_i + x_j_1 + ... + x_j_s.
If we could make StableLTI to a subclass of DeltaRegular it would be quite nice, because this would represent the mathematical hierachy as well.