NormalizedTriangularSetCategory(R, E, V, P)

nregset.spad line 1 [edit on github]

• R : GcdDomain
• E : OrderedAbelianMonoidSup
• V : OrderedSet
• P : RecursivePolynomialCategory(R, E, V)

The category of normalized triangular sets. A triangular set ts is said normalized if for every algebraic variable v of ts the polynomial select(ts, v) is normalized w.r.t. every polynomial in collectUnder(ts, v). A polynomial p is said normalized w.r.t. a non-constant polynomial q if p is constant or degree(p, mdeg(q)) = 0 and init(p) is normalized w.r.t. q. One of the important features of normalized triangular sets is that they are regular sets.

# : % -> NonNegativeInteger

from Aggregate

= : (%, %) -> Boolean

from BasicType

algebraic? : (V, %) -> Boolean

from TriangularSetCategory(R, E, V, P)

algebraicCoefficients? : (P, %) -> Boolean

from RegularTriangularSetCategory(R, E, V, P)

algebraicVariables : % -> List(V)

from TriangularSetCategory(R, E, V, P)

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

from HomogeneousAggregate(P)

augment : (P, %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

augment : (P, List(%)) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

augment : (List(P), %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

augment : (List(P), List(%)) -> List(%)

from RegularTriangularSetCategory(R, E, V, 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)

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)

extend : (P, %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

extend : (P, List(%)) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

extend : (List(P), %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

extend : (List(P), List(%)) -> List(%)

from RegularTriangularSetCategory(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)

internalAugment : (P, %) -> %

from RegularTriangularSetCategory(R, E, V, P)

internalAugment : (List(P), %) -> %

from RegularTriangularSetCategory(R, E, V, P)

intersect : (P, %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

intersect : (P, List(%)) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

intersect : (List(P), %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

intersect : (List(P), List(%)) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

invertible? : (P, %) -> Boolean

from RegularTriangularSetCategory(R, E, V, P)

invertible? : (P, %) -> List(Record(val : Boolean, tower : %))

from RegularTriangularSetCategory(R, E, V, P)

invertibleElseSplit? : (P, %) -> Union(Boolean, List(%))

from RegularTriangularSetCategory(R, E, V, P)

invertibleSet : (P, %) -> List(%)

from RegularTriangularSetCategory(R, E, V, P)

last : % -> Union(P, "failed")

from TriangularSetCategory(R, E, V, P)

lastSubResultant : (P, P, %) -> List(Record(val : P, tower : %))

from RegularTriangularSetCategory(R, E, V, P)

lastSubResultantElseSplit : (P, P, %) -> Union(P, List(%))

from RegularTriangularSetCategory(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)

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

from RegularTriangularSetCategory(R, E, V, P)

purelyAlgebraic? : (P, %) -> Boolean

from RegularTriangularSetCategory(R, E, V, P)

purelyAlgebraicLeadingMonomial? : (P, %) -> Boolean

from RegularTriangularSetCategory(R, E, V, P)

purelyTranscendental? : (P, %) -> Boolean

from RegularTriangularSetCategory(R, E, V, 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)

squareFreePart : (P, %) -> List(Record(val : P, tower : %))

from RegularTriangularSetCategory(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)

zeroSetSplit : (List(P), Boolean) -> List(%)

from RegularTriangularSetCategory(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

RegularTriangularSetCategory(R, E, V, P)

HomogeneousAggregate(P)

SetCategory

PolynomialSetCategory(R, E, V, P)

CoercibleTo(List(P))

InnerEvalable(P, P)

Evalable(P)

RetractableFrom(List(P))

CoercibleTo(OutputForm)

TriangularSetCategory(R, E, V, P)

finiteAggregate

shallowlyMutable

BasicType