code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/mregular_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/mregular_lib.doc INSTEAD
@c library version: (1.6.2.1,2002/02/20)
@c library file: ../Singular/LIB/mregular.lib
@cindex mregular.lib
@cindex mregular_lib
@table @asis
@item @strong{Library:}
mregular.lib
@item @strong{Purpose:}
   Castelnuovo-Mumford Regularity of CM-Schemes and Curves
@item @strong{Authors:}
I.Bermejo, ibermejo@@ull.es
@* Ph.Gimenez, pgimenez@@agt.uva.es
@* G.-M.Greuel, greuel@@mathematik.uni-kl.de

@item @strong{Overview:}
A library for computing the Castelnuovo-Mumford regularity of a subscheme of
the projective n-space that DOES NOT require the computation of a minimal
graded free resolution of the saturated ideal defining the subscheme.
The procedures are based on two papers by Isabel Bermejo and Philippe Gimenez:
'On Castelnuovo-Mumford regularity of projective curves' Proc.Amer.Math.Soc.
128(5) (2000), and 'Computing the Castelnuovo-Mumford regularity of some
subschemes of Pn using quotients of monomial ideals', Proceedings of
MEGA-2000, J. Pure Appl. Algebra (to appear).
@*The algorithm assumes the variables to be in Noether position.

@end table

@strong{Procedures:}
@menu
* reg_CM:: regularity of arith. C-M subscheme V(id_sat) of Pn
* reg_curve:: regularity of projective curve V(id_sat) in Pn
* reg_moncurve:: regularity of projective monomial curve defined by li
@end menu
@c ---end content LibInfo---

@c ------------------- reg_CM -------------
@node reg_CM, reg_curve,, mregular_lib
@subsubsection reg_CM
@cindex reg_CM
@c ---content reg_CM---
Procedure from library @code{mregular.lib} (@pxref{mregular_lib}).

@table @asis
@item @strong{Usage:}
reg_CM (i); i ideal

@item @strong{Return:}
an integer, the Castelnuovo-Mumford regularity of i-sat.

@item @strong{Assume:}
i is a homogeneous ideal of the basering S=K[x(0)..x(n)] where
the field K is infinite, and S/i-sat is Cohen-Macaulay.
Assume that K[x(n-d),...,x(n)] is a Noether normalization of S/i-sat
where d=dim S/i -1. If this is not the case, compute a Noether
normalization e.g. by using the proc noetherNormal from algebra.lib.

@item @strong{Note:}
The output is reg(X)=reg(i-sat) where X is the arithmetically
Cohen-Macaulay subscheme of the projective n-space defined by i.
If printlevel > 0 (default = 0) additional information is displayed.
In particular, the value of the regularity of the Hilbert function of
S/i-sat is given.

@end table
@strong{Example:}
@smallexample
@c computed example reg_CM d2t_singular/mregular_lib.doc:68
LIB "mregular.lib";
ring s=0,x(0..5),dp;
ideal i=x(2)^2-x(4)*x(5),x(1)*x(2)-x(0)*x(5),x(0)*x(2)-x(1)*x(4),
x(1)^2-x(3)*x(5),x(0)*x(1)-x(2)*x(3),x(0)^2-x(3)*x(4);
reg_CM(i);
@expansion{} 2
// Additional information can be obtained as follows:
printlevel = 1;
reg_CM(i);
@expansion{} // Ideal i of S defining an arithm. Cohen-Macaulay subscheme X of P5:
@expansion{} //   - dimension of X: 2
@expansion{} //   - i is saturated: YES
@expansion{} //   - regularity of the Hilbert function of S/i-sat: -1
@expansion{} //   - time for computing reg(X): 0 sec.
@expansion{} // Castelnuovo-Mumford regularity of X:
@expansion{} 2
@c end example reg_CM d2t_singular/mregular_lib.doc:68
@end smallexample
@c ---end content reg_CM---

@c ------------------- reg_curve -------------
@node reg_curve, reg_moncurve, reg_CM, mregular_lib
@subsubsection reg_curve
@cindex reg_curve
@c ---content reg_curve---
Procedure from library @code{mregular.lib} (@pxref{mregular_lib}).

@table @asis
@item @strong{Usage:}
reg_curve (i[,e]); i ideal, e integer

@item @strong{Return:}
an integer, the Castelnuovo-Mumford regularity of i-sat.

@item @strong{Assume:}
i is a homogeneous ideal of the basering S=K[x(0)..x(n)] where
the field K is infinite, and it defines a projective curve C in
the projective n-space (dim(i)=2). We assume that K[x(n-1),x(n)]
is a Noether normalization of S/i-sat.
@*e=0: (default)
@*Uses a random choice of an element of K when it is necessary.
This is absolutely safe (if the element is bad, another random
choice will be done until a good element is found).
@*e=1: Substitutes the random choice of an element of K by a simple
transcendental field extension of K.

@item @strong{Note:}
The output is the integer reg(C)=reg(i-sat).
@*If printlevel > 0 (default = 0) additional information is displayed.
In particular, says if C is arithmetically Cohen-Macaulay or not,
determines in which step of a minimal graded free resolution of i-sat
the regularity of C is attained, and sometimes gives the value of the
regularity of the Hilbert function of S/i-sat (otherwise, an upper
bound is given).

@end table
@strong{Example:}
@smallexample
@c computed example reg_curve d2t_singular/mregular_lib.doc:119
LIB "mregular.lib";
ring s = 0,(x,y,z,t),dp;
// 1st example is Ex.2.5 in [Bermejo-Gimenez], Proc.Amer.Math.Soc. 128(5):
ideal i  = x17y14-y31, x20y13, x60-y36z24-x20z20t20;
reg_curve(i);
@expansion{} 72
// 2nd example is Ex.2.9 in [Bermejo-Gimenez], Proc.Amer.Math.Soc. 128(5):
int k=43;
ideal j=x17y14-y31,x20y13,x60-y36z24-x20z20t20,y41*z^k-y40*z^(k+1);
reg_curve(j);
@expansion{} 93
// Additional information can be obtained as follows:
printlevel = 1;
reg_curve(j);
@expansion{} // Ideal i of S defining a projective curve C in P3:
@expansion{} //   - i is saturated: YES
@expansion{} //   - C is arithm. Cohen-Macaulay: NO
@expansion{} //   - reg(C) attained at the last step of a m.g.f.r. of i-sat: YES
@expansion{} //   - regularity of the Hilbert function of S/i-sat: 92
@expansion{} //   - time for computing reg(C): 0 sec.
@expansion{} // Castelnuovo-Mumford regularity of C:
@expansion{} 93
@c end example reg_curve d2t_singular/mregular_lib.doc:119
@end smallexample
@c ---end content reg_curve---

@c ------------------- reg_moncurve -------------
@node reg_moncurve,, reg_curve, mregular_lib
@subsubsection reg_moncurve
@cindex reg_moncurve
@c ---content reg_moncurve---
Procedure from library @code{mregular.lib} (@pxref{mregular_lib}).

@table @asis
@item @strong{Usage:}
reg_moncurve (a0,...,an) ; ai integers with a0=0 < a1 < ... < an=:d

@item @strong{Return:}
an integer, the Castelnuovo-Mumford regularity of the projective
monomial curve C in Pn parametrically defined by:
@*x(0)=t^d , x(1)=s^(a1)t^(d-a1), ... , x(n)=s^d.

@item @strong{Assume:}
a0=0 < a1 < ... < an are integers and the base field is infinite.

@item @strong{Note:}
The defining ideal I(C) in S is determined using elimination.
The procedure reg_curve is improved in this case since one
knows beforehand that the dimension is 2, that the variables are
in Noether position, that I(C) is prime.
@*If printlevel > 0 (default = 0) additional information is displayed.
In particular, says if C is arithmetically Cohen-Macaulay or not,
determines in which step of a minimal graded free resolution of I(C)
the regularity is attained, and sometimes gives the value of the
regularity of the Hilbert function of S/I(C) (otherwise, an upper
bound is given).

@end table
@strong{Example:}
@smallexample
@c computed example reg_moncurve d2t_singular/mregular_lib.doc:170
LIB "mregular.lib";
// The 1st example is the twisted cubic:
reg_moncurve(0,1,2,3);
@expansion{} 2
// The 2nd. example is the non arithm. Cohen-Macaulay monomial curve in P4
// parametrized by: x(0)-s6,x(1)-s5t,x(2)-s3t3,x(3)-st5,x(4)-t6:
reg_moncurve(0,1,3,5,6);
@expansion{} 3
// Additional information can be obtained as follows:
printlevel = 1;
reg_moncurve(0,1,3,5,6);
@expansion{} // Sequence of integers defining a monomial curve C in P4:
@expansion{} //   - time for computing ideal I(C) of S (elimination): 0 sec.
@expansion{} //   - C is arithm. Cohen-Macaulay: NO
@expansion{} //   - reg(C) attained at the last step of a m.g.f.r. of I(C): YES
@expansion{} //   - reg(C) attained at the second last step of a m.g.f.r. of I(C): YES
@expansion{} //   - regularity of the Hilbert function of S/I(C): 2
@expansion{} //   - time for computing reg(C): 0 sec.
@expansion{} // Castelnuovo-Mumford regularity of C:
@expansion{} 3
@c end example reg_moncurve d2t_singular/mregular_lib.doc:170
@end smallexample
@c ---end content reg_moncurve---


code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/normal_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/normal_lib.doc INSTEAD
@c library version: (1.34.2.17,2002/10/21)
@c library file: ../Singular/LIB/normal.lib
@cindex normal.lib
@cindex normal_lib
@table @asis
@item @strong{Library:}
normal.lib
@item @strong{Purpose:}
     Normalization of Affine Rings
@item @strong{Authors:}
G.-M. Greuel, greuel@@mathematik.uni-kl.de,
@* G. Pfister, pfister@@mathematik.uni-kl.de

@end table

@strong{Main procedures:}
@menu
* normal:: computes the normalization of basering/I, resp. computes the normalization of basering/I and the delta invariant
* HomJJ:: presentation of End_R(J) as affine ring, L a list
* genus:: computes genus of the projective curve defined by I
@end menu
@strong{Auxiliary procedure:}
@menu
* deltaLoc:: (sum of) delta invariant(s) at conjugated singular points
@end menu
@c ---end content LibInfo---

@c ------------------- normal -------------
@node normal, HomJJ,, normal_lib
@subsubsection normal
@cindex normal
@c ---content normal---
Procedure from library @code{normal.lib} (@pxref{normal_lib}).

@table @asis
@item @strong{Usage:}
normal(i [,choose]); i a radical ideal, choose empty, 1 or "wd"
if choose=1 the normalization of the associated primes is computed
(which is sometimes more efficient);
if @code{choose="wd"} the delta invariant is computed
simultaneously; this may take much more time in the reducible case,
since the factorizing standard basis algorithm cannot be used.

@item @strong{Assume:}
The ideal must be radical, for non-radical ideals the output may
be wrong (i=radical(i); makes i radical)

@item @strong{Return:}
a list of rings, say nor and in case of @code{choose="wd"} an
integer at the end of the list.
Each ring @code{nor[i]} contains two ideals with given names
@code{norid} and @code{normap} such that@*
- the direct sum of the rings @code{nor[i]/norid} is the
normalization of basering/id;@*
- @code{normap} gives the normalization map from basering/id to
@code{nor[i]/norid} (for each i).

@item @strong{Note:}
to use the i-th ring type: @code{def R=nor[i]; setring R;}.
@* Increasing printlevel displays more comments (default: printlevel=0).
@* Not implemented for local or mixed orderings.
@* If the input ideal i is weighted homogeneous a weighted ordering may
be used (qhweight(i); computes weights).

