
D.8.3.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 0dimensional;
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 0dim. 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)^tx(d)^s+p;
for (i=d1; i>0; i) { I=x(i)^tx(i)^s+p,I; }
I;
==> I[1]=x(1)^3+x(2)^2+x(3)^2+x(4)^21
==> I[2]=x(2)^3+x(1)^2+x(3)^2+x(4)^21
==> I[3]=x(3)^3+x(1)^2+x(2)^2+x(4)^21
==> I[4]=x(4)^3+x(1)^2+x(2)^2+x(3)^21
// 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.766044i*0.477895)
==> [4]:
==> (0.766044i*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

