Lines Matching +refs:is +refs:regular +refs:ts
5 ++ This is just an interface between several packages and domains.
6 ++ The goal is to compute lexicographical Groebner bases
8 ++ by the {\em FGLM} algorithm if this is possible (i.e.
40 ++ ideal then the {\em FGLM} strategy is used, otherwise
41 ++ the {\em Sugar} strategy is used.
83 ++ A domain for regular chains (i.e. regular triangular sets) over
85 ++ This is just a front-end for the \spadtype{RegularTriangularSet}
99 ++ \spad{zeroSetSplit(lp, clos?, info?)} returns a list \spad{lts} of regular
100 ++ chains such that the union of the closures of their regular zero sets
102 ++ if \spad{clos?} is \spad{false} then the union of the regular zero
103 ++ set of the \spad{ts} (for \spad{ts} in \spad{lts}) equals this variety.
104 ++ If \spad{info?} is \spad{true} then some information is
120 ++ The decompositions are given by means of regular triangular sets.
124 ++ The second one provide decompositions by means of square-free regular triangular sets.
180 ++ ideal then the {\em FGLM} strategy is used, otherwise
181 ++ the {\em Sugar} strategy is used.
184 ++ associated with \spad{base} into regular chains.
185 ++ Thus a point belongs to this variety iff it is a regular
186 ++ zero of a regular set in in the output.
188 ++ of a zero-dimensional ideal. If \spad{norm?} is \spad{true}
189 ++ then the regular sets are normalized.
192 ++ associated with \spad{base} into square-free regular chains.
193 ++ Thus a point belongs to this variety iff it is a regular
194 ++ zero of a regular set in in the output.
196 ++ of a zero-dimensional ideal. If \spad{norm?} is \spad{true}
197 ++ then the regular sets are normalized.
200 ++ associated with \spad{lp} into regular chains.
201 ++ Thus a point belongs to this variety iff it is a regular
202 ++ zero of a regular set in in the output.
204 ++ If \spad{norm?} is \spad{true} then the regular sets are normalized.
207 ++ associated with \spad{lp} into square-free regular chains.
208 ++ Thus a point belongs to this variety iff it is a regular
209 ++ zero of a regular set in in the output.
211 ++ If \spad{norm?} is \spad{true} then the regular sets are normalized.
248 ts : TS := empty()
249 toSee : List LpWTS := [[base, ts]$LpWTS]
253 lp := lpwt.val; ts := lpwt.tower
254 empty? lp => toSave := cons(ts, toSave)
256 algebraic?(v, ts) =>
258 norm? and zero? remainder(init(p), ts).polnum =>
259 toSee := cons([lp, ts]$LpWTS, toSee)
260 (not norm?) and zero? (initiallyReduce(init(p), ts)) =>
261 toSee := cons([lp, ts]$LpWTS, toSee)
262 lbwt : List BWTS := invertible?(init(p), ts)$TS
292 ts : ST := empty()
293 toSee : List LpWST := [[base, ts]$LpWST]
297 lp := lpwt.val; ts := lpwt.tower
298 empty? lp => toSave := cons(ts, toSave)
300 algebraic?(v, ts) =>
302 norm? and zero? remainder(init(p), ts).polnum =>
303 toSee := cons([lp, ts]$LpWST, toSee)
304 (not norm?) and zero? (initiallyReduce(init(p), ts)) =>
305 toSee := cons([lp, ts]$LpWST, toSee)
306 lbwt : List BWST := invertible?(init(p), ts)$ST
343 ++ The main operation is \spadopFrom{rur}{InternalRationalUnivariateRepresentationPackage}.
344 ++ It is based on the {\em generic} algorithm description in [1]. \newline References:
370 ++ \spad{rur(ts, univ?)} returns a rational univariate representation
371 ++ of \spad{ts}. This assumes that the lowest polynomial in \spad{ts}
372 ++ is a variable \spad{v} which does not occur in the other polynomials
373 ++ of \spad{ts}. This variable will be used to define the simple
376 ++ If \spad{univ?} is \spad{true} then these polynomials will have
379 ++ \spad{checkRur(ts, lus)} returns \spad{true} if \spad{lus}
380 ++ is a rational univariate representation of \spad{ts}.
384 checkRur(ts : TS, lts : List TS) : Boolean ==
385 f0 := last(ts)::P
387 ts := collectUpper(ts, z)
388 dts : N := degree(ts)
389 lp := parts(ts)
400 -- if sqfr? ASSUME p is square-free
406 prepareRur(ts : TS) : List LPWT ==
407 not purelyAlgebraic?(ts)$TS =>
408 error "rur$IRURPK: #1 is not zero-dimensional"
409 lp : LP := parts(ts)$TS
412 error "rur$IRURPK: #1 is empty"
425 ts := internalAugment(newf1, convert(newf0, true)@TS)
426 toSave := cons([lp, ts], toSave)
429 makeMonic(z : V, c : P, r : P, ts : TS, s : P, univ? : B) : TS ==
430 --ASSUME r is a irreducible univariate polynomial in z
434 --ASSUME mvar(ts) < mvar(s)
435 lp : LP := parts(ts)
451 makeLinearAndMonic(p : P, xi : V, ts : TS, univ? : B, check? : B, info? : B) : List TS ==
453 -- if info? THEN some INFORMATION is displayed
454 f0 := last(ts)::P
457 ts := collectUpper(ts, z)
458 toSee : List WIP := [[f0, lambda, ts]$WIP]
462 (f0, lambda, ts) := (wip.pol, wip.gap, wip.tower)
478 toSee := cons([f0, next(lambda), ts]$WIP, toSee)
484 toSave := cons(makeMonic(z, c, fr, ts, s, univ?), toSave)
490 toSee := cons([f0, next(lambda), ts]$WIP, toSee)
493 rur (ts : TS, univ? : Boolean) : List TS ==
494 toSee : List LPWT := prepareRur(ts)
498 ts : TS := wip.tower
500 empty? lp => toSave := cons(ts, toSave)
503 p := remainder(p, ts).polnum
506 p := primitivePart stronglyReduce(p, ts)
510 ts := internalAugment(p, ts)
511 wip := [lp, ts]
513 lts := makeLinearAndMonic(p, xi, ts, univ?, false, false)
514 for ts in lts repeat
515 wip := [lp, ts]
528 ++ of a zero-dimensional algebraic variety given by a regular
529 ++ triangular set. This package is essentially an interface for the
531 ++ It is used in the \spadtype{ZeroDimensionalSolvePackage}
549 ++ of \spad{lp}. This assumes that \spad{lp} defines a regular
550 ++ triangular \spad{ts} whose associated variety is zero-dimensional
552 ++ \spad{[u, lc]} where \spad{u} is an irreducible univariate polynomial
559 ++ a root \spad{r} of \spad{u} such that \spad{x} is given by the
561 ++ If \spad{univ?} is \spad{true} then each polynomial \spad{c}
569 ++ Moreover, if \spad{check?} is \spad{true} then the result is checked.
589 error "rur$RURPACK: #1 is empty"
591 error "rur$RURPACK: #1 is not a triangular set"
592 ts : TS := [[newq]$(List Q)]
597 error "rur$RURPACK: #1 is not a subset of R[ls]"
601 toSee : List LQWT := [[lq, ts]$LQWT]
605 lq := lqwt.val; ts := lqwt.tower
607 -- output(ts::OutputForm)$OutputPackage
608 toSave := cons(ts, toSave)
610 not (mvar(q) > mvar(ts)) =>
611 error "rur$RURPACK: #1 is not a triangular set"
612 empty? (rest(ts)::TS) =>
615 newts := internalAugment(fq, ts)
618 lsfqwt : List QWT := squareFreePart(q, ts)
620 q := qwt.val; ts := qwt.tower
623 q := normalizedAssociate(q, ts)$normpack
624 newts := internalAugment(q, ts)
628 for ts in toSave repeat
629 lus := rur(ts, univ?)$rurpack
630 check? and (not checkRur(ts, lus)$rurpack) =>
632 output(ts::OutputForm)$OutputPackage
660 ++ of irreducible regular chains. Real roots are given by means of tuples
662 ++ This constructor takes three arguments. The first one \spad{R} is the
663 ++ coefficient ring. The second one \spad{ls} is the list of variables involved
665 ++ \spad{s} is an additional symbol used for the univariate representations.
666 ++ WARNING: The third argument is not checked.
668 ++ The default is to compute these decompositions directly from the input
716 ++ associated with \spad{lp} into regular chains.
717 ++ Thus a point belongs to this variety iff it is a regular
718 ++ zero of a regular set in in the output.
720 ++ If \spad{lp} is not zero-dimensional then the result is only
723 ++ Moreover, if \spad{info?} is \spad{true} then some information is
726 ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called
729 ++ Otherwise, the triangular decomposition is computed directly from the input
736 ++ \spad{univariateSolve(ts)} returns a univariate representation
737 ++ of \spad{ts}.
742 ++ Moreover, if \spad{info?} is \spad{true} then some information is
743 ++ displayed during the decomposition into regular chains.
744 ++ If \spad{check?} is \spad{true} then the result is checked.
746 ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called
749 ++ Otherwise, the triangular decomposition is computed directly from the input
761 ++ \spad{realSolve(ts)} returns the set of the points in the regular
762 ++ zero set of \spad{ts} whose coordinates are all real.
763 ++ WARNING: For each set of coordinates given by \spad{realSolve(ts)}
764 ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}.
766 ++ \spad{realSolve(ts, info?, check?, lextri?)} returns the set of the points
768 ++ Moreover, if \spad{info?} is \spad{true} then some information is
769 ++ displayed during decomposition into regular chains.
770 ++ If \spad{check?} is \spad{true} then the result is checked.
771 ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called
774 ++ Otherwise, the triangular decomposition is computed directly from the input
776 ++ WARNING: For each set of coordinates given by \spad{realSolve(ts, info?, check?, lextri?)}
777 ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}.
779 …++ \spad{realSolve(ts, info?, check?)} returns the same as \spad{realSolve(ts, info?, check?, fals…
781 ++ \spad{realSolve(ts, info?)} returns the same as \spad{realSolve(ts, info?, false, false)}.
783 ++ \spad{realSolve(lp)} returns the same as \spad{realSolve(ts, false, false, false)}
785 ++ \spad{positiveSolve(ts)} returns the points of the regular
786 ++ set of \spad{ts} with (real) strictly positive coordinates.
790 ++ Moreover, if \spad{info?} is \spad{true} then some information is
791 ++ displayed during decomposition into regular chains.
792 ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called
795 ++ Otherwise, the triangular decomposition is computed directly from the input
798 ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}.
804 ++ \spad{squareFree(ts)} returns the square-free factorization of \spad{ts}.
805 ++ Moreover, each factor is a Lazard triangular set and the decomposition
806 ++ is a Kalkbrener split of \spad{ts}, which is enough here for
808 ++ WARNING: \spad{ts} is not checked to be zero-dimensional.
839 squareFree(ts : TS) : List(ST) ==
842 lq : List(Q2) := [convert(p)@Q2 for p in parts(ts)]
905 realSolve(ts : TS) : List REALSOL ==
906 lsts : List ST := squareFree(ts)
938 for ts in lts repeat
939 lsts := concat(squareFree(ts), lsts)
981 positiveSolve(ts : TS) : List REALSOL ==
982 lsts : List ST := squareFree(ts)
1016 for ts in lts repeat
1017 lsts := concat(squareFree(ts), lsts)
1049 univariateSolve(ts : TS) : List RUR ==
1050 toSee : List ST := squareFree(ts)
1069 for ts in lts repeat
1070 toSee := concat(squareFree(ts), toSee)