# TriangularSetCategory(R, E, V, P)¶

The category of triangular sets of multivariate polynomials with coefficients in an integral domain. Let `R` be an integral domain and `V` a finite ordered set of variables, say `X1 < X2 < ... < Xn`. A set `S` of polynomials in `R[X1, X2, ..., Xn]` is triangular if no elements of `S` lies in `R`, and if two distinct elements of `S` have distinct main variables. Note that the empty set is a triangular set. A triangular set is not necessarily a (lexicographical) Groebner basis and the notion of reduction related to triangular sets is based on the recursive view of polynomials. We recall this notion here and refer to [1] for more details. A polynomial `P` is reduced `w`.`r`.`t` a non-constant polynomial `Q` if the degree of `P` in the main variable of `Q` is less than the main degree of `Q`. A polynomial `P` is reduced `w`.`r`.`t` a triangular set `T` if it is reduced `w`.`r`.`t`. every polynomial of `T`.

#: % -> NonNegativeInteger

from Aggregate

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

algebraic?: (V, %) -> Boolean

`algebraic?(v, ts)` returns `true` iff `v` is the main variable of some polynomial in `ts`.

algebraicVariables: % -> List V

`algebraicVariables(ts)` returns the decreasingly sorted list of the main variables of the polynomials of `ts`.

any?: (P -> Boolean, %) -> Boolean

from HomogeneousAggregate P

autoReduced?: (%, (P, List P) -> Boolean) -> Boolean

`autoReduced?(ts, redOp?)` returns `true` iff every element of `ts` is reduced `w`.`r`.`t` to every other in the sense of `redOp?`

basicSet: (List P, (P, P) -> Boolean) -> Union(Record(bas: %, top: List P), failed)

`basicSet(ps, redOp?)` returns `[bs, ts]` where `concat(bs, ts)` is `ps` and `bs` is a basic set in Wu Wen Tsun sense of `ps` `w`.`r`.`t` the reduction-test `redOp?`, if no non-zero constant polynomial lie in `ps`, otherwise `"failed"` is returned.

basicSet: (List P, P -> Boolean, (P, P) -> Boolean) -> Union(Record(bas: %, top: List P), failed)

`basicSet(ps, pred?, redOp?)` returns the same as `basicSet(qs, redOp?)` where `qs` consists of the polynomials of `ps` satisfying property `pred?`.

coerce: % -> List P

from CoercibleTo List P

coerce: % -> OutputForm
coHeight: % -> NonNegativeInteger if V has Finite

`coHeight(ts)` returns `size()\\$V` minus `\#ts`.

collect: (%, V) -> %

from PolynomialSetCategory(R, E, V, P)

collectQuasiMonic: % -> %

`collectQuasiMonic(ts)` returns the subset of `ts` consisting of the polynomials with initial in `R`.

collectUnder: (%, V) -> %

from PolynomialSetCategory(R, E, V, P)

collectUpper: (%, V) -> %

from PolynomialSetCategory(R, E, V, P)

construct: List P -> %

from Collection P

convert: % -> InputForm
copy: % -> %

from Aggregate

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

from HomogeneousAggregate P

count: (P, %) -> NonNegativeInteger

from HomogeneousAggregate P

degree: % -> NonNegativeInteger

`degree(ts)` returns the product of main degrees of the members of `ts`.

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

`extend(ts, p)` returns a triangular set which encodes the simple extension by `p` of the extension of the base field defined by `ts`, according to the properties of triangular sets of the current category If the required properties do not hold an error is returned.

extendIfCan: (%, P) -> Union(%, failed)

`extendIfCan(ts, p)` returns a triangular set which encodes the simple extension by `p` of the extension of the base field defined by `ts`, according to the properties of triangular sets of the current domain. If the required properties do not hold then “failed” is returned. This operation encodes in some sense the properties of the triangular sets of the current category. Is is used to implement the `construct` operation to guarantee that every triangular set build from a list of polynomials has the required properties.

find: (P -> Boolean, %) -> Union(P, failed)

from Collection P

first: % -> Union(P, failed)

`first(ts)` returns the polynomial of `ts` with greatest main variable if `ts` is not empty, otherwise returns `"failed"`.

`headReduce(p, ts)` returns a polynomial `r` such that `headReduce?(r, ts)` holds and there exists some product `h` of `initials(ts)` such that `h*p - r` lies in the ideal generated by `ts`.

`headReduced?(ts)` returns `true` iff the head of every element of `ts` is reduced `w`.`r`.`t` to any other element of `ts`.

`headReduced?(p, ts)` returns `true` iff the head of `p` is reduced `w`.`r`.`t`. `ts`.

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

`infRittWu?(ts1, ts2)` returns `true` iff `ts2` has higher rank than `ts1` in Wu Wen Tsun sense.

initiallyReduce: (P, %) -> P

`initiallyReduce(p, ts)` returns a polynomial `r` such that `initiallyReduced?(r, ts)` holds and there exists some product `h` of `initials(ts)` such that `h*p - r` lies in the ideal generated by `ts`.

