# Singular

#### 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 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 ```