RegularTriangularSetCategory(R, E, V, P)ΒΆ

regset.spad line 1

The category of regular triangular sets, introduced under the name regular chains in [1] (and other papers). In [3] it is proved that regular triangular sets and towers of simple extensions of a field are equivalent notions. In the following definitions, all polynomials and ideals are taken from the polynomial ring k[x1, ..., xn] where k is the fraction field of R. The triangular set [t1, ..., tm] is regular iff for every i the initial of ti+1 is invertible in the tower of simple extensions associated with [t1, ..., ti]. A family [T1, ..., Ts] of regular triangular sets is a split of Kalkbrener of a given ideal I iff the radical of I is equal to the intersection of the radical ideals generated by the saturated ideals of the [T1, ..., Ti]. A family [T1, ..., Ts] of regular triangular sets is a split of Kalkbrener of a given triangular set T iff it is a split of Kalkbrener of the saturated ideal of T. Let K be an algebraic closure of k. Assume that V is finite with cardinality n and let A be the affine space K^n. For a regular triangular set T let denote by W(T) the set of regular zeros of T. A family [T1, ..., Ts] of regular triangular sets is a split of Lazard of a given subset S of A iff the union of the W(Ti) contains S and is contained in the closure of S (w.r.t. Zariski topology). A family [T1, ..., Ts] of regular triangular sets is a split of Lazard of a given triangular set T if it is a split of Lazard of W(T). Note that if [T1, ..., Ts] is a split of Lazard of T then it is also a split of Kalkbrener of T. The converse is false. This category provides operations related to both kinds of splits, the former being related to ideals decomposition whereas the latter deals with varieties decomposition. See the example illustrating the RegularTriangularSet constructor for more explanations about decompositions by means of regular triangular sets.