@cindex normalization
@cindex delta invariant.
@end table
@strong{Example:}
@smallexample
@c computed example normal d2t_singular/normal_lib.doc:71
LIB "normal.lib";
ring r=32003,(x,y,z),wp(2,1,2);
ideal i=z3-xy4;
list nor=normal(i);
@expansion{}
@expansion{} // 'normal' created a list of 1 ring(s).
@expansion{} // nor[1+1] is the delta-invariant in case of choose=wd.
@expansion{} // To see the rings, type (if the name of your list is nor):
@expansion{}      show( nor);
@expansion{} // To access the 1-st ring and map (similar for the others), type:
@expansion{}      def R = nor[1]; setring R;  norid; normap;
@expansion{} // R/norid is the 1-st ring of the normalization and
@expansion{} // normap the map from the original basering to R/norid
show(nor);
@expansion{} // list, 1 element(s):
@expansion{} [1]:
@expansion{}    // ring: (32003),(T(1),T(2),T(3)),(a(2,1,1),dp(3),C);
@expansion{}    // minpoly = 0
@expansion{} // objects belonging to this ring:
@expansion{} // normap               [0]  ideal, 3 generator(s)
@expansion{} // norid                [0]  ideal, 1 generator(s)
def r1=nor[1];
setring r1;
norid;
@expansion{} norid[1]=T(3)3-T(1)T(2)
normap;
@expansion{} normap[1]=T(1)
@expansion{} normap[2]=T(2)
@expansion{} normap[3]=T(2)T(3)
ring s=0,(x,y),dp;
ideal i=(x-y^2)^2 - y*x^3;
nor=normal(i,"wd");
@expansion{}
@expansion{} // 'normal' created a list of 1 ring(s).
@expansion{} // nor[1+1] is the delta-invariant in case of choose=wd.
@expansion{} // To see the rings, type (if the name of your list is nor):
@expansion{}      show( nor);
@expansion{} // To access the 1-st ring and map (similar for the others), type:
@expansion{}      def R = nor[1]; setring R;  norid; normap;
@expansion{} // R/norid is the 1-st ring of the normalization and
@expansion{} // normap the map from the original basering to R/norid
//the delta-invariant
nor[size(nor)];
@expansion{} 3
@c end example normal d2t_singular/normal_lib.doc:71
@end smallexample
@c ---end content normal---

@c ------------------- HomJJ -------------
@node HomJJ, genus, normal, normal_lib
@subsubsection HomJJ
@cindex HomJJ
@c ---content HomJJ---
Procedure from library @code{normal.lib} (@pxref{normal_lib}).

@table @asis
@item @strong{Usage:}
HomJJ (Li); Li = list: ideal SBid, ideal id, ideal J, poly p

@item @strong{Assume:}
R = P/id, P = basering, a polynomial ring, id an ideal of P,
@* SBid = standard basis of id,
@* J = ideal of P containing the polynomial p,
@* p = nonzero divisor of R

@item @strong{Compute:}
Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure as
affine ring, together with the canonical map R --> Hom_R(J,J),
where R is the quotient ring of P modulo the standard basis SBid.

@item @strong{Return:}
a list l of two objects
@format
         l[1] : a polynomial ring, containing two ideals, 'endid' and 'endphi'
               such that l[1]/endid = Hom_R(J,J) and
               endphi describes the canonical map R -> Hom_R(J,J)
         l[2] : an integer which is 1 if phi is an isomorphism, 0 if not
         l[3] : an integer, the contribution to delta
@end format

@item @strong{Note:}
printlevel >=1: display comments (default: printlevel=0)

@end table
@strong{Example:}
@smallexample
@c computed example HomJJ d2t_singular/normal_lib.doc:128
LIB "normal.lib";
ring r   = 0,(x,y),wp(2,3);
ideal id = y^2-x^3;
ideal J  = x,y;
poly p   = x;
list Li = std(id),id,J,p;
list L   = HomJJ(Li);
def end = L[1];    // defines ring L[1], containing ideals endid, endphi
setring end;       // makes end the basering
end;
@expansion{} //   characteristic : 0
@expansion{} //   number of vars : 1
@expansion{} //        block   1 : ordering dp
@expansion{} //                  : names    T(1)
@expansion{} //        block   2 : ordering C
endid;             // end/endid is isomorphic to End(r/id) as ring
@expansion{} endid[1]=0
map psi = r,endphi;// defines the canonical map r/id -> End(r/id)
psi;
@expansion{} psi[1]=T(1)^2
@expansion{} psi[2]=T(1)^3
@c end example HomJJ d2t_singular/normal_lib.doc:128
@end smallexample
@c ---end content HomJJ---

@c ------------------- genus -------------
@node genus, deltaLoc, HomJJ, normal_lib
@subsubsection genus
@cindex genus
@c ---content genus---
Procedure from library @code{normal.lib} (@pxref{normal_lib}).

@table @asis
@item @strong{Usage:}
genus(I) or genus(i,1); I a 1-dimensional ideal

@item @strong{Return:}
an integer, the geometric genus p_g = p_a - delta of the projective
curve defined by I, where p_a is the arithmetic genus.

