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

regset.spad line 1357 [edit on github]

R: GcdDomain

V: OrderedSet

P: RecursivePolynomialCategory(R, E, V)

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.

- #: % -> NonNegativeInteger
from Aggregate

- 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

- count: (P -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate P

- count: (P, %) -> NonNegativeInteger
from HomogeneousAggregate P

- degree: % -> NonNegativeInteger
from TriangularSetCategory(R, E, V, P)

- 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)

- 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. 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)

Evalable P if P has Evalable P

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, V, P)

RegularTriangularSetCategory(R, E, V, P)

TriangularSetCategory(R, E, V, P)