initiallyReduced?: % -> Boolean

`initiallyReduced?(ts)` returns `true` iff for every element `p` of `ts` `p` and all its iterated initials are reduced `w`.`r`.`t`. to the other elements of `ts` with the same main variable.

initiallyReduced?: (P, %) -> Boolean

`initiallyReduced?(p, ts)` returns `true` iff `p` and all its iterated initials are reduced `w`.`r`.`t`. to the elements of `ts` with the same main variable.

initials: % -> List P

`initials(ts)` returns the list of the non-constant initials of the members of `ts`.

last: % -> Union(P, failed)

`last(ts)` returns the polynomial of `ts` with smallest main variable if `ts` is not empty, otherwise returns `"failed"`.

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

`normalized?(ts)` returns `true` iff for every `p` in `ts` we have `normalized?(p, us)` where `us` is `collectUnder(ts, mvar(p))`.

normalized?: (P, %) -> Boolean

`normalized?(p, ts)` returns `true` iff `p` and all its iterated initials have degree zero `w`.`r`.`t`. the main variables of the polynomials of `ts`

parts: % -> List P

from HomogeneousAggregate P

quasiComponent: % -> Record(close: List P, open: List P)

`quasiComponent(ts)` returns `[lp, lq]` where `lp` is the list of the members of `ts` and `lq`is `initials(ts)`.

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

`reduce(p, ts, redOp, redOp?)` returns a polynomial `r` such that `redOp?(r, p)` holds for every `p` of `ts` and there exists some product `h` of the initials of the members of `ts` such that `h*p - r` lies in the ideal generated by `ts`. The operation `redOp` must satisfy the following conditions. For every `p` and `q` we have `redOp?(redOp(p, q), q)` and there exists an integer `e` and a polynomial `f` such that `init(q)^e*p = f*q + redOp(p, q)`.

reduceByQuasiMonic: (P, %) -> P

`reduceByQuasiMonic(p, ts)` returns the same as `remainder(p, collectQuasiMonic(ts)).polnum`.

reduced?: (P, %, (P, P) -> Boolean) -> Boolean

`reduced?(p, ts, redOp?)` returns `true` iff `p` is reduced `w`.`r`.`t`. in the sense of the operation `redOp?`, that is if for every `t` in `ts` `redOp?(p, t)` holds.

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

`removeZero(p, ts)` returns `0` if `p` reduces to `0` by pseudo-division `w`.`r`.`t` `ts` otherwise returns a polynomial `q` computed from `p` by removing any coefficient in `p` reducing to `0`.

rest: % -> Union(%, failed)

`rest(ts)` returns the polynomials of `ts` with smaller main variable than `mvar(ts)` if `ts` is not empty, otherwise returns “failed”

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

`rewriteSetWithReduction(lp, ts, redOp, redOp?)` returns a list `lq` of polynomials such that `[reduce(p, ts, redOp, redOp?) for p in lp]` and `lp` have the same zeros inside the regular zero set of `ts`. Moreover, for every polynomial `q` in `lq` and every polynomial `t` in `ts` `redOp?(q, t)` holds and there exists a polynomial `p` in the ideal generated by `lp` and a product `h` of `initials(ts)` such that `h*p - r` lies in the ideal generated by `ts`. The operation `redOp` must satisfy the following conditions. For every `p` and `q` we have `redOp?(redOp(p, q), q)` and there exists an integer `e` and a polynomial `f` such that `init(q)^e*p = f*q + redOp(p, q)`.

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)

`select(ts, v)` returns the polynomial of `ts` with `v` as main variable, if any.

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

from Collection P

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

sort: (%, V) -> Record(under: %, floor: %, upper: %)

from PolynomialSetCategory(R, E, V, P)

stronglyReduce: (P, %) -> P

`stronglyReduce(p, ts)` returns a polynomial `r` such that `stronglyReduced?(r, ts)` holds and there exists some product `h` of `initials(ts)` such that `h*p - r` lies in the ideal generated by `ts`.

stronglyReduced?: % -> Boolean

`stronglyReduced?(ts)` returns `true` iff every element of `ts` is reduced `w`.`r`.`t` to any other element of `ts`.

stronglyReduced?: (P, %) -> Boolean

`stronglyReduced?(p, ts)` returns `true` iff `p` is reduced `w`.`r`.`t`. `ts`.

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 -> List %

`zeroSetSplit(lp)` returns a list `lts` of triangular sets such that the zero set of `lp` is the union of the closures of the regular zero sets of the members of `lts`.

zeroSetSplitIntoTriangularSystems: List P -> List Record(close: %, open: List P)

`zeroSetSplitIntoTriangularSystems(lp)` returns a list of triangular systems `[[ts1, qs1], ..., [tsn, qsn]]` such that the zero set of `lp` is the union of the closures of the `W_i` where `W_i` consists of the zeros of `ts` which do not cancel any polynomial in `qsi`.

Aggregate

BasicType

Evalable P if P has Evalable P

finiteAggregate

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, V, P)

SetCategory

shallowlyMutable