#: % -> NonNegativeInteger
from Aggregate
=: (%, %) -> Boolean
from BasicType
~=: (%, %) -> Boolean
from BasicType
algebraic?: (V, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
algebraicCoefficients?: (P, %) -> Boolean
algebraicCoefficients?(p, ts) returns true iff every variable of p which is not the main one of p is algebraic w.r.t. ts.
algebraicVariables: % -> List V
from TriangularSetCategory(R, E, V, P)
any?: (P -> Boolean, %) -> Boolean
from HomogeneousAggregate P
augment: (List P, %) -> List %
augment(lp, ts) returns ts if empty? lp, augment(p, ts) if lp = [p], otherwise augment(first lp, augment(rest lp, ts))
augment: (List P, List %) -> List %
augment(lp, lts) returns the same as concat([augment(lp, ts) for ts in lts])
augment: (P, %) -> List %
augment(p, ts) assumes that p is a non-constant polynomial whose main variable is greater than any variable of ts. This operation assumes also that if p is added to ts the resulting set, say ts+p, is a regular triangular set. Then it returns a split of Kalkbrener of ts+p. This may not be ts+p itself, if for instance ts+p is required to be square-free.
augment: (P, List %) -> List %
augment(p, lts) returns the same as concat([augment(p, ts) for ts in lts])
autoReduced?: (%, (P, List P) -> Boolean) -> Boolean
from TriangularSetCategory(R, E, V, P)
basicSet: (List P, (P, P) -> Boolean) -> Union(Record(bas: %, top: List P), failed)
from TriangularSetCategory(R, E, V, P)
basicSet: (List P, P -> Boolean, (P, P) -> Boolean) -> Union(Record(bas: %, top: List P), failed)
from TriangularSetCategory(R, E, V, P)
coerce: % -> List P
from CoercibleTo List P
coerce: % -> OutputForm
from CoercibleTo OutputForm
coHeight: % -> NonNegativeInteger if V has Finite
from TriangularSetCategory(R, E, V, P)
collect: (%, V) -> %
from PolynomialSetCategory(R, E, V, P)
collectQuasiMonic: % -> %
from TriangularSetCategory(R, E, V, P)
collectUnder: (%, V) -> %
from PolynomialSetCategory(R, E, V, P)
collectUpper: (%, V) -> %
from PolynomialSetCategory(R, E, V, P)
construct: List P -> %
from Collection P
convert: % -> InputForm
from ConvertibleTo InputForm
copy: % -> %
from Aggregate
count: (P -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate P
count: (P, %) -> NonNegativeInteger
from HomogeneousAggregate P
degree: % -> NonNegativeInteger
from TriangularSetCategory(R, E, V, P)
empty: () -> %
from Aggregate
empty?: % -> Boolean
from Aggregate
eq?: (%, %) -> Boolean
from Aggregate
eval: (%, Equation P) -> % if P has Evalable P
from Evalable P
eval: (%, List Equation P) -> % if P has Evalable P
from Evalable P
eval: (%, List P, List P) -> % if P has Evalable P
from InnerEvalable(P, P)
eval: (%, P, P) -> % if P has Evalable P
from InnerEvalable(P, P)
every?: (P -> Boolean, %) -> Boolean
from HomogeneousAggregate P
extend: (%, P) -> %
from TriangularSetCategory(R, E, V, P)
extend: (List P, %) -> List %
extend(lp, ts) returns ts if empty? lp extend(p, ts) if lp = [p] else extend(first lp, extend(rest lp, ts))
extend: (List P, List %) -> List %
extend(lp, lts) returns the same as concat([extend(lp, ts) for ts in lts])|
extend: (P, %) -> List %
extend(p, ts) assumes that p is a non-constant polynomial whose main variable is greater than any variable of ts. Then it returns a split of Kalkbrener of ts+p. This may not be ts+p itself, if for instance ts+p is not a regular triangular set.
extend: (P, List %) -> List %
extend(p, lts) returns the same as concat([extend(p, ts) for ts in lts])|
extendIfCan: (%, P) -> Union(%, failed)
from TriangularSetCategory(R, E, V, P)
find: (P -> Boolean, %) -> Union(P, failed)
from Collection P
first: % -> Union(P, failed)
from TriangularSetCategory(R, E, V, P)
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
headReduce: (P, %) -> P
from TriangularSetCategory(R, E, V, P)
headReduced?: % -> Boolean
from TriangularSetCategory(R, E, V, P)
headReduced?: (P, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
headRemainder: (P, %) -> Record(num: P, den: R)
from PolynomialSetCategory(R, E, V, P)
iexactQuo: (R, R) -> R
from PolynomialSetCategory(R, E, V, P)
infRittWu?: (%, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
initiallyReduce: (P, %) -> P
from TriangularSetCategory(R, E, V, P)
initiallyReduced?: % -> Boolean
from TriangularSetCategory(R, E, V, P)
initiallyReduced?: (P, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
initials: % -> List P
from TriangularSetCategory(R, E, V, P)
internalAugment: (List P, %) -> %
internalAugment(lp, ts) returns ts if lp is empty otherwise returns internalAugment(rest lp, internalAugment(first lp, ts))
internalAugment: (P, %) -> %
internalAugment(p, ts) assumes that augment(p, ts) returns a singleton and returns it.
intersect: (List P, %) -> List %
intersect(lp, ts) returns lts a split of Lazard of the intersection of the affine variety associated with lp and the regular zero set of ts.
intersect: (List P, List %) -> List %
intersect(lp, lts) returns the same as concat([intersect(lp, ts) for ts in lts])|
intersect: (P, %) -> List %
intersect(p, ts) returns the same as intersect([p], ts)
intersect: (P, List %) -> List %
intersect(p, lts) returns the same as intersect([p], lts)
invertible?: (P, %) -> Boolean
invertible?(p, ts) returns true iff p is invertible in the tower associated with ts.
invertible?: (P, %) -> List Record(val: Boolean, tower: %)
invertible?(p, ts) returns lbwt where lbwt.i is the result of invertibleElseSplit?(p, lbwt.i.tower) and the list of the (lqrwt.i).tower is a split of Kalkbrener of ts.
invertibleElseSplit?: (P, %) -> Union(Boolean, List %)
invertibleElseSplit?(p, ts) returns true (resp. false) if p is invertible in the tower associated with ts or returns a split of Kalkbrener of ts.
invertibleSet: (P, %) -> List %
invertibleSet(p, ts) returns a split of Kalkbrener of the quotient ideal of the ideal I by p where I is the radical of saturated of ts.
last: % -> Union(P, failed)
from TriangularSetCategory(R, E, V, P)
lastSubResultant: (P, P, %) -> List Record(val: P, tower: %)
lastSubResultant(p1, p2, ts) returns lpwt such that lpwt.i.val is a quasi-monic gcd of p1 and p2 w.r.t. lpwt.i.tower, for every i, and such that the list of the lpwt.i.tower is a split of Kalkbrener of ts. Moreover, if p1 and p2 do not have a non-trivial gcd w.r.t. lpwt.i.tower then lpwt.i.val is the resultant of these polynomials w.r.t. lpwt.i.tower. This assumes that p1 and p2 have the same maim variable and that this variable is greater that any variable occurring in ts.
lastSubResultantElseSplit: (P, P, %) -> Union(P, List %)
lastSubResultantElseSplit(p1, p2, ts) returns either g a quasi-monic gcd of p1 and p2 w.r.t. the ts or a split of Kalkbrener of ts. This assumes that p1 and p2 have the same maim variable and that this variable is greater that any variable occurring in ts.
latex: % -> String
from SetCategory
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
mainVariable?: (V, %) -> Boolean
from PolynomialSetCategory(R, E, V, P)
mainVariables: % -> List V
from PolynomialSetCategory(R, E, V, P)
map!: (P -> P, %) -> %
from HomogeneousAggregate P
map: (P -> P, %) -> %
from HomogeneousAggregate P
member?: (P, %) -> Boolean
from HomogeneousAggregate P
members: % -> List P
from HomogeneousAggregate P
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
mvar: % -> V
from PolynomialSetCategory(R, E, V, P)
normalized?: % -> Boolean
from TriangularSetCategory(R, E, V, P)
normalized?: (P, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
parts: % -> List P
from HomogeneousAggregate P
purelyAlgebraic?: % -> Boolean
purelyAlgebraic?(ts) returns true iff for every algebraic variable v of ts we have algebraicCoefficients?(t_v, ts_v_-) where ts_v is select <l–triangular-set-category_select>`(``ts`, v) and ts_v_- is collectUnder <l–triangular-set-category_collect-under>`(``ts`, v).
purelyAlgebraic?: (P, %) -> Boolean
purelyAlgebraic?(p, ts) returns true iff every variable of p is algebraic w.r.t. ts.
purelyAlgebraicLeadingMonomial?: (P, %) -> Boolean
purelyAlgebraicLeadingMonomial?(p, ts) returns true iff the main variable of any non-constant iterarted initial of p is algebraic w.r.t. ts.
purelyTranscendental?: (P, %) -> Boolean
purelyTranscendental?(p, ts) returns true iff every variable of p is not algebraic w.r.t. ts
quasiComponent: % -> Record(close: List P, open: List P)
from TriangularSetCategory(R, E, V, P)
reduce: ((P, P) -> P, %) -> P
from Collection P
reduce: ((P, P) -> P, %, P) -> P
from Collection P
reduce: ((P, P) -> P, %, P, P) -> P
from Collection P
reduce: (P, %, (P, P) -> P, (P, P) -> Boolean) -> P
from TriangularSetCategory(R, E, V, P)
reduceByQuasiMonic: (P, %) -> P
from TriangularSetCategory(R, E, V, P)
reduced?: (P, %, (P, P) -> Boolean) -> Boolean
from TriangularSetCategory(R, E, V, P)
remainder: (P, %) -> Record(rnum: R, polnum: P, den: R)
from PolynomialSetCategory(R, E, V, P)
remove: (P -> Boolean, %) -> %
from Collection P
remove: (P, %) -> %
from Collection P
removeDuplicates: % -> %
from Collection P
removeZero: (P, %) -> P
from TriangularSetCategory(R, E, V, P)
rest: % -> Union(%, failed)
from TriangularSetCategory(R, E, V, P)
retract: List P -> %
from RetractableFrom List P
retractIfCan: List P -> Union(%, failed)
from RetractableFrom List P
rewriteIdealWithHeadRemainder: (List P, %) -> List P
from PolynomialSetCategory(R, E, V, P)
rewriteIdealWithRemainder: (List P, %) -> List P
from PolynomialSetCategory(R, E, V, P)
rewriteSetWithReduction: (List P, %, (P, P) -> P, (P, P) -> Boolean) -> List P
from TriangularSetCategory(R, E, V, P)
roughBase?: % -> Boolean
from PolynomialSetCategory(R, E, V, P)
roughEqualIdeals?: (%, %) -> Boolean
from PolynomialSetCategory(R, E, V, P)
roughSubIdeal?: (%, %) -> Boolean
from PolynomialSetCategory(R, E, V, P)
roughUnitIdeal?: % -> Boolean
from PolynomialSetCategory(R, E, V, P)
sample: %
from Aggregate
select: (%, V) -> Union(P, failed)
from TriangularSetCategory(R, E, V, P)
select: (P -> Boolean, %) -> %
from Collection P
size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
sort: (%, V) -> Record(under: %, floor: %, upper: %)
from PolynomialSetCategory(R, E, V, P)
squareFreePart: (P, %) -> List Record(val: P, tower: %)
squareFreePart(p, ts) returns lpwt such that lpwt.i.val is a square-free polynomial w.r.t. lpwt.i.tower, this polynomial being associated with p modulo lpwt.i.tower, for every i. Moreover, the list of the lpwt.i.tower is a split of Kalkbrener of ts. WARNING: This assumes that p is a non-constant polynomial such that if p is added to ts, then the resulting set is a regular triangular set.
stronglyReduce: (P, %) -> P
from TriangularSetCategory(R, E, V, P)
stronglyReduced?: % -> Boolean
from TriangularSetCategory(R, E, V, P)
stronglyReduced?: (P, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
triangular?: % -> Boolean
from PolynomialSetCategory(R, E, V, P)
trivialIdeal?: % -> Boolean
from PolynomialSetCategory(R, E, V, P)
variables: % -> List V
from PolynomialSetCategory(R, E, V, P)
zeroSetSplit: (List P, Boolean) -> List %
zeroSetSplit(lp, clos?) returns lts a split of Kalkbrener of the radical ideal associated with lp. If clos? is false, it is also a decomposition of the variety associated with lp into the regular zero set of the ts in lts (or, in other words, a split of Lazard of this variety). See the example illustrating the RegularTriangularSet constructor for more explanations about decompositions by means of regular triangular sets.
zeroSetSplit: List P -> List %
from TriangularSetCategory(R, E, V, P)
zeroSetSplitIntoTriangularSystems: List P -> List Record(close: %, open: List P)
from TriangularSetCategory(R, E, V, P)

Aggregate

BasicType

CoercibleTo List P

CoercibleTo OutputForm

Collection P

ConvertibleTo InputForm

Evalable P if P has Evalable P

finiteAggregate

HomogeneousAggregate P

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, V, P)

RetractableFrom List P

SetCategory

shallowlyMutable

TriangularSetCategory(R, E, V, P)