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

sregset.spad line 1135 [edit on github]

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

#: % -> 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?: % -> Boolean

from Aggregate

empty: () -> %

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)

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

map: (P -> P, %) -> %

from HomogeneousAggregate P

max: % -> P if P has OrderedSet

from HomogeneousAggregate P

max: ((P, P) -> Boolean, %) -> 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

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

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, Boolean, Boolean) -> List %

zeroSetSplit(lp, clos?, info?) has the same specifications as zeroSetSplit from RegularTriangularSetCategory 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

SquareFreeRegularTriangularSetCategory(R, E, V, P)

TriangularSetCategory(R, E, V, P)