SquareFreeNormalizedTriangularSetCategory(R, E, V, P)

nsregset.spad line 1 [edit on github]

The category of square-free and normalized triangular sets. Thus, up to the primitivity axiom of [1], these sets are Lazard triangular 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)

BasicType

PolynomialSetCategory(R, E, V, P)

CoercibleTo(List(P))

InnerEvalable(P, P)

Evalable(P)

TriangularSetCategory(R, E, V, P)

SetCategory

CoercibleTo(OutputForm)

SquareFreeRegularTriangularSetCategory(R, E, V, P)

finiteAggregate

shallowlyMutable

NormalizedTriangularSetCategory(R, E, V, P)

RetractableFrom(List(P))