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

regset.spad line 1 [edit on github]

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?: % -> Boolean

from Aggregate

empty: () -> %

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

max: % -> P if P has OrderedSet

from HomogeneousAggregate P

max: ((P, P) -> Boolean, %) -> P

from HomogeneousAggregate P

member?: (P, %) -> Boolean

from HomogeneousAggregate P

members: % -> List P

from HomogeneousAggregate P

min: % -> P if P has OrderedSet

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(ts, v) and ts_v_- is collectUnder(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)