Home Online Manual
Top
Back: laguerre_solve
Forward: ures_solve
FastBack:
FastForward:
Up: solve_lib
Top: Singular Manual
Contents: Table of Contents
Index: Index
About: About this document

D.8.4.2 solve

Procedure from library solve.lib (see solve_lib).

Usage:
solve(G [, m, n [, l]] [,"oldring"] [,"nodisplay"] ); G = ideal, m, n, l = integers (control parameters of the method), outR ring,
m: precision of output in digits ( 4 <= m) and of the generated ring of complex numbers;
n: control of multiplicity
n = 0, return all different roots
n != 0, find all roots (with multiplicity)
l: precision of internal computation in decimal digits ( l >=8 ) only if the basering is not complex or complex with smaller precision,
[default: (m,n,l) = (8,0,30), or if only (m,n) are set explicitly with n!=0, then (m,n,l) = (m,n,60) ]

Assume:
the ideal is 0-dimensional;
basering has characteristic 0 and is either complex or without parameters;

Return:
(1) If called without the additional parameter "oldring":
ring R with the same number of variables but with complex coefficients (and precision m). R comes with a list SOL of numbers, in which complex roots of G are stored:
* If n = 0, SOL is the list of all different solutions, each of them being represented by a list of numbers.
* If n != 0, SOL is a list of two list: SOL[i][1] is the list of all different solutions with the multiplicity SOL[i][2].
SOL is ordered w.r.t. multiplicity (the smallest first).
(2) If called with the additional parameter "oldring", the procedure looks for an appropriate ring (at top level) in which the solutions can be stored (interactive).
The user may then select an appropriate ring and choose a name for the output list in this ring. The list is exported directly to the selected ring and the return value is a string "result exported to" + name of the selected ring.

Note:
If the problem is not 0-dim. the procedure stops with ERROR. If the ideal G is not a lexicographic Groebner basis, the lexicographic Groebner basis is computed internally (Hilbert driven).
The computed solutions are displayed, unless solve is called with the additional parameter "nodisplay".

Example:
 
LIB "solve.lib";
// Find all roots of a multivariate ideal using triangular sets:
int d,t,s = 4,3,2 ;
int i;
ring A=0,x(1..d),dp;
poly p=-1;
for (i=d; i>0; i--) { p=p+x(i)^s; }
ideal I = x(d)^t-x(d)^s+p;
for (i=d-1; i>0; i--) { I=x(i)^t-x(i)^s+p,I; }
I;
==> I[1]=x(1)^3+x(2)^2+x(3)^2+x(4)^2-1
==> I[2]=x(2)^3+x(1)^2+x(3)^2+x(4)^2-1
==> I[3]=x(3)^3+x(1)^2+x(2)^2+x(4)^2-1
==> I[4]=x(4)^3+x(1)^2+x(2)^2+x(3)^2-1
// the multiplicity is
vdim(std(I));
==> 81
def AC=solve(I,6,0,"nodisplay");  // solutions should not be displayed
==> 
==> // 'solve' created a ring, in which a list SOL of numbers (the complex so\
   lutions)
==> // is stored.
==> // To access the list of complex solutions, type (if the name R was assig\
   ned
==> // to the return value):
==>         setring R; SOL; 
// list of solutions is stored in AC as the list SOL (default name)
setring AC;
size(SOL);               // number of different solutions
==> 37
SOL[5];                  // the 5th solution
==> [1]:
==> 0.587401
==> [2]:
==> -0.32748
==> [3]:
==> 0.587401
==> [4]:
==> 0.587401
// you must start with char. 0
setring A;
def AC1=solve(I,6,1,"nodisplay");
==> 
==> // 'solve' created a ring, in which a list SOL of numbers (the complex so\
   lutions)
==> // is stored.
==> // To access the list of complex solutions, type (if the name R was assig\
   ned
==> // to the return value):
==>         setring R; SOL; 
setring AC1;
size(SOL);               // number of different multiplicities
==> 2
SOL[1][1][1];            // a solution with
==> [1]:
==> (0.766044+i*0.477895)
==> [2]:
==> (0.766044+i*0.477895)
==> [3]:
==> (0.766044-i*0.477895)
==> [4]:
==> (0.766044-i*0.477895)
SOL[1][2];               // multiplicity 1
==> 1
SOL[2][1][1];            // a solution with
==> [1]:
==> 0
==> [2]:
==> 0
==> [3]:
==> 1
==> [4]:
==> 0
SOL[2][2];               // multiplicity 12
==> 12
// the number of different solutions is equal to
size(SOL[1][1])+size(SOL[2][1]);
==> 37
// the number of complex solutions (counted with multiplicities) is
size(SOL[1][1])*SOL[1][2]+size(SOL[2][1])*SOL[2][2];
==> 81