WuWenTsunTriangularSet(R, E, V, P)

triset.spad line 1391 [edit on github]

• 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 with respect to 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.

#: % -> NonNegativeInteger

from Aggregate

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

algebraic?: (V, %) -> Boolean

from TriangularSetCategory(R, E, V, P)

algebraicVariables: % -> List V

from TriangularSetCategory(R, E, V, P)

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

from HomogeneousAggregate 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 with respect to the reduction-test redOp? (using redOp to reduce polynomials with respect to 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 -> 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)

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)

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

map: (P -> P, %) -> %

from HomogeneousAggregate P

max: % -> P if P has OrderedSet

from HomogeneousAggregate P

max: ((P, P) -> Boolean, %) -> 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 with respect to 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

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

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)

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)

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)