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

- R: IntegralDomain
- E: OrderedAbelianMonoidSup
- V: OrderedSet
- P: RecursivePolynomialCategory(R, E, V)

A domain constructor of the category GeneralTriangularSet. The only requirement for a list of polynomials to be a member of such a domain is the following: no polynomial is constant and two distinct polynomials have distinct main variables. Such a triangular set may not be auto-reduced or consistent. The construct operation does not check the previous requirement. Triangular sets are stored as sorted lists `w`

.`r`

.`t`

. the main variables of their members. Furthermore, this domain exports operations dealing with the characteristic set method of Wu Wen Tsun and some optimizations mainly proposed by Dong Ming Wang.

- =: (%, %) -> Boolean
- from BasicType
- ~=: (%, %) -> Boolean
- from BasicType
- algebraic?: (V, %) -> Boolean
- from TriangularSetCategory(R, E, V, P)
- algebraicVariables: % -> List V
- from TriangularSetCategory(R, E, V, P)
- 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)

- characteristicSerie: (List P, (P, P) -> Boolean, (P, P) -> P) -> List %
`characteristicSerie(ps, redOp?, redOp)`

returns a list`lts`

of triangular sets such that the zero set of`ps`

is the union of the regular zero sets of the members of`lts`

. This is made by the Ritt and Wu Wen Tsun process applying the operation`characteristicSet(ps, redOp?, redOp)`

to compute characteristic sets in Wu Wen Tsun sense.

- characteristicSerie: List P -> List %
`characteristicSerie(ps)`

returns the same as`characteristicSerie(ps, initiallyReduced?, initiallyReduce)`

.

- characteristicSet: (List P, (P, P) -> Boolean, (P, P) -> P) -> Union(%, failed)
`characteristicSet(ps, redOp?, redOp)`

returns a non-contradictory characteristic set of`ps`

in Wu Wen Tsun sense`w`

.`r`

.`t`

the reduction-test`redOp?`

(using`redOp`

to reduce polynomials`w`

.`r`

.`t`

a`redOp?`

basic set), if no non-zero constant polynomial appear during those reductions, else`"failed"`

is returned. The operations`redOp`

and`redOp?`

must satisfy the following conditions:`redOp?(redOp(p, q), q)`

holds for every polynomials`p, q`

and there exists an integer`e`

and a polynomial`f`

such that we have`init(q)^e*p = f*q + redOp(p, q)`

.

- characteristicSet: List P -> Union(%, failed)
`characteristicSet(ps)`

returns the same as`characteristicSet(ps, initiallyReduced?, initiallyReduce)`

.- 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, %) -> 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)
- extend: (%, P) -> %
- from TriangularSetCategory(R, E, V, P)
- 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)
- last: % -> Union(P, failed)
- from TriangularSetCategory(R, E, V, P)
- 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

- medialSet: (List P, (P, P) -> Boolean, (P, P) -> P) -> Union(%, failed)
`medialSet(ps, redOp?, redOp)`

returns`bs`

a basic set (in Wu Wen Tsun sense`w`

.`r`

.`t`

the reduction-test`redOp?`

) of some set generating the same ideal as`ps`

(with rank not higher than any basic set of`ps`

), if no non-zero constant polynomials appear during the computations, else`"failed"`

is returned. In the former case,`bs`

has to be understood as a candidate for being a characteristic set of`ps`

. In the original algorithm,`bs`

is simply a basic set of`ps`

.

- medialSet: List P -> Union(%, failed)
`medial(ps)`

returns the same as`medialSet(ps, initiallyReduced?, initiallyReduce)`

.- member?: (P, %) -> Boolean
- 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)
- quasiComponent: % -> Record(close: List P, open: List P)
- from TriangularSetCategory(R, E, V, 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, %) -> %
- 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)
- size?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- sort: (%, V) -> Record(under: %, floor: %, upper: %)
- from PolynomialSetCategory(R, E, V, P)
- 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 -> 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)