@item @strong{Note:}
delta is the sum of all local delta-invariants of the singularities,
i.e. dim(R'/R), R' the normalization of the local ring R of the
singularity.
@*genus(i,1) uses the normalization to compute delta. Usually this
is slow but sometimes not.

@end table
@strong{Example:}
@smallexample
@c computed example genus d2t_singular/normal_lib.doc:171
LIB "normal.lib";
ring r=0,(x,y),dp;
ideal i=y^9 - x^2*(x - 1)^9;
genus(i);
@expansion{} 0
@c end example genus d2t_singular/normal_lib.doc:171
@end smallexample
@c ---end content genus---

@c ------------------- deltaLoc -------------
@node deltaLoc,, genus, normal_lib
@subsubsection deltaLoc
@cindex deltaLoc
@c ---content deltaLoc---
Procedure from library @code{normal.lib} (@pxref{normal_lib}).

@table @asis
@item @strong{Usage:}
deltaLoc(f,J); f poly, J ideal

@item @strong{Assume:}
f is reduced bivariate polynomial; basering has exactly two variables;
J is irreducible prime component of the singular locus of f (e.g., one
entry of the output of @code{minAssGTZ(I);}, I = <f,jacob(f)>).

@item @strong{Return:}
list L:

@table @asis
@item @code{L[1]}; int:
         the sum of (local) delta invariants of f at the (conjugated) singular
         points given by J.
@item @code{L[2]}; int:
         the sum of (local) Tjurina numbers of f at the (conjugated) singular
         points given by J.
@item @code{L[3]}; int:
         the sum of (local) number of branches of f at the (conjugated)
         singular points given by J.
@end table

@item @strong{Note:}
procedure makes use of @code{execute}; increasing printlevel displays
more comments (default: printlevel=0).

@cindex delta invariant
@cindex Tjurina number
@end table
@strong{Example:}
@smallexample
@c computed example deltaLoc d2t_singular/normal_lib.doc:220
LIB "normal.lib";
ring r=0,(x,y),dp;
poly f=(x2+y^2-1)^3 +27x2y2;
ideal I=f,jacob(f);
I=std(I);
list qr=minAssGTZ(I);
size(qr);
@expansion{} 6
// each component of the singular locus either describes a cusp or a pair
// of conjugated nodes:
deltaLoc(f,qr[1]);
@expansion{} [1]:
@expansion{}    1
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    1
deltaLoc(f,qr[2]);
@expansion{} [1]:
@expansion{}    1
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    1
deltaLoc(f,qr[3]);
@expansion{} [1]:
@expansion{}    1
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    1
deltaLoc(f,qr[4]);
@expansion{} [1]:
@expansion{}    1
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    1
deltaLoc(f,qr[5]);
@expansion{} [1]:
@expansion{}    2
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    4
deltaLoc(f,qr[6]);
@expansion{} [1]:
@expansion{}    2
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    4
@c end example deltaLoc d2t_singular/normal_lib.doc:220
@end smallexample
@c inserted refs from d2t_singular/normal_lib.doc:238
@ifinfo
@menu
See also:
* delta::
* tjurina::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{delta};
@ref{tjurina}.
@end iftex
@c end inserted refs from d2t_singular/normal_lib.doc:238

@c ---end content deltaLoc---

repo_name: mthl/texinfo

license: mit


code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/ntsolve_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/ntsolve_lib.doc INSTEAD
@c library version: (1.12.2.1,2002/04/12)
@c library file: ../Singular/LIB/ntsolve.lib
@cindex ntsolve.lib
@cindex ntsolve_lib
@table @asis
@item @strong{Library:}
ntsolve.lib
@item @strong{Purpose:}
     Real Newton Solving of Polynomial Systems
@item @strong{Authors:}
Wilfred Pohl, email: pohl@@mathematik.uni-kl.de
@*Dietmar Hillebrand

@end table

@strong{Procedures:}
@menu
* nt_solve:: find one real root of 0-dimensional ideal G
* triMNewton:: find one real root for 0-dim triangular system G
@end menu
@c ---end content LibInfo---

@c ------------------- nt_solve -------------
@node nt_solve, triMNewton,, ntsolve_lib
@subsubsection nt_solve
@cindex nt_solve
@c ---content nt_solve---
Procedure from library @code{ntsolve.lib} (@pxref{ntsolve_lib}).

@table @asis
@item @strong{Usage:}
nt_solve(gls,ini[,ipar]); gls,ini= ideals, ipar=list/intvec,@*
gls: contains the equations, for which a solution will be computed
ini: ideal of initial values (approximate solutions to start with),@*
ipar: control integers (default: ipar = 100,10)
  @format
 ipar[1]: max. number of iterations
 ipar[2]: accuracy (we have the l_2-norm ||.||): accept solution @code{sol}
          if ||gls(sol)|| < eps0*(0.1^ipar[2])
          where eps0 = ||gls(ini)|| is the initial error
  @end format

@item @strong{Assume:}
gls is a zerodimensional ideal with nvars(basering) = size(gls) (>1)

@item @strong{Return:}
ideal, coordinates of one solution (if found), 0 else

@item @strong{Note:}
if printlevel >0: displays comments (default =0)

@end table
@strong{Example:}
@smallexample
@c computed example nt_solve d2t_singular/ntsolve_lib.doc:56
LIB "ntsolve.lib";
ring rsq = (real,40),(x,y,z,w),lp;
ideal gls =  x2+y2+z2-10, y2+z3+w-8, xy+yz+xz+w5 - 1,w3+y;
ideal ini = 3.1,2.9,1.1,0.5;
intvec ipar = 200,0;
ideal sol = nt_solve(gls,ini,ipar);
sol;
@expansion{} sol[1]=0.8698104581550055082008024750939710335537
@expansion{} sol[2]=2.8215774457503246008496262517717182369409
@expansion{} sol[3]=1.1323120084664179900060940157112668717318
@expansion{} sol[4]=-1.413071026406678849397999475590194239628
@c end example nt_solve d2t_singular/ntsolve_lib.doc:56
@end smallexample
@c ---end content nt_solve---

@c ------------------- triMNewton -------------
@node triMNewton,, nt_solve, ntsolve_lib
@subsubsection triMNewton
@cindex triMNewton
@c ---content triMNewton---
Procedure from library @code{ntsolve.lib} (@pxref{ntsolve_lib}).

@table @asis
@item @strong{Usage:}
triMNewton(G,a[,ipar]); G,a= ideals, ipar=list/intvec

@item @strong{Assume:}
G: g1,..,gn, a triangular system of n equations in n vars, i.e.
gi=gi(var(n-i+1),..,var(n)),@*
a: ideal of numbers, coordinates of an approximation of a common
zero of G to start with (with a[i] to be substituted in var(i)),@*
ipar: control integer vector (default: ipar = 100,10)
  @format
  ipar[1]: max. number of iterations
  ipar[2]: accuracy (we have as norm |.| absolute value ):
           accept solution @code{sol} if |G(sol)| < |G(a)|*(0.1^ipar[2]).
  @end format

@item @strong{Return:}
an ideal, coordinates of a better approximation of a zero of G

@end table
@strong{Example:}
@smallexample
@c computed example triMNewton d2t_singular/ntsolve_lib.doc:97
LIB "ntsolve.lib";
ring r = (real,30),(z,y,x),(lp);
ideal i = x^2-1,y^2+x4-3,z2-y4+x-1;
ideal a = 2,3,4;
intvec e = 20,10;
ideal l = triMNewton(i,a,e);
l;
@expansion{} l[1]=-2.000000000042265738880279143423
@expansion{} l[2]=1.41421356237309504880168872421
@expansion{} l[3]=1
@c end example triMNewton d2t_singular/ntsolve_lib.doc:97
@end smallexample
@c ---end content triMNewton---


code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/paramet_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/paramet_lib.doc INSTEAD
@c library version: (1.11.2.1,2002/10/21)
@c library file: ../Singular/LIB/paramet.lib
@cindex paramet.lib
@cindex paramet_lib
@table @asis
@item @strong{Library:}
paramet.lib
@item @strong{Purpose:}
   Parametrization of Varieties
@item @strong{Author:}
Thomas Keilen, keilen@@mathematik.uni-kl.de

@end table

@strong{Procedures:}
@menu
* parametrize:: parametrizes a prime ideal via the normalization
* parametrizepd:: calculates the prim.dec. and parametrizes the components
* parametrizesing:: parametrizes an isolated plane curve singularity
@end menu
@table @asis
@item @strong{Overview:}
A library to compute parametrizations of algebraic varieties (if possible)
with the aid of a normalization, or a primary decomposition, resp. to compute
a parametrization of a plane curve singularity with the aid of a
Hamburger-Noether expansion.

@end table
@c inserted refs from d2t_singular/paramet_lib.doc:30
@ifinfo
@menu
See also:
* hnoether_lib::
* normal_lib::
* primdec_lib::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{hnoether_lib};
@ref{normal_lib};
@ref{primdec_lib}.
@end iftex
@c end inserted refs from d2t_singular/paramet_lib.doc:30

@c ---end content LibInfo---

@c ------------------- parametrize -------------
@node parametrize, parametrizepd,, paramet_lib
@subsubsection parametrize
@cindex parametrize
@c ---content parametrize---
Procedure from library @code{paramet.lib} (@pxref{paramet_lib}).

@table @asis
@item @strong{Usage:}
parametrize(I); I ideal in an arbitrary number of variables,
whose radical is prime, in a ring with global ordering

@item @strong{Create:}
If the parametrization is successful, the basering will be changed to
the parametrization ring, that is to the ring PR=0,(s,t),dp;
respectively PR=0,t(1..d),dp;, depending on the dimension of the
parametrized variety.

@item @strong{Return:}
a list containing the parametrization ideal resp. the original ideal,
the number of variables needed for the parametrization resp. 0, and
1 resp. 0 depending on whether the parametrization was successful
or not

@cindex parametrization
@cindex normalization
@end table
@strong{Example:}
@smallexample
@c computed example parametrize d2t_singular/paramet_lib.doc:65
LIB "paramet.lib";
ring RING=0,(x,y,z),dp;
ideal I=z2-y2x2+x3;
parametrize(I);
@expansion{} [1]:
@expansion{}    _[1]=s2-t2
@expansion{}    _[2]=s
@expansion{}    _[3]=s2t-t3
@expansion{} [2]:
@expansion{}    2
@expansion{} [3]:
@expansion{}    1
@c end example parametrize d2t_singular/paramet_lib.doc:65
@end smallexample
@c inserted refs from d2t_singular/paramet_lib.doc:72
@ifinfo
@menu
See also:
* normal::
* parametrizepd::
* primdecGTZ::
* radical::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{normal};
@ref{parametrizepd};
@ref{primdecGTZ};
@ref{radical}.
@end iftex
@c end inserted refs from d2t_singular/paramet_lib.doc:72

@c ---end content parametrize---

@c ------------------- parametrizepd -------------
@node parametrizepd, parametrizesing, parametrize, paramet_lib
@subsubsection parametrizepd
@cindex parametrizepd
@c ---content parametrizepd---
Procedure from library @code{paramet.lib} (@pxref{paramet_lib}).

@table @asis
@item @strong{Usage:}
parametrizepd(I); I ideal in a polynomial ring with global ordering

@item @strong{Create:}
If the parametrization is successful, the basering will be changed to
the parametrization ring, that is to the ring PR=0,(s,t),dp;
respectively PR=0,t(1..d),dp;, depending on the dimension of the
parametrized variety.

@item @strong{Return:}
a list of lists, where each entry contains the parametrization
of a primary component of I resp. 0, the number of variables
resp. 0, and 1 resp. 0 depending on whether the parametrization
of the component was successful or not

@cindex parametrization
@cindex normalization
@end table
@strong{Example:}
@smallexample
@c computed example parametrizepd d2t_singular/paramet_lib.doc:106
LIB "paramet.lib";
ring RING=0,(x,y,z),dp;
ideal I=(x2-y2z2+z3)*(x2-z2-z3),(x2-y2z2+z3)*yz;
parametrizepd(I);
@expansion{} [1]:
@expansion{}    [1]:
@expansion{}       _[1]=s2t-t3
@expansion{}       _[2]=s
@expansion{}       _[3]=s2-t2
@expansion{}    [2]:
@expansion{}       2
@expansion{}    [3]:
@expansion{}       1
@expansion{} [2]:
@expansion{}    [1]:
@expansion{}       _[1]=0
@expansion{}       _[2]=s
@expansion{}       _[3]=0
@expansion{}    [2]:
@expansion{}       1
@expansion{}    [3]:
@expansion{}       1
@expansion{} [3]:
@expansion{}    [1]:
@expansion{}       _[1]=s3-s
@expansion{}       _[2]=0
@expansion{}       _[3]=s2-1
@expansion{}    [2]:
@expansion{}       1
@expansion{}    [3]:
@expansion{}       1
@c end example parametrizepd d2t_singular/paramet_lib.doc:106
@end smallexample
@c inserted refs from d2t_singular/paramet_lib.doc:113
@ifinfo
@menu
See also:
* normal::
* parametrize::
* primdecGTZ::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{normal};
@ref{parametrize};
@ref{primdecGTZ}.
@end iftex
@c end inserted refs from d2t_singular/paramet_lib.doc:113

@c ---end content parametrizepd---

@c ------------------- parametrizesing -------------
@node parametrizesing,, parametrizepd, paramet_lib
@subsubsection parametrizesing
@cindex parametrizesing
@c ---content parametrizesing---
Procedure from library @code{paramet.lib} (@pxref{paramet_lib}).

@table @asis
@item @strong{Usage:}
parametrizesing(f); f a polynomial in two variables, ordering ls or ds

@item @strong{Create:}
If the parametrization is successful, the basering will be changed to
the parametrization ring, that is to the ring 0,(x,y),ls;

@item @strong{Return:}
a list containing the parametrizations of the different branches of the
singularity at the origin resp. 0, if f was not of the desired kind

@cindex parametrization
@cindex curve singularities
@end table
@strong{Example:}
@smallexample
@c computed example parametrizesing d2t_singular/paramet_lib.doc:143
LIB "paramet.lib";
ring RING=0,(x,y),ls;
poly f=(x^2-y^3)*(x^2-y^2-y^3);
parametrizesing(f);
@expansion{} [1]:
@expansion{}    _[1]=x
@expansion{}    _[2]=x-1/2x2
@expansion{} [2]:
@expansion{}    _[1]=x
@expansion{}    _[2]=-x-1/2x2
@expansion{} [3]:
@expansion{}    _[1]=x3
@expansion{}    _[2]=x2
@c end example parametrizesing d2t_singular/paramet_lib.doc:143
@end smallexample
@c inserted refs from d2t_singular/paramet_lib.doc:150
@ifinfo
@menu
See also:
* develop::
* hnexpansion::
* hnoether_lib::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{develop};
@ref{hnexpansion};
@ref{hnoether_lib}.
@end iftex
@c end inserted refs from d2t_singular/paramet_lib.doc:150

@c ---end content parametrizesing---


code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/poly_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/poly_lib.doc INSTEAD
@c library version: (1.33.2.6,2003/02/10)
@c library file: ../Singular/LIB/poly.lib
@cindex poly.lib
@cindex poly_lib
@table @asis
@item @strong{Library:}
poly.lib
@item @strong{Purpose:}
      Procedures for Manipulating Polys, Ideals, Modules
@item @strong{Authors:}
O. Bachmann, G.-M: Greuel, A. Fruehbis

@end table

@strong{Procedures:}
@menu
* cyclic:: ideal of cyclic n-roots
* katsura:: katsura [i] ideal
* freerank:: rank of coker(input) if coker is free else -1
* is_homog:: int, =1 resp. =0 if input is homogeneous resp. not
* is_zero:: int, =1 resp. =0 if coker(input) is 0 resp. not
* lcm:: lcm of given generators of ideal
* maxcoef:: maximal length of coefficient occurring in poly/...
* maxdeg:: int/intmat = degree/s of terms of maximal order
* maxdeg1:: int = [weighted] maximal degree of input
* mindeg:: int/intmat = degree/s of terms of minimal order
* mindeg1:: int = [weighted] minimal degree of input
* normalize:: normalize poly/... such that leading coefficient is 1
* rad_con:: check radical containment of poly p in ideal I
* content:: content of polynomial/vector f
* numerator:: numerator of number n
* denominator:: denominator of number n
* mod2id:: conversion of a module M to an ideal
* id2mod:: conversion inverse to mod2id
* substitute:: substitute in I variables by polynomials
* subrInterred:: interred w.r.t. a subset of variables
* hilbPoly:: Hilbert polynomial of basering/I
@end menu
@c ---end content LibInfo---

@c ------------------- cyclic -------------
@node cyclic, katsura,, poly_lib
@subsubsection cyclic
@cindex cyclic
@c ---content cyclic---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
cyclic(n); n integer

@item @strong{Return:}
ideal of cyclic n-roots from 1-st n variables of basering

@end table
@strong{Example:}
@smallexample
@c computed example cyclic d2t_singular/poly_lib.doc:59
LIB "poly.lib";
ring r=0,(u,v,w,x,y,z),lp;
cyclic(nvars(basering));
@expansion{} _[1]=u+v+w+x+y+z
@expansion{} _[2]=uv+uz+vw+wx+xy+yz
@expansion{} _[3]=uvw+uvz+uyz+vwx+wxy+xyz
@expansion{} _[4]=uvwx+uvwz+uvyz+uxyz+vwxy+wxyz
@expansion{} _[5]=uvwxy+uvwxz+uvwyz+uvxyz+uwxyz+vwxyz
@expansion{} _[6]=uvwxyz-1
homog(cyclic(5),z);
@expansion{} _[1]=u+v+w+x+y
@expansion{} _[2]=uv+uy+vw+wx+xy
@expansion{} _[3]=uvw+uvy+uxy+vwx+wxy
@expansion{} _[4]=uvwx+uvwy+uvxy+uwxy+vwxy
@expansion{} _[5]=uvwxy-z5
@c end example cyclic d2t_singular/poly_lib.doc:59
@end smallexample
@c ---end content cyclic---

@c ------------------- katsura -------------
@node katsura, freerank, cyclic, poly_lib
@subsubsection katsura
@cindex katsura
@c ---content katsura---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
katsura([n]): n integer

@item @strong{Return:}
katsura(n) : n-th katsura ideal of
@*(1) newly created and set ring (32003, x(0..n), dp), if
nvars(basering) < n
@*(2) basering, if nvars(basering) >= n
@*katsura() : katsura ideal of basering

@end table
@strong{Example:}
@smallexample
@c computed example katsura d2t_singular/poly_lib.doc:89
LIB "poly.lib";
ring r; basering;
@expansion{} //   characteristic : 32003
@expansion{} //   number of vars : 3
@expansion{} //        block   1 : ordering dp
@expansion{} //                  : names    x y z
@expansion{} //        block   2 : ordering C
katsura();
@expansion{} _[1]=x+2y+2z-1
@expansion{} _[2]=x2+2y2+2z2-x
@expansion{} _[3]=2xy+2yz-y
katsura(4); basering;
@expansion{} _[1]=x(0)+2*x(1)+2*x(2)+2*x(3)-1
@expansion{} _[2]=x(0)^2+2*x(1)^2+2*x(2)^2+2*x(3)^2-x(0)
@expansion{} _[3]=2*x(0)*x(1)+2*x(1)*x(2)+2*x(2)*x(3)-x(1)
@expansion{} _[4]=x(1)^2+2*x(0)*x(2)+2*x(1)*x(3)-x(2)
@expansion{} //   characteristic : 32003
@expansion{} //   number of vars : 5
@expansion{} //        block   1 : ordering dp
@expansion{} //                  : names    x(0) x(1) x(2) x(3) x(4)
@expansion{} //        block   2 : ordering C
@c end example katsura d2t_singular/poly_lib.doc:89
@end smallexample
@c ---end content katsura---

@c ------------------- freerank -------------
@node freerank, is_homog, katsura, poly_lib
@subsubsection freerank
@cindex freerank
@c ---content freerank---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
freerank(M[,any]); M=poly/ideal/vector/module/matrix

@item @strong{Compute:}
rank of module presented by M in case it is free.
@*By definition this is vdim(coker(M)/m*coker(M)) if coker(M)
is free, where m = maximal ideal of the variables of the
basering and M is considered as matrix.
@*(the 0-module is free of rank 0)

@item @strong{Return:}
rank of coker(M) if coker(M) is free and -1 else;
@*in case of a second argument return a list:
@*L[1] = rank of coker(M) or -1
@*L[2] = minbase(M)

@item @strong{Note:}
freerank(syz(M)); computes the rank of M if M is free (and -1 else)

@end table
@strong{Example:}
@smallexample
@c computed example freerank d2t_singular/poly_lib.doc:128
LIB "poly.lib";
ring r;
ideal i=x;
module M=[x,0,1],[-x,0,-1];
freerank(M);          // should be 2, coker(M) is not free
@expansion{} 2
freerank(syz (M),"");
@expansion{} [1]:
@expansion{}    1
@expansion{} [2]:
@expansion{}    _[1]=gen(2)+gen(1)
// [1] should be 1, coker(syz(M))=M is free of rank 1
// [2] should be gen(2)+gen(1) (minimal relation of M)
freerank(i);
@expansion{} -1
freerank(syz(i));     // should be 1, coker(syz(i))=i is free of rank 1
@expansion{} 1
@c end example freerank d2t_singular/poly_lib.doc:128
@end smallexample
@c ---end content freerank---

@c ------------------- is_homog -------------
@node is_homog, is_zero, freerank, poly_lib
@subsubsection is_homog
@cindex is_homog
@c ---content is_homog---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
is_homog(id); id poly/ideal/vector/module/matrix

@item @strong{Return:}
integer which is 1 if input is homogeneous (resp. weighted homogeneous
if the monomial ordering consists of one block of type ws,Ws,wp or Wp,
assuming that all weights are positive) and 0 otherwise

@item @strong{Note:}
A vector is homogeneous, if the components are homogeneous of same
degree, a module/matrix is homogeneous if all column vectors are
homogeneous
@*//*** ergaenzen, wenn Matrizen-Spalten Gewichte haben

@end table
@strong{Example:}
@smallexample
@c computed example is_homog d2t_singular/poly_lib.doc:168
LIB "poly.lib";
ring r = 0,(x,y,z),wp(1,2,3);
is_homog(x5-yz+y3);
@expansion{} 0
ideal i = x6+y3+z2, x9-z3;
is_homog(i);
@expansion{} 1
ring s = 0,(a,b,c),ds;
vector v = [a2,0,ac+bc];
vector w = [a3,b3,c4];
is_homog(v);
@expansion{} 1
is_homog(w);
@expansion{} 0
@c end example is_homog d2t_singular/poly_lib.doc:168
@end smallexample
@c ---end content is_homog---

@c ------------------- is_zero -------------
@node is_zero, lcm, is_homog, poly_lib
@subsubsection is_zero
@cindex is_zero
@c ---content is_zero---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
is_zero(M[,any]); M=poly/ideal/vector/module/matrix

@item @strong{Return:}
integer, 1 if coker(M)=0 resp. 0 if coker(M)!=0, where M is
considered as matrix.
@*If a second argument is given, return a list:
@*L[1] = 1 if coker(M)=0 resp. 0 if coker(M)!=0
@*L[2] = dim(M)

@end table
@strong{Example:}
@smallexample
@c computed example is_zero d2t_singular/poly_lib.doc:204
LIB "poly.lib";
ring r;
module m = [x],[y],[1,z];
is_zero(m,1);
@expansion{} [1]:
@expansion{}    0
@expansion{} [2]:
@expansion{}    2
qring q = std(ideal(x2+y3+z2));
ideal j = x2+y3+z2-37;
is_zero(j);
@expansion{} 1
@c end example is_zero d2t_singular/poly_lib.doc:204
@end smallexample
@c ---end content is_zero---

@c ------------------- lcm -------------
@node lcm, maxcoef, is_zero, poly_lib
@subsubsection lcm
@cindex lcm
@c ---content lcm---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
lcm(p[,q]); p int/intvec q a list of integers or
@*p poly/ideal q a list of polynomials

@item @strong{Return:}
the least common multiple of the common entries of p and q:
@* - of type int if p is an int/intvec
@* - of type poly if p is a poly/ideal

@end table
@strong{Example:}
@smallexample
@c computed example lcm d2t_singular/poly_lib.doc:236
LIB "poly.lib";
ring  r = 0,(x,y,z),lp;
poly  p = (x+y)*(y+z);
poly  q = (z4+2)*(y+z);
lcm(p,q);
@expansion{} xyz4+2xy+xz5+2xz+y2z4+2y2+yz5+2yz
ideal i=p,q,y+z;
lcm(i,p);
@expansion{} xyz4+2xy+xz5+2xz+y2z4+2y2+yz5+2yz
lcm(2,3,6);
@expansion{} 6
lcm(2..6);
@expansion{} 60
@c end example lcm d2t_singular/poly_lib.doc:236
@end smallexample
@c ---end content lcm---

@c ------------------- maxcoef -------------
@node maxcoef, maxdeg, lcm, poly_lib
@subsubsection maxcoef
@cindex maxcoef
@c ---content maxcoef---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
maxcoef(f); f poly/ideal/vector/module/matrix

@item @strong{Return:}
maximal length of coefficient of f of type int (by counting the
length of the string of each coefficient)

@end table
@strong{Example:}
@smallexample
@c computed example maxcoef d2t_singular/poly_lib.doc:268
LIB "poly.lib";
ring r= 0,(x,y,z),ds;
poly g = 345x2-1234567890y+7/4z;
maxcoef(g);
@expansion{} 10
ideal i = g,10/1234567890;
maxcoef(i);
@expansion{} 11
// since i[2]=1/123456789
@c end example maxcoef d2t_singular/poly_lib.doc:268
@end smallexample
@c ---end content maxcoef---

@c ------------------- maxdeg -------------
@node maxdeg, maxdeg1, maxcoef, poly_lib
@subsubsection maxdeg
@cindex maxdeg
@c ---content maxdeg---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
maxdeg(id); id poly/ideal/vector/module/matrix

@item @strong{Return:}
int/intmat, each component equals maximal degree of monomials in the
corresponding component of id, independent of ring ordering
(maxdeg of each var is 1).
@*Of type int if id is of type poly, of type intmat else

@item @strong{Note:}
proc maxdeg1 returns 1 integer, the absolute maximum; moreover, it has
an option for computing weighted degrees

@end table
@strong{Example:}
@smallexample
@c computed example maxdeg d2t_singular/poly_lib.doc:304
LIB "poly.lib";
ring r = 0,(x,y,z),wp(1,2,3);
poly f = x+y2+z3;
deg(f);             //deg; returns weighted degree (in case of 1 block)!
@expansion{} 9
maxdeg(f);
@expansion{} 3
matrix m[2][2]=f+x10,1,0,f^2;
maxdeg(m);
@expansion{} 10,0,
@expansion{} -1,6
@c end example maxdeg d2t_singular/poly_lib.doc:304
@end smallexample
@c ---end content maxdeg---

@c ------------------- maxdeg1 -------------
@node maxdeg1, mindeg, maxdeg, poly_lib
@subsubsection maxdeg1
@cindex maxdeg1
@c ---content maxdeg1---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
maxdeg1(id[,v]); id=poly/ideal/vector/module/matrix, v=intvec

@item @strong{Return:}
integer, maximal [weighted] degree of monomials of id independent of
ring ordering, maxdeg1 of i-th variable is v[i] (default: v=1..1).

@item @strong{Note:}
This proc returns one integer while maxdeg returns, in general,
a matrix of integers. For one polynomial and if no intvec v is given
maxdeg is faster

@end table
@strong{Example:}
@smallexample
@c computed example maxdeg1 d2t_singular/poly_lib.doc:339
LIB "poly.lib";
ring r = 0,(x,y,z),wp(1,2,3);
poly f = x+y2+z3;
deg(f);            //deg returns weighted degree (in case of 1 block)!
@expansion{} 9
maxdeg1(f);
@expansion{} 3
intvec v = ringweights(r);
maxdeg1(f,v);                        //weighted maximal degree
@expansion{} 9
matrix m[2][2]=f+x10,1,0,f^2;
maxdeg1(m,v);                        //absolute weighted maximal degree
@expansion{} 18
@c end example maxdeg1 d2t_singular/poly_lib.doc:339
@end smallexample
@c ---end content maxdeg1---

@c ------------------- mindeg -------------
@node mindeg, mindeg1, maxdeg1, poly_lib
@subsubsection mindeg
@cindex mindeg
@c ---content mindeg---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
mindeg(id); id poly/ideal/vector/module/matrix

@item @strong{Return:}
minimal degree/s of monomials of id, independent of ring ordering
(mindeg of each variable is 1) of type int if id of type poly, else
of type intmat.

@item @strong{Note:}
proc mindeg1 returns one integer, the absolute minimum; moreover it
has an option for computing weighted degrees.

@end table
@strong{Example:}
@smallexample
@c computed example mindeg d2t_singular/poly_lib.doc:376
LIB "poly.lib";
ring r = 0,(x,y,z),ls;
poly f = x5+y2+z3;
ord(f);                  // ord returns weighted order of leading term!
@expansion{} 3
mindeg(f);               // computes minimal degree
@expansion{} 2
matrix m[2][2]=x10,1,0,f^2;
mindeg(m);               // computes matrix of minimum degrees
@expansion{} 10,0,
@expansion{} -1,4
@c end example mindeg d2t_singular/poly_lib.doc:376
@end smallexample
@c ---end content mindeg---

@c ------------------- mindeg1 -------------
@node mindeg1, normalize, mindeg, poly_lib
@subsubsection mindeg1
@cindex mindeg1
@c ---content mindeg1---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
mindeg1(id[,v]); id=poly/ideal/vector/module/matrix, v=intvec

@item @strong{Return:}
integer, minimal [weighted] degree of monomials of id independent of
ring ordering, mindeg1 of i-th variable is v[i] (default v=1..1).

@item @strong{Note:}
This proc returns one integer while mindeg returns, in general,
a matrix of integers. For one polynomial and if no intvec v is given
mindeg is faster.

@end table
@strong{Example:}
@smallexample
@c computed example mindeg1 d2t_singular/poly_lib.doc:411
LIB "poly.lib";
ring r = 0,(x,y,z),ls;
poly f = x5+y2+z3;
ord(f);                  // ord returns weighted order of leading term!
@expansion{} 3
intvec v = 1,-3,2;
mindeg1(f,v);            // computes minimal weighted degree
@expansion{} -6
matrix m[2][2]=x10,1,0,f^2;
mindeg1(m,1..3);         // computes absolute minimum of weighted degrees
@expansion{} -1
@c end example mindeg1 d2t_singular/poly_lib.doc:411
@end smallexample
@c ---end content mindeg1---

@c ------------------- normalize -------------
@node normalize, rad_con, mindeg1, poly_lib
@subsubsection normalize
@cindex normalize
@c ---content normalize---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
normalize(id); id=poly/vector/ideal/module

@item @strong{Return:}
object of same type with leading coefficient equal to 1

@end table
@strong{Example:}
@smallexample
@c computed example normalize d2t_singular/poly_lib.doc:441
LIB "poly.lib";
ring r = 0,(x,y,z),ls;
poly f = 2x5+3y2+4z3;
normalize(f);
@expansion{} z3+3/4y2+1/2x5
module m=[9xy,0,3z3],[4z,6y,2x];
normalize(m);
@expansion{} _[1]=z3*gen(3)+3xy*gen(1)
@expansion{} _[2]=z*gen(1)+3/2y*gen(2)+1/2x*gen(3)
ring s = 0,(x,y,z),(c,ls);
module m=[9xy,0,3z3],[4z,6y,2x];
normalize(m);
@expansion{} _[1]=[xy,0,1/3z3]
@expansion{} _[2]=[z,3/2y,1/2x]
@c end example normalize d2t_singular/poly_lib.doc:441
@end smallexample
@c ---end content normalize---

@c ------------------- rad_con -------------
@node rad_con, content, normalize, poly_lib
@subsubsection rad_con
@cindex rad_con
@c ---content rad_con---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
rad_con(g,I); g polynomial, I ideal

@item @strong{Return:}
1 (TRUE) (type int) if g is contained in the radical of I
@* 0 (FALSE) (type int) otherwise

@end table
@strong{Example:}
@smallexample
@c computed example rad_con d2t_singular/poly_lib.doc:473
LIB "poly.lib";
ring R=0,(x,y,z),dp;
ideal I=x2+y2,z2;
poly f=x4+y4;
rad_con(f,I);
@expansion{} 0
ideal J=x2+y2,z2,x4+y4;
poly g=z;
rad_con(g,I);
@expansion{} 1
@c end example rad_con d2t_singular/poly_lib.doc:473
@end smallexample
@c ---end content rad_con---

@c ------------------- content -------------
@node content, numerator, rad_con, poly_lib
@subsubsection content
@cindex content
@c ---content content---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
content(f); f polynomial/vector

@item @strong{Return:}
number, the content (greatest common factor of coefficients)
of the polynomial/vector f

@end table
@strong{Example:}
@smallexample
@c computed example content d2t_singular/poly_lib.doc:504
LIB "poly.lib";
ring r=0,(x,y,z),(c,lp);
content(3x2+18xy-27xyz);
@expansion{} 3
vector v=[3x2+18xy-27xyz,15x2+12y4,3];
content(v);
@expansion{} 3
@c end example content d2t_singular/poly_lib.doc:504
@end smallexample
@c ---end content content---

@c ------------------- numerator -------------
@node numerator, denominator, content, poly_lib
@subsubsection numerator
@cindex numerator
@c ---content numerator---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
numerator(n); n number

@item @strong{Return:}
number, the numerator of n

@end table
@strong{Example:}
@smallexample
@c computed example numerator d2t_singular/poly_lib.doc:531
LIB "poly.lib";
ring r = 0,x, dp;
number n = 3/2;
numerator(n);
@expansion{} 3
@c end example numerator d2t_singular/poly_lib.doc:531
@end smallexample
@c inserted refs from d2t_singular/poly_lib.doc:538
@ifinfo
@menu
See also:
* cleardenom::
* content::
* denominator::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{cleardenom};
@ref{content};
@ref{denominator}.
@end iftex
@c end inserted refs from d2t_singular/poly_lib.doc:538

@c ---end content numerator---

@c ------------------- denominator -------------
@node denominator, mod2id, numerator, poly_lib
@subsubsection denominator
@cindex denominator
@c ---content denominator---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
denominator(n); n number

@item @strong{Return:}
number, the denominator of n

@end table
@strong{Example:}
@smallexample
@c computed example denominator d2t_singular/poly_lib.doc:561
LIB "poly.lib";
ring r = 0,x, dp;
number n = 3/2;
denominator(n);
@expansion{} 2
@c end example denominator d2t_singular/poly_lib.doc:561
@end smallexample
@c inserted refs from d2t_singular/poly_lib.doc:568
@ifinfo
@menu
See also:
* cleardenom::
* content::
* denominator::
@end menu
@end ifinfo
@iftex
@strong{See also:}
@ref{cleardenom};
@ref{content};
@ref{denominator}.
@end iftex
@c end inserted refs from d2t_singular/poly_lib.doc:568

@c ---end content denominator---

@c ------------------- mod2id -------------
@node mod2id, id2mod, denominator, poly_lib
@subsubsection mod2id
@cindex mod2id
@c ---content mod2id---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
mod2id(M,vpos); M matrix, vpos intvec

@item @strong{Assume:}
vpos is an integer vector such that gen(i) corresponds
to var(vpos[i]).
@*The basering contains variables var(vpos[i]) which do not occur
in M.

@item @strong{Return:}
ideal I in which each gen(i) from the module is replaced by
var(vpos[i]) and all monomials var(vpos[i])*var(vpos[j]) have
been added to the generating set of I.

@item @strong{Note:}
This procedure should be used in the following situation:
one wants to pass to a ring with new variables, say e(1),..,e(s),
which correspond to the components gen(1),..,gen(s) of the
module M such that e(i)*e(j)=0 for all i,j.
@*The new ring should already exist and be the current ring

@end table
@strong{Example:}
@smallexample
@c computed example mod2id d2t_singular/poly_lib.doc:606
LIB "poly.lib";
ring r=0,(e(1),e(2),x,y,z),(dp(2),ds(3));
module mo=x*gen(1)+y*gen(2);
intvec iv=2,1;
mod2id(mo,iv);
@expansion{} _[1]=e(2)^2
@expansion{} _[2]=e(1)*e(2)
@expansion{} _[3]=e(1)^2
@expansion{} _[4]=e(1)*y+e(2)*x
@c end example mod2id d2t_singular/poly_lib.doc:606
@end smallexample
@c ---end content mod2id---

@c ------------------- id2mod -------------
@node id2mod, substitute, mod2id, poly_lib
@subsubsection id2mod
@cindex id2mod
@c ---content id2mod---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
id2mod(I,vpos); I ideal, vpos intvec

@item @strong{Return:}
module corresponding to the ideal by replacing var(vpos[i]) by
gen(i) and omitting all generators var(vpos[i])*var(vpos[j])

@item @strong{Note:}
* This procedure only makes sense if the ideal contains
all var(vpos[i])*var(vpos[j]) as monomial generators and
all other generators of I are linear combinations of the
var(vpos[i]) over the ring in the other variables.
@** This is the inverse procedure to mod2id and should be applied
only to ideals created by mod2id using the same intvec vpos
(possibly after a standard basis computation)

@end table
@strong{Example:}
@smallexample
@c computed example id2mod d2t_singular/poly_lib.doc:643
LIB "poly.lib";
ring r=0,(e(1),e(2),x,y,z),(dp(2),ds(3));
ideal i=e(2)^2,e(1)*e(2),e(1)^2,e(1)*y+e(2)*x;
intvec iv=2,1;
id2mod(i,iv);
@expansion{} _[1]=x*gen(1)+y*gen(2)
@c end example id2mod d2t_singular/poly_lib.doc:643
@end smallexample
@c ---end content id2mod---

@c ------------------- substitute -------------
@node substitute, subrInterred, id2mod, poly_lib
@subsubsection substitute
@cindex substitute
@c ---content substitute---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
- case 1: typeof(#[1])==poly:
@*substitute (I,v,f[,v1,f1,v2,f2,...]); I object of basering which
can be mapped, v,v1,v2,.. ring variables, f,f1,f2,... poly
@* - case 2: typeof(#[1])==ideal:
substitute1 (I,v,f); I object of basering which can be mapped,
v ideal of ring variables, f ideal

@item @strong{Return:}
object of same type as I,
@* - case 1: ring variable v,v1,v2,... substituted by polynomials
f,f1,f2,..., in this order
@* - case 2: ring variables in v substituted by polynomials in f:
v[i] is substituted by f[i], i=1,...,i=min(size(v),ncols(f))

@item @strong{Note:}
this procedure extends the built-in command subst which substitutes
ring variables only by monomials

@end table
@strong{Example:}
@smallexample
@c computed example substitute d2t_singular/poly_lib.doc:683
LIB "poly.lib";
ring r = 0,(b,c,t),dp;
ideal I = -bc+4b2c2t,bc2t-5b2c;
substitute(I,c,b+c,t,0,b,b-1);
@expansion{} _[1]=-b2-bc+2b+c-1
@expansion{} _[2]=-5b3-5b2c+15b2+10bc-15b-5c+5
ideal v = c,t,b;
ideal f = b+c,0,b-1;
substitute(I,v,f);
@expansion{} _[1]=-b2-bc+2b+c-1
@expansion{} _[2]=-5b3-5b2c+15b2+10bc-15b-5c+5
@c end example substitute d2t_singular/poly_lib.doc:683
@end smallexample
@c ---end content substitute---

@c ------------------- subrInterred -------------
@node subrInterred, hilbPoly, substitute, poly_lib
@subsubsection subrInterred
@cindex subrInterred
@c ---content subrInterred---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
subrInterred(mon,sm,iv);
@*sm: ideal in a ring r with n + s variables,
@*e.g. x_1,..,x_n and t_1,..,t_s
@*mon: ideal with monomial generators (not divisible by
any of the t_i) such that sm is contained in the module
k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]
@*iv: intvec listing the variables which are supposed to be used
as x_i

@item @strong{Return:}
list l:
@*l[1]=the monomials from mon in the order used
@*l[2]=their coefficients after interreduction
@*l[3]=l[1]*l[2]

@item @strong{Purpose:}
Do interred only w.r.t. a subset of variables.
@*The procedure returns an interreduced system of generators of
sm considered as a k[t_1,..,t_s]-submodule of the free module
k[t_1,..,t_s]*mon[1]+..+k[t_1,..,t_s]*mon[size(mon)]).

@end table
@strong{Example:}
@smallexample
@c computed example subrInterred d2t_singular/poly_lib.doc:728
LIB "poly.lib";
ring r=0,(x,y,z),dp;
ideal i=x^2+x*y^2,x*y+x^2*y,z;
ideal j=x^2+x*y^2,x*y,z;
ideal mon=x^2,z,x*y;
intvec iv=1,3;
subrInterred(mon,i,iv);
@expansion{} [1]:
@expansion{}    _[1,1]=z
@expansion{}    _[1,2]=xy
@expansion{}    _[1,3]=x2
@expansion{} [2]:
@expansion{}    _[1]=gen(1)
@expansion{}    _[2]=y2*gen(2)-gen(2)
@expansion{}    _[3]=y*gen(2)+gen(3)
@expansion{} [3]:
@expansion{}    _[1,1]=z
@expansion{}    _[1,2]=xy3-xy
@expansion{}    _[1,3]=xy2+x2
subrInterred(mon,j,iv);
@expansion{} [1]:
@expansion{}    _[1,1]=z
@expansion{}    _[1,2]=xy
@expansion{}    _[1,3]=x2
@expansion{} [2]:
@expansion{}    _[1]=gen(1)
@expansion{}    _[2]=gen(2)
@expansion{}    _[3]=gen(3)
@expansion{} [3]:
@expansion{}    _[1,1]=z
@expansion{}    _[1,2]=xy
@expansion{}    _[1,3]=x2
@c end example subrInterred d2t_singular/poly_lib.doc:728
@end smallexample
@c ---end content subrInterred---

@c ------------------- hilbPoly -------------
@node hilbPoly,, subrInterred, poly_lib
@subsubsection hilbPoly
@cindex hilbPoly
@c ---content hilbPoly---
Procedure from library @code{poly.lib} (@pxref{poly_lib}).

@table @asis
@item @strong{Usage:}
hilbPoly(I) I a homogeneous ideal

@item @strong{Return:}
the Hilbert polynomial of basering/I as an intvec v=v_0,...,v_r
such that the Hilbert polynomial is (v_0+v_1*t+...v_r*t^r)/r!

@end table
@strong{Example:}
@smallexample
@c computed example hilbPoly d2t_singular/poly_lib.doc:759
LIB "poly.lib";
ring r = 0,(b,c,t,h),dp;
ideal I=
bct-t2h+2th2+h3,
bt3-ct3-t4+b2th+c2th-2bt2h+2ct2h+2t3h-bch2-2bth2+2cth2+2th3,
b2c2+bt2h-ct2h-t3h+b2h2+2bch2+c2h2-2bth2+2cth2+t2h2-2bh3+2ch3+2th3+3h4,
c2t3+ct4-c3th-2c2t2h-2ct3h-t4h+bc2h2-2c2th2-bt2h2+4t3h2+2bth3-2cth3-t2h3
+bh4-6th4-2h5;
hilbPoly(I);
@expansion{} -11,10
@c end example hilbPoly d2t_singular/poly_lib.doc:759
@end smallexample
@c ---end content hilbPoly---


code:
@c ---content LibInfo---
@comment This file was generated by doc2tex.pl from d2t_singular/presolve_lib.doc
@comment DO NOT EDIT DIRECTLY, BUT EDIT d2t_singular/presolve_lib.doc INSTEAD
@c library version: (1.17.2.7,2003/06/12)
@c library file: ../Singular/LIB/presolve.lib
@cindex presolve.lib
@cindex presolve_lib
@table @asis
@item @strong{Library:}
presolve.lib
@item @strong{Purpose:}
     Pre-Solving of Polynomial Equations
@item @strong{Author:}
Gert-Martin Greuel, email: greuel@@mathematik.uni-kl.de,

@end table

@strong{Procedures:}
@menu
* degreepart:: elements of id of total degree >= d1 and <= d2
* elimlinearpart:: linear part eliminated from id
* elimpart:: partial elimination of vars [among first n vars]
* elimpartanyr:: factors of p partially eliminated from i in any ring
* fastelim:: fast elimination of factors of p from i [options]
* findvars:: ideal of variables occurring in id [more information]
* hilbvec:: intvec of Hilbert-series of id [in char c and ord o]
* linearpart:: elements of id of total degree <=1
* tolessvars:: maps id to new basering having only vars occurring in id
* solvelinearpart:: reduced std-basis of linear part of id
* sortandmap:: map to new basering with vars sorted w.r.t. complexity
* sortvars:: sort vars w.r.t. complexity in id [different blocks]
* shortid:: generators of id having <= n terms
* valvars:: valuation of vars w.r.t. to their complexity in id
* idealSimplify:: eliminates variables which are linear in id
* idealSplit:: intersection of the ideals has the same radical as id
@end menu
@c ---end content LibInfo---

@c ------------------- degreepart -------------
@node degreepart, elimlinearpart,, presolve_lib
@subsubsection degreepart
@cindex degreepart
@c ---content degreepart---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
degreepart(id,d1,d2[,v]); id=ideal/module, d1,d1=integers, v=intvec

@item @strong{Return:}
generators of id of [v-weighted] total degree >= d1 and <= d2
(default: v = 1,...,1)

@end table
@strong{Example:}
@smallexample
@c reused example degreepart d2t_singular/presolve_lib.doc:55
LIB "presolve.lib";
ring r=0,(x,y,z),dp;
ideal i=1+x+x2+x3+x4,3,xz+y3+z8;
degreepart(i,0,4);
@expansion{} _[1]=x4+x3+x2+x+1
@expansion{} _[2]=3
module m=[x,y,z],x*[x3,y2,z],[1,x2,z3,0,1];
intvec v=2,3,6;
show(degreepart(m,8,8,v));
@expansion{} // module, 1 generator(s)
@expansion{} [x4,xy2,xz]
@c end example degreepart d2t_singular/presolve_lib.doc:55
@end smallexample
@c ---end content degreepart---

@c ------------------- elimlinearpart -------------
@node elimlinearpart, elimpart, degreepart, presolve_lib
@subsubsection elimlinearpart
@cindex elimlinearpart
@c ---content elimlinearpart---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
elimlinearpart(i[,n]); i=ideal, n=integer,@*
default: n=nvars(basering)

@item @strong{Return:}
list L with 5 entries:
  @format
  L[1]: (interreduced) ideal obtained from i by substituing
        from the first n variables those, which appear in a linear part
        of i, by putting this part into triangular form
  L[2]: ideal of variables which have been substituted
  L[3]: ideal, j-th element defines substitution of j-th var in [2]
  L[4]: ideal of variables of basering, eliminated ones are set to 0
  L[5]: ideal, describing the map from the basering to itself such that
        L[1] is the image of i
  @end format

@item @strong{Note:}
the procedure does always interreduce the ideal i internally w.r.t.
ordering dp.

@end table
@strong{Example:}
@smallexample
@c reused example elimlinearpart d2t_singular/presolve_lib.doc:99
LIB "presolve.lib";
ring s=0,(x,y,z),dp;
ideal i = x3+y2+z,x2y2+z3,y+z+1;
elimlinearpart(i);
@expansion{} [1]:
@expansion{}    _[1]=x3+z2+3z+1
@expansion{}    _[2]=x2z2+2x2z+z3+x2
@expansion{} [2]:
@expansion{}    _[1]=y
@expansion{} [3]:
@expansion{}    _[1]=y+z+1
@expansion{} [4]:
@expansion{}    _[1]=x
@expansion{}    _[2]=0
@expansion{}    _[3]=z
@expansion{} [5]:
@expansion{}    _[1]=x
@expansion{}    _[2]=-z-1
@expansion{}    _[3]=z
@c end example elimlinearpart d2t_singular/presolve_lib.doc:99
@end smallexample
@c ---end content elimlinearpart---

@c ------------------- elimpart -------------
@node elimpart, elimpartanyr, elimlinearpart, presolve_lib
@subsubsection elimpart
@cindex elimpart
@c ---content elimpart---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
elimpart(i [,n,e] ); i=ideal, n,e=integers
@*n : only the first n vars are considered for substitution,@*
e =0: substitute from linear part of i (same as elimlinearpart)@*
e!=0: eliminate also by direct substitution@*
(default: n = nvars(basering), e = 1)

@item @strong{Return:}
list of 5 objects:
  @format
  [1]: ideal obtained by substituting from the first n variables those
       from i, which appear in the linear part of i (or, if e!=0, which
       can be expressed directly in the remaining vars)
  [2]: ideal, variables which have been substituted
  [3]: ideal, i-th element defines substitution of i-th var in [2]
  [4]: ideal of variables of basering, substituted ones are set to 0
  [5]: ideal, describing the map from the basering, say k[x(1..m)], to
       itself onto k[..variables fom [4]..] and [1] is the image of i
  @end format
The ideal i is generated by [1] and [3] in k[x(1..m)], the map [5]
maps [3] to 0, hence induces an isomorphism
  @format
            k[x(1..m)]/i -> k[..variables fom [4]..]/[1]
  @end format

@item @strong{Note:}
If the basering has ordering (c,dp), this is faster for big ideals,
since it avoids internal ring change and mapping.

@end table
@strong{Example:}
@smallexample
@c reused example elimpart d2t_singular/presolve_lib.doc:148
LIB "presolve.lib";
ring s=0,(x,y,z),dp;
ideal i =x2+y2,x2+y+1;
elimpart(i,3,0);
@expansion{} [1]:
@expansion{}    _[1]=y2-y-1
@expansion{}    _[2]=x2+y+1
@expansion{} [2]:
@expansion{}    _[1]=0
@expansion{} [3]:
@expansion{}    _[1]=0
@expansion{} [4]:
@expansion{}    _[1]=x
@expansion{}    _[2]=y
@expansion{}    _[3]=z
@expansion{} [5]:
@expansion{}    _[1]=x
@expansion{}    _[2]=y
@expansion{}    _[3]=z
elimpart(i,3,1);
@expansion{} [1]:
@expansion{}    _[1]=x4+3x2+1
@expansion{} [2]:
@expansion{}    _[1]=y
@expansion{} [3]:
@expansion{}    _[1]=x2+y+1
@expansion{} [4]:
@expansion{}    _[1]=x
@expansion{}    _[2]=0
@expansion{}    _[3]=z
@expansion{} [5]:
@expansion{}    _[1]=x
@expansion{}    _[2]=-x2-1
@expansion{}    _[3]=z
@c end example elimpart d2t_singular/presolve_lib.doc:148
@end smallexample
@c ---end content elimpart---

@c ------------------- elimpartanyr -------------
@node elimpartanyr, fastelim, elimpart, presolve_lib
@subsubsection elimpartanyr
@cindex elimpartanyr
@c ---content elimpartanyr---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
elimpartanyr(i [,p,e] ); i=ideal, p=polynomial, e=integer@*
p: product of vars to be eliminated,@*
e =0: substitute from linear part of i (same as elimlinearpart)@*
e!=0: eliminate also by direct substitution@*
(default: p=product of all vars, e=1)

@item @strong{Return:}
list of 6 objects:
  @format
  [1]: (interreduced) ideal obtained by substituting from i those vars
       appearing in p, which occur in the linear part of i (or which can
       be expressed directly in the remaining variables, if e!=0)
  [2]: ideal, variables which have been substituted
  [3]: ideal, i-th element defines substitution of i-th var in [2]
  [4]: ideal of variables of basering, substituted ones are set to 0
  [5]: ideal, describing the map from the basering, say k[x(1..m)], to
       itself onto k[..variables fom [4]..] and [1] is the image of i
  [6]: int, # of vars considered for substitution (= # of factors of p)
  @end format
The ideal i is generated by [1] and [3] in k[x(1..m)], the map [5]
maps [3] to 0, hence induces an isomorphism
  @format
            k[x(1..m)]/i -> k[..variables fom [4]..]/[1]
  @end format

@item @strong{Note:}
the proc uses @code{execute} to create a ring with ordering dp and vars
placed correctly and then applies @code{elimpart}.

@end table
@strong{Example:}
@smallexample
@c reused example elimpartanyr d2t_singular/presolve_lib.doc:199
LIB "presolve.lib";
ring s=0,(x,y,z),dp;
ideal i = x3+y2+z,x2y2+z3,y+z+1;
elimpartanyr(i,z);
@expansion{} [1]:
@expansion{}    _[1]=x3+y2-y-1
@expansion{}    _[2]=x2y2-y3-3y2-3y-1
@expansion{} [2]:
@expansion{}    _[1]=z
@expansion{} [3]:
@expansion{}    _[1]=y+z+1
@expansion{} [4]:
@expansion{}    _[1]=0
@expansion{}    _[2]=x
@expansion{}    _[3]=y
@expansion{} [5]:
@expansion{}    _[1]=-y-1
@expansion{}    _[2]=x
@expansion{}    _[3]=y
@expansion{} [6]:
@expansion{}    1
@c end example elimpartanyr d2t_singular/presolve_lib.doc:199
@end smallexample
@c ---end content elimpartanyr---

@c ------------------- fastelim -------------
@node fastelim, findvars, elimpartanyr, presolve_lib
@subsubsection fastelim
@cindex fastelim
@c ---content fastelim---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=polynomial; h,o,a,b,e=integers
p: product of variables to be eliminated;@*
Optional parameters:
  @format
  - h !=0: use Hilbert-series driven std-basis computation
  - o !=0: use proc @code{valvars} for a - hopefully - optimal ordering of vars
  - a !=0: order vars to be eliminated w.r.t. increasing complexity
  - b !=0: order vars not to be eliminated w.r.t. increasing complexity
  - e !=0: use @code{elimpart} first to eliminate easy part
  - m !=0: compute a minimal system of generators
  @end format
(default: h,o,a,b,e,m = 0,1,0,0,0,0)

@item @strong{Return:}
ideal obtained from i by eliminating those variables, which occur in p

@end table
@strong{Example:}
@smallexample
@c reused example fastelim d2t_singular/presolve_lib.doc:236
LIB "presolve.lib";
ring s=31991,(e,f,x,y,z,t,u,v,w,a,b,c,d),dp;
ideal i = w2+f2-1, x2+t2+a2-1,  y2+u2+b2-1, z2+v2+c2-1,
d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
fastelim(i,xytua,1,1);       //with hilb,valvars
@expansion{} _[1]=f2+w2-1
@expansion{} _[2]=z2+v2+c2-1
@expansion{} _[3]=e2+d2-1
fastelim(i,xytua,1,0,1);     //with hilb,minbase
@expansion{} _[1]=z2+v2+c2-1
@expansion{} _[2]=f2+w2-1
@expansion{} _[3]=e2+d2-1
@c end example fastelim d2t_singular/presolve_lib.doc:236
@end smallexample
@c ---end content fastelim---

@c ------------------- findvars -------------
@node findvars, hilbvec, fastelim, presolve_lib
@subsubsection findvars
@cindex findvars
@c ---content findvars---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
findvars(id [,any] ); id=poly/ideal/vector/module/matrix, any=any type

@item @strong{Return:}
if no second argument is present: ideal of variables occurring in id,@*
if a second argument is given (of any type): list L with 4 entries:
  @format
  L[1]: ideal of variables occurring in id
  L[2]: intvec of variables occurring in id
  L[3]: ideal of variables not occurring in id
  L[4]: intvec of variables not occurring in id
  @end format

@end table
@strong{Example:}
@smallexample
@c reused example findvars d2t_singular/presolve_lib.doc:271
LIB "presolve.lib";
ring s  = 0,(e,f,x,y,t,u,v,w,a,d),dp;
ideal i = w2+f2-1, x2+t2+a2-1;
findvars(i);
@expansion{} _[1]=f
@expansion{} _[2]=x
@expansion{} _[3]=t
@expansion{} _[4]=w
@expansion{} _[5]=a
findvars(i,1);
@expansion{} [1]:
@expansion{}    _[1]=f
@expansion{}    _[2]=x
@expansion{}    _[3]=t
@expansion{}    _[4]=w
@expansion{}    _[5]=a
@expansion{} [2]:
@expansion{}    2,3,5,8,9
@expansion{} [3]:
@expansion{}    _[1]=e
@expansion{}    _[2]=y
@expansion{}    _[3]=u
@expansion{}    _[4]=v
@expansion{}    _[5]=d
@expansion{} [4]:
@expansion{}    1,4,6,7,10
@c end example findvars d2t_singular/presolve_lib.doc:271
@end smallexample
@c ---end content findvars---

@c ------------------- hilbvec -------------
@node hilbvec, linearpart, findvars, presolve_lib
@subsubsection hilbvec
@cindex hilbvec
@c ---content hilbvec---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
hilbvec(id[,c,o]); id=poly/ideal/vector/module/matrix, c,o=strings,@*
c=char, o=ordering used by @code{hilb}@*
(default: c="32003", o="dp")

@item @strong{Return:}
intvec of 1-st Hilbert-series of id, computed in char c and ordering o

@item @strong{Note:}
id must be homogeneous (i.e. all vars have weight 1)

@end table
@strong{Example:}
@smallexample
@c reused example hilbvec d2t_singular/presolve_lib.doc:303
LIB "presolve.lib";
ring s   = 0,(e,f,x,y,z,t,u,v,w,a,b,c,d,H),dp;
ideal id = w2+f2-1, x2+t2+a2-1,  y2+u2+b2-1, z2+v2+c2-1,
d2+e2-1, f4+2u, wa+tf, xy+tu+ab;
id = homog(id,H);
hilbvec(id);
@expansion{} 1,0,-7,0,20,0,-28,0,14,0,14,0,-28,0,20,0,-7,0,1,0
@c end example hilbvec d2t_singular/presolve_lib.doc:303
@end smallexample
@c ---end content hilbvec---

@c ------------------- linearpart -------------
@node linearpart, tolessvars, hilbvec, presolve_lib
@subsubsection linearpart
@cindex linearpart
@c ---content linearpart---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
linearpart(id); id=ideal/module

@item @strong{Return:}
generators of id of total degree <= 1

@end table
@strong{Example:}
@smallexample
@c reused example linearpart d2t_singular/presolve_lib.doc:331
LIB "presolve.lib";
ring r=0,(x,y,z),dp;
ideal i=1+x+x2+x3,3,x+3y+5z;
linearpart(i);
@expansion{} _[1]=3
@expansion{} _[2]=x+3y+5z
module m=[x,y,z],x*[x3,y2,z],[1,x2,z3,0,1];
show(linearpart(m));
@expansion{} // module, 1 generator(s)
@expansion{} [x,y,z]
@c end example linearpart d2t_singular/presolve_lib.doc:331
@end smallexample
@c ---end content linearpart---

@c ------------------- tolessvars -------------
@node tolessvars, solvelinearpart, linearpart, presolve_lib
@subsubsection tolessvars
@cindex tolessvars
@c ---content tolessvars---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
tolessvars(id [,s1,s2] ); id poly/ideal/vector/module/matrix,
s1,s2=strings@*
s1: name of new ring,@*
s2: new ordering@*
(default: s1="R(n)" where n is the # of vars in the new ring,
s2="dp" or "ds" depending whether the first block of the old
ordering is a p- resp. an s-ordering)

@item @strong{Create:}
nothing, if id contains all vars of the basering.@*
Else, create a ring with same char as the basering, but possibly less
variables (only those variables which actually occur in id) and map
id to the new ring, which will be the basering after the proc has
finished.

@item @strong{Display:}
If printlevel >=0, display ideal of vars, which have been omitted from
the old ring

@item @strong{Return:}
the original ideal id (see NOTE)

@item @strong{Note:}
You must not type, say, 'ideal id=tolessvars(id);' since the ring
to which 'id' would belong will only be defined by the r.h.s.. But you
may type 'def id=tolessvars(id);' or 'list id=tolessvars(id);'
since then 'id' does not a priory belong to a ring, its type will
be defined by the right hand side. Moreover, do not use a name which
occurs in the old ring, for the same reason.

@end table
@strong{Example:}
@smallexample
@c reused example tolessvars d2t_singular/presolve_lib.doc:384
LIB "presolve.lib";
ring r  = 0,(x,y,z),dp;
ideal i = y2-x3,x-3,y-2x;
def j   = tolessvars(i,"R_r","lp");
@expansion{}
@expansion{} // variables which did not occur:
@expansion{} z
@expansion{} // basering is now R_r
show(basering);
@expansion{} // ring: (0),(x,y),(lp(2),C);
@expansion{} // minpoly = 0
@expansion{} // objects belonging to this ring:
@expansion{} // j                    [0]  ideal, 3 generator(s)
j;
@expansion{} j[1]=-x3+y2
@expansion{} j[2]=x-3
@expansion{} j[3]=-2x+y
kill R_r;
@c end example tolessvars d2t_singular/presolve_lib.doc:384
@end smallexample
@c ---end content tolessvars---

@c ------------------- solvelinearpart -------------
@node solvelinearpart, sortandmap, tolessvars, presolve_lib
@subsubsection solvelinearpart
@cindex solvelinearpart
@c ---content solvelinearpart---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
solvelinearpart(id [,n] ); id=ideal/module, n=integer,@*
(default: n=0)

@item @strong{Return:}
(interreduced) generators of id of degree <=1 in reduced triangular
form if n=0 [non-reduced triangular form if n!=0]

@item @strong{Assume:}
monomial ordering is a global ordering (p-ordering)

@item @strong{Note:}
may be used to solve a system of linear equations
see proc @code{gauss_row} from 'matrix.lib' for a different method

@item @strong{Warning:}
the result is very likely to be false for 'real' coefficients, use
char 0 instead!

@end table
@strong{Example:}
@smallexample
@c reused example solvelinearpart d2t_singular/presolve_lib.doc:426
LIB "presolve.lib";
// Solve the system of linear equations:
//         3x +   y +  z -  u = 2
//         3x +  8y + 6z - 7u = 1
//        14x + 10y + 6z - 7u = 0
//         7x +  4y + 3z - 3u = 3
ring r = 0,(x,y,z,u),lp;
ideal i= 3x +   y +  z -  u,
13x +  8y + 6z - 7u,
14x + 10y + 6z - 7u,
7x +  4y + 3z - 3u;
ideal j= 2,1,0,3;
j = i-j;                        // difference of 1x4 matrices
// compute reduced triangular form, setting
solvelinearpart(j);             // the RHS equal 0 gives the solutions!
@expansion{} _[1]=u-4
@expansion{} _[2]=z-4
@expansion{} _[3]=y+1
@expansion{} _[4]=x-1
solvelinearpart(j,1); "";       // triangular form, not reduced
@expansion{} _[1]=u-4
@expansion{} _[2]=3z-8u+20
@expansion{} _[3]=18y-6z+7u+14
@expansion{} _[4]=13x+8y+6z-7u-1
@expansion{}
@c end example solvelinearpart d2t_singular/presolve_lib.doc:426
@end smallexample
@c ---end content solvelinearpart---

@c ------------------- sortandmap -------------
@node sortandmap, sortvars, solvelinearpart, presolve_lib
@subsubsection sortandmap
@cindex sortandmap
@c ---content sortandmap---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);@*
id=poly/ideal/vector/module,@*
s1,s2 = strings (names for new ring and mapped id),@*
p1,p2,...= polynomials (product of variables),@*
n1,n2,...= integers,@*
o1,o2,...= strings,@*
m1,m2,...= integers@*
(default: p1=product of all vars, n1=0, o1="dp",m1=0)
@*the last pi (containing the remaining vars) may be omitted

