SquareFreeRegularTriangularSetCategory(R, E, V, P)¶

The category of square-free regular triangular sets. A regular triangular set ts is square-free if the gcd of any polynomial p in ts and differentiate(p, mvar(p)) w.r.t. collectUnder <l–triangular-set-category_collect-under>(ts, mvar <l–recursive-polynomial-category_mvar>(p)) has degree zero w.r.t. mvar(p). Thus any square-free regular set defines a tower of square-free simple extensions.

#: % -> NonNegativeInteger
from Aggregate
=: (%, %) -> Boolean
from BasicType
~=: (%, %) -> 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?: (P -> Boolean, %) -> Boolean
from HomogeneousAggregate P
augment: (List P, %) -> List %
from RegularTriangularSetCategory(R, E, V, P)
augment: (List P, List %) -> List %
from RegularTriangularSetCategory(R, E, V, P)
augment: (P, %) -> List %
from RegularTriangularSetCategory(R, E, V, P)
augment: (P, List %) -> List %
from RegularTriangularSetCategory(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)
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: () -> %
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)
every?: (P -> Boolean, %) -> Boolean
from HomogeneousAggregate P
extend: (%, P) -> %
from TriangularSetCategory(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)
extend: (P, %) -> List %
from RegularTriangularSetCategory(R, E, V, P)
extend: (P, List %) -> List %
from RegularTriangularSetCategory(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
from TriangularSetCategory(R, E, V, P)
from TriangularSetCategory(R, E, V, P)
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: (List P, %) -> %
from RegularTriangularSetCategory(R, E, V, P)
internalAugment: (P, %) -> %
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)
intersect: (P, %) -> List %
from RegularTriangularSetCategory(R, E, V, P)
intersect: (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!: (P -> P, %) -> %
from HomogeneousAggregate P
map: (P -> P, %) -> %
from HomogeneousAggregate P
member?: (P, %) -> Boolean
from HomogeneousAggregate P
members: % -> List P
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)
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, 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)
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, Boolean) -> List %
from RegularTriangularSetCategory(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

Evalable P if P has Evalable P

finiteAggregate

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, V, P)

RegularTriangularSetCategory(R, E, V, P)

SetCategory

shallowlyMutable

TriangularSetCategory(R, E, V, P)