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

regset.spad line 1 [edit on github]

R: GcdDomain

V: OrderedSet

P: RecursivePolynomialCategory(R, E, V)

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

- 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

- count: (P -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate P

- count: (P, %) -> NonNegativeInteger
from HomogeneousAggregate P

- degree: % -> NonNegativeInteger
from TriangularSetCategory(R, E, V, P)

- 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)

- 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)`

- 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)

- 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)

Evalable P if P has Evalable P

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, V, P)

TriangularSetCategory(R, E, V, P)