@item @strong{Create:}
a new ring and map id into it, the new ring has same char as basering
but with new ordering and vars sorted in the following manner:
  @format
  - each block of vars occurring in pi is sorted w.r.t. its complexity in id,
  - ni controls the sorting in i-th block (= vars occurring in pi):
    ni=0 (resp.!=0) means that less (resp. more) complex vars come first
  - oi and mi define the monomial ordering of the i-th block:
    if mi =0, oi=ordstr(i-th block)
    if mi!=0, the ordering of the i-th block itself is a blockordering,
      each subblock having ordstr=oi, such that vars of same complexity are
      in one block
  @end format
Note that only simple ordstrings oi are allowed:
@*"lp","dp","Dp","ls","ds","Ds".

@item @strong{Return:}
nothing

@item @strong{Note:}
We define a variable x to be more complex than y (with respect to id)
if val(x) > val(y) lexicographically, where val(x) denotes the
valuation vector of x:@*
consider id as list of polynomials in x with coefficients in the
remaining variables. Then:@*
val(x) = (maximal occurring power of x, # of all monomials in leading
coefficient, # of all monomials in coefficient of next smaller power
of x,...).

@end table
@strong{Example:}
@smallexample
@c reused example sortandmap d2t_singular/presolve_lib.doc:498
LIB "presolve.lib";
ring s = 32003,(x,y,z),dp;
ideal i=x3+y2,xz+z2;
sortandmap(i,"R_r","i");
// i is now an ideal in the new basering R_r
show(R_r);
@expansion{} // ring: (32003),(y,z,x),(dp(3),C);
@expansion{} // minpoly = 0
@expansion{} // objects belonging to this ring:
@expansion{} // i                    [0]  ideal, 2 generator(s)
kill R_r; setring s;
sortandmap(i,"R_r","i",1,xy,0,z,0,"ds",0,"lp",0);
show(R_r);
@expansion{} // ring: (32003),(x,y,z),(ds(2),lp(1),C);
@expansion{} // minpoly = 0
@expansion{} // objects belonging to this ring:
@expansion{} // i                    [0]  ideal, 2 generator(s)
kill R_r;
@c end example sortandmap d2t_singular/presolve_lib.doc:498
@end smallexample
@c ---end content sortandmap---

@c ------------------- sortvars -------------
@node sortvars, shortid, sortandmap, presolve_lib
@subsubsection sortvars
@cindex sortvars
@c ---content sortvars---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
sortvars(id[,n1,p1,n2,p2,...]);@*
id=poly/ideal/vector/module,@*
p1,p2,...= polynomials (product of vars),@*
n1,n2,...=integers@*
(default: p1=product of all vars, n1=0)
@*the last pi (containing the remaining vars) may be omitted

@item @strong{Compute:}
sort variables with respect to their complexity in id

@item @strong{Return:}
list of two elements, an ideal and a list:
  @format
  [1]: ideal, variables of basering sorted w.r.t their complexity in id
       ni controls the ordering in i-th block (= vars occurring in pi):
       ni=0 (resp.!=0) means that less (resp. more) complex vars come first
  [2]: a list with 4 entries for each pi:
       ideal ai : vars of pi in correct order,
       intvec vi: permutation vector describing the ordering in ai,
       intmat Mi: valuation matrix of ai, the columns of Mi being the
                  valuation vectors of the vars in ai
       intvec wi: size of 1-st, 2-nd,... block of identical columns of Mi
                  (vars with same valuation)
  @end format

@item @strong{Note:}
We define a variable x to be more complex than y (with respect to id)
if val(x) > val(y) lexicographically, where val(x) denotes the
valuation vector of x:@*
consider id as list of polynomials in x with coefficients in the
remaining variables. Then:@*
val(x) = (maximal occurring power of x, # of all monomials in leading
coefficient, # of all monomials in coefficient of next smaller power
of x,...).

@end table
@strong{Example:}
@smallexample
@c reused example sortvars d2t_singular/presolve_lib.doc:560
LIB "presolve.lib";
ring s=0,(x,y,z,w),dp;
ideal i = x3+y2+yw2,xz+z2,xyz-w2;
sortvars(i,0,xy,1,zw);
@expansion{} [1]:
@expansion{}    _[1]=y
@expansion{}    _[2]=x
@expansion{}    _[3]=w
@expansion{}    _[4]=z
@expansion{} [2]:
@expansion{}    [1]:
@expansion{}       _[1]=y
@expansion{}       _[2]=x
@expansion{}    [2]:
@expansion{}       2,1
@expansion{}    [3]:
@expansion{}       2,3,
@expansion{}       1,1,
@expansion{}       2,0,
@expansion{}       0,2
@expansion{}    [4]:
@expansion{}       1,1
@expansion{}    [5]:
@expansion{}       _[1]=w
@expansion{}       _[2]=z
@expansion{}    [6]:
@expansion{}       2,1
@expansion{}    [7]:
@expansion{}       2,2,
@expansion{}       2,1,
@expansion{}       0,2
@expansion{}    [8]:
@expansion{}       1,1
@c end example sortvars d2t_singular/presolve_lib.doc:560
@end smallexample
@c ---end content sortvars---

@c ------------------- shortid -------------
@node shortid, valvars, sortvars, presolve_lib
@subsubsection shortid
@cindex shortid
@c ---content shortid---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
shortid(id,n[,e]); id= ideal/module, n,e=integers

@item @strong{Return:}
- if called with two arguments or e=0:
@* same type as id, containing generators of id having <= n terms.
@* - if called with three arguments and e!=0:
@* a list L:
@* L[1]: same type as id, containing generators of id having <= n terms.
@* L[2]: number of corresponding generator of id

@item @strong{Note:}
May be used to compute partial standard basis in case id is to hard

@end table
@strong{Example:}
@smallexample
@c reused example shortid d2t_singular/presolve_lib.doc:594
LIB "presolve.lib";
ring s=0,(x,y,z,w),dp;
ideal i = (x3+y2+yw2)^2,(xz+z2)^2,xyz-w2-xzw;
shortid(i,3);
@expansion{} _[1]=x2z2+2xz3+z4
@expansion{} _[2]=xyz-xzw-w2
@c end example shortid d2t_singular/presolve_lib.doc:594
@end smallexample
@c ---end content shortid---

@c ------------------- valvars -------------
@node valvars, idealSimplify, shortid, presolve_lib
@subsubsection valvars
@cindex valvars
@c ---content valvars---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
valvars(id[,n1,p1,n2,p2,...]);@*
id=poly/ideal/vector/module,@*
p1,p2,...= polynomials (product of vars),@*
n1,n2,...= integers,

ni controls the ordering of vars occurring in pi: ni=0 (resp.!=0) means
that less (resp. more) complex vars come first@*
(default: p1=product of all vars, n1=0)
@*the last pi (containing the remaining vars) may be omitted

@item @strong{Compute:}
valuation (complexity) of variables with respect to id.@*
ni controls the ordering of vars occurring in pi:@*
ni=0 (resp.!=0) means that less (resp. more) complex vars come first.

@item @strong{Return:}
list with 3 entries:
  @format
  [1]: intvec, say v, describing the permutation such that the permuted
       ringvariables are ordered with respect to their complexity in id
  [2]: list of intvecs, i-th intvec, say v(i) describing permutation
       of vars in a(i) such that v=v(1),v(2),...
  [3]: list of ideals and intmat's, say a(i) and M(i), where
       a(i): factors of pi,
       M(i): valuation matrix of a(i), such that the j-th column of M(i)
             is the valuation vector of j-th generator of a(i)
         @end format

@item @strong{Note:}
Use @code{sortvars} in order to actually sort the variables!
We define a variable x to be more complex than y (with respect to id)
if val(x) > val(y) lexicographically, where val(x) denotes the
valuation vector of x:@*
consider id as list of polynomials in x with coefficients in the
remaining variables. Then:@*
val(x) = (maximal occurring power of x, # of all monomials in leading
coefficient, # of all monomials in coefficient of next smaller power
of x,...).

@end table
@strong{Example:}
@smallexample
@c reused example valvars d2t_singular/presolve_lib.doc:654
LIB "presolve.lib";
ring s=0,(x,y,z,a,b),dp;
ideal i=ax2+ay3-b2x,abz+by2;
valvars (i,0,xyz);
@expansion{} [1]:
@expansion{}    3,1,2,4,5
@expansion{} [2]:
@expansion{}    [1]:
@expansion{}       3,1,2
@expansion{}    [2]:
@expansion{}       1,2
@expansion{} [3]:
@expansion{}    [1]:
@expansion{}       _[1]=x
@expansion{}       _[2]=y
@expansion{}       _[3]=z
@expansion{}    [2]:
@expansion{}       2,3,1,
@expansion{}       1,1,1,
@expansion{}       1,1,0
@expansion{}    [3]:
@expansion{}       _[1]=a
@expansion{}       _[2]=b
@expansion{}    [4]:
@expansion{}       1,2,
@expansion{}       3,1,
@expansion{}       0,2
@c end example valvars d2t_singular/presolve_lib.doc:654
@end smallexample
@c ---end content valvars---

@c ------------------- idealSimplify -------------
@node idealSimplify, idealSplit, valvars, presolve_lib
@subsubsection idealSimplify
@cindex idealSimplify
@c ---content idealSimplify---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
idealSimplify(id); id ideal

@item @strong{Return:}
ideal I = eliminate(Id,m) m is a product of variables
which are only linearly involved in the generators of id

@end table
@strong{Example:}
@smallexample
@c reused example idealSimplify d2t_singular/presolve_lib.doc:681
LIB "presolve.lib";
ring r=0,(x,y,z,w,t),dp;
ideal i=
t,
x3+y2+2z,
x2+3y,
x2+y2+z2,
w2+z;
ideal j=idealSimplify(i);
ideal k=eliminate(i,zyt);
reduce(k,std(j));
@expansion{} _[1]=0
@expansion{} _[2]=0
reduce(j,std(k));
@expansion{} _[1]=0
@expansion{} _[2]=0
@c end example idealSimplify d2t_singular/presolve_lib.doc:681
@end smallexample
@c ---end content idealSimplify---

@c ------------------- idealSplit -------------
@node idealSplit,, idealSimplify, presolve_lib
@subsubsection idealSplit
@cindex idealSplit
@c ---content idealSplit---
Procedure from library @code{presolve.lib} (@pxref{presolve_lib}).

@table @asis
@item @strong{Usage:}
idealSplit(id,timeF,timeS); id ideal and optional
@*timeF ,timeS integers to bound the time which can be used
for factorization resp. standard basis computation

@item @strong{Return:}
a list of ideals such that their intersection
@*has the same radical as id

@end table
@strong{Example:}
@smallexample
@c reused example idealSplit d2t_singular/presolve_lib.doc:718
LIB "presolve.lib";
ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
ideal i=
bv+su,
bw+tu,
sw+tv,
by+sx,
bz+tx,
sz+ty,
uy+vx,
uz+wx,
vz+wy,
bvz;
idealSplit(i);
@expansion{} [1]:
@expansion{}    _[1]=x
@expansion{}    _[2]=u
@expansion{}    _[3]=t
@expansion{}    _[4]=s
@expansion{}    _[5]=b
@expansion{}    _[6]=wy+vz
@expansion{} [2]:
@expansion{}    _[1]=z
@expansion{}    _[2]=w
@expansion{}    _[3]=t
@expansion{}    _[4]=s
@expansion{}    _[5]=b
@expansion{}    _[6]=vx+uy
@expansion{} [3]:
@expansion{}    _[1]=z
@expansion{}    _[2]=x
@expansion{}    _[3]=w
@expansion{}    _[4]=u
@expansion{}    _[5]=t
@expansion{}    _[6]=b
@expansion{} [4]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=x
@expansion{}    _[4]=t
@expansion{}    _[5]=s
@expansion{}    _[6]=b
@expansion{} [5]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=x
@expansion{}    _[4]=u
@expansion{}    _[5]=b
@expansion{}    _[6]=tv+sw
@expansion{} [6]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=x
@expansion{}    _[4]=w
@expansion{}    _[5]=t
@expansion{}    _[6]=su+bv
@expansion{} [7]:
@expansion{}    _[1]=w
@expansion{}    _[2]=v
@expansion{}    _[3]=u
@expansion{}    _[4]=t
@expansion{}    _[5]=s
@expansion{}    _[6]=b
@expansion{} [8]:
@expansion{}    _[1]=x
@expansion{}    _[2]=w
@expansion{}    _[3]=v
@expansion{}    _[4]=u
@expansion{}    _[5]=b
@expansion{}    _[6]=ty+sz
@expansion{} [9]:
@expansion{}    _[1]=z
@expansion{}    _[2]=w
@expansion{}    _[3]=v
@expansion{}    _[4]=u
@expansion{}    _[5]=t
@expansion{}    _[6]=sx+by
@expansion{} [10]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=x
@expansion{}    _[4]=w
@expansion{}    _[5]=v
@expansion{}    _[6]=u
@expansion{} [11]:
@expansion{}    _[1]=y
@expansion{}    _[2]=v
@expansion{}    _[3]=t
@expansion{}    _[4]=s
@expansion{}    _[5]=b
@expansion{}    _[6]=wx+uz
@expansion{} [12]:
@expansion{}    _[1]=y
@expansion{}    _[2]=x
@expansion{}    _[3]=v
@expansion{}    _[4]=u
@expansion{}    _[5]=s
@expansion{}    _[6]=b
@expansion{} [13]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=x
@expansion{}    _[4]=v
@expansion{}    _[5]=s
@expansion{}    _[6]=tu+bw
@expansion{} [14]:
@expansion{}    _[1]=z
@expansion{}    _[2]=y
@expansion{}    _[3]=w
@expansion{}    _[4]=v
@expansion{}    _[5]=t
@expansion{}    _[6]=s
@expansion{} [15]:
@expansion{}    _[1]=y
@expansion{}    _[2]=w
@expansion{}    _[3]=v
@expansion{}    _[4]=u
@expansion{}    _[5]=s
@expansion{}    _[6]=tx+bz
@c end example idealSplit d2t_singular/presolve_lib.doc:718
@end smallexample
@c ---end content idealSplit---