WuWenTsunTriangularSet(R, E, V, P)

triset.spad line 1382 [edit on github]

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.

# : % -> NonNegativeInteger
from Aggregate
= : (%, %) -> Boolean
from BasicType
algebraic? : (V, %) -> Boolean
from TriangularSetCategory(R, E, V, P)
algebraicVariables : % -> List(V)
from TriangularSetCategory(R, E, V, P)
any? : (Mapping(Boolean, P), %) -> Boolean
from HomogeneousAggregate(P)
autoReduced? : (%, Mapping(Boolean, P, List(P))) -> Boolean
from TriangularSetCategory(R, E, V, P)
basicSet : (List(P), Mapping(Boolean, P), Mapping(Boolean, P, P)) -> Union(Record(bas : %, top : List(P)), "failed")
from TriangularSetCategory(R, E, V, P)
basicSet : (List(P), Mapping(Boolean, P, P)) -> Union(Record(bas : %, top : List(P)), "failed")
from TriangularSetCategory(R, E, V, P)
characteristicSerie : List(P) -> List(%)

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

characteristicSerie : (List(P), Mapping(Boolean, P, P), Mapping(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.

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

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

characteristicSet : (List(P), Mapping(Boolean, P, P), Mapping(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).

coHeight : % -> NonNegativeInteger if V has Finite
from TriangularSetCategory(R, E, V, P)
coerce : % -> List(P)
from CoercibleTo(List(P))
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
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)
count : (Mapping(Boolean, 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 : (%, P, P) -> % if P has Evalable(P)
from InnerEvalable(P, P)
eval : (%, 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 : (%, List(Equation(P))) -> % if P has Evalable(P)
from Evalable(P)
every? : (Mapping(Boolean, P), %) -> Boolean
from HomogeneousAggregate(P)
extend : (%, P) -> %
from TriangularSetCategory(R, E, V, P)
extendIfCan : (%, P) -> Union(%, "failed")
from TriangularSetCategory(R, E, V, P)
find : (Mapping(Boolean, P), %) -> 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 : (Mapping(P, P), %) -> %
from HomogeneousAggregate(P)
map! : (Mapping(P, P), %) -> %
from HomogeneousAggregate(P)
max : % -> P if P has OrderedSet
from HomogeneousAggregate(P)
max : (Mapping(Boolean, P, P), %) -> P
from HomogeneousAggregate(P)
medialSet : List(P) -> Union(%, "failed")

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

medialSet : (List(P), Mapping(Boolean, P, P), Mapping(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.

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, %, Mapping(P, P, P), Mapping(Boolean, P, P)) -> P
from TriangularSetCategory(R, E, V, P)
reduce : (Mapping(P, P, P), %) -> P
from Collection(P)
reduce : (Mapping(P, P, P), %, P) -> P
from Collection(P)
reduce : (Mapping(P, P, P), %, P, P) -> P
from Collection(P)
reduceByQuasiMonic : (P, %) -> P
from TriangularSetCategory(R, E, V, P)
reduced? : (P, %, Mapping(Boolean, P, P)) -> 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)
remove : (Mapping(Boolean, 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), %, Mapping(P, P, P), Mapping(Boolean, P, P)) -> 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 : (Mapping(Boolean, P), %) -> %
from Collection(P)
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)
~= : (%, %) -> Boolean
from BasicType

ConvertibleTo(InputForm)

Collection(P)

Aggregate

RetractableFrom(List(P))

HomogeneousAggregate(P)

BasicType

PolynomialSetCategory(R, E, V, P)

CoercibleTo(List(P))

InnerEvalable(P, P)

Evalable(P)

SetCategory

CoercibleTo(OutputForm)

TriangularSetCategory(R, E, V, P)

finiteAggregate

shallowlyMutable