RegularTriangularSet(R, E, V, P)ΒΆ

regset.spad line 1358

This domain provides an implementation of regular chains. Moreover, the operation zeroSetSplit is an implementation of a new algorithm for solving polynomial systems by means of regular chains.

=: (%, %) -> 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)
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, %) -> 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)
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
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: (List P, %) -> %
from RegularTriangularSetCategory(R, E, V, P)
internalAugment: (P, %) -> %
from RegularTriangularSetCategory(R, E, V, P)
internalAugment: (P, %, Boolean, Boolean, Boolean, Boolean, Boolean) -> List %
internalAugment(p, ts, b1, b2, b3, b4, b5) is an internal subroutine, exported only for developement.
internalZeroSetSplit: (List P, Boolean, Boolean, Boolean) -> List %
internalZeroSetSplit(lp, b1, b2, b3) is an internal subroutine, exported only for developement.
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
member?: (P, %) -> Boolean
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)
pre_process: (List P, Boolean, Boolean) -> Record(val: List P, towers: List %)
pre_process(lp, b1, b2) is an internal subroutine, exported only for developement.
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, 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, %) -> %
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)
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, Boolean, Boolean) -> List %
zeroSetSplit(lp, clos?, info?) has the same specifications as zeroSetSplit. Moreover, if clos? then solves in the sense of the Zariski closure else solves in the sense of the regular zeros. If info? then do print messages during the computations.
zeroSetSplit: (List P, Boolean, Boolean, Boolean, Boolean) -> List %
zeroSetSplit(lp, b1, b2.b3, b4) is an internal subroutine, exported only for developement.
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)

RegularTriangularSetCategory(R, E, V, P)

RetractableFrom List P

SetCategory

shallowlyMutable

TriangularSetCategory(R, E, V, P)