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.