[CLO] 	David Cox John Little Donal O’Shea, Ideals, Varieties, and Algorithms.
	An Introduction to Computational Algebraic
	Geometry and Commutative Algebra
	Fourth Edition Springer-Verlag, 2015.

Singular

Il programma Singular viene lanciato da un terminale con il comando 
"Singular".

Tipi di data:
	int, intvec, intmat,
        list,
	string,
	ring, number, poly, vector, matrix, ideal, qring, map,
	module,
	def, link, resolution,
	proc, ...

Anelli di polinomi (coefficienti, variabili, ordine monomiale):

coefficienti
	Q: (0)
        R, piu' precisamente numeri floating point con 50 cifre 
	dopo la virgola decimale: (real,50)

> ring r = (real,50),x,dp;
> 101/3;
33.66666666666666666666666666666666666666666666666667

	Z/5: ring r = 5,x,dp;

variabili
	(x,y,z), (x(1..3)) con le variabili x(1), x(2),x(3)

ordini monomiali: 
    ordine lessicografico lp, 	1 0 0
				0 1 0
				0 0 1
    lessicografico graduato Dp,	1 1 1
				1 0 0
				0 1 0
    lessicografico graduato inverso dp	1  1  1
					0  0 -1
					0 -1  0
ad esempio:
ring r = 0, (x,y,z), M(1, 0, 0,   0, 1, 0,   0, 0, 1);
// Q[x,y,z] con ordine lessicografico x > y > z > 1


// algoritmo di divisione (differisce da quello di [CLO])
	ring r=0,(x,y),lp;
	poly f=x*y^2+1;
	poly f1=x*y+1;
	poly f2=y+1;
	ideal F=f;
	ideal G=f1,f2;
	list q = division (F,G);
f - q[1][1,1]*f1-q[1][2,1]*f2 - q[2]; \\ q[2] = resto
poly g = 4*x*y^2+1;
lead(g);
leadmonom(g);

////////////////////////////////////////////////////////////////
/ Esempio di una procedura (che somma i numeri naturali fino ad n):

proc somman (int n)  // somman(n) = 0 + 1 + 2 + ... + n
{
int s=0;
int i;
for (i=1; i<=n; i=i+1)
{
s=s+i;
};
return(s);
};

/////////////////////////////////////////////////////////////////

Basi di Groebner, alcunicomandi importanti: 
	groebner
	std
	option(redSB)
        option(noredSB)

// [CLO, pag. 50]
ring R =0, (x(1..3)), lp;
ideal I = 2*x(1) + 3*x(2) - x(3), x(1) + x(2) -1, x(1) + x(3) -3;
std(I);

// [CLO, pag. 90]
ring R = 0, (x,y), Dp;
poly f1 = x^3 - 2*x*y;
poly f2 = x^2*y - 2*y^2 + x;
ideal I = f1, f2;
groebner(I);

// resto rispetto ad una base di Groebner: reduce(f,I)
ring r = complex,(x,y,z),Dp;
poly f = -4*x^2*y^2*z^2+y^6+3*z^5;
poly f1=x*z-y^2; poly f2=x^3-z^2;
ideal I =f1,f2;
ideal GI = std(I);
reduce(f,GI);

// S-polinomio: (pag. 85)
LIB "teachstd.lib";
ring r=0,(x,y),lp;
poly f=x^3*y^2-x^2*y^3+x; 
poly g=3*x^4*y+y^2; 
spoly(f,g);

ring S = 0,(x,y,z),lp;
ideal J = x^10 + y^8*z^2 + z^10,x*y + y^2 + z^2;
std(J);
ring S1 = 0,(x,y,z),dp;
ideal J1 = imap(S,J); 
// il comando imap(S,J) serve a portare l'ideale J dall'anello S 
// nell'anello attivo S1;
std(J1);

///////////////////////////////////////////////////////////////////

LIB "surf.lib";
ring R = 0,(x,y),dp;
ideal J = x^3-y^2;
plot(J);
ring R = 0,(x,y,z),dp;
// superficie romana di Steiner 1844
ideal J = x^2*y^2+x^2*z^2+y^2*z^2-17*x*y*z;
surfer(J);

/////////////////////////////////////////////////////////////////////

/ Eliminazione:

LIB "elim.lib";
ring r = complex, (x,y,z), lp;
ideal I = x^2+y+z-1, x+y^2+z-1, x+y+z^2-1;
elim(I,(1));
elim(I,(1..2));



============================================================
CoCoA - Computations in Commutative Algebra
(pp. 611-612)

Il programma CoCoA viene lanciato da un terminale con il comando
"cocoa5".

use R ::= QQ[x,y], Lex;   // DegRevLex, DegLex
I := ideal(xˆ2 + y,2*x*y + yˆ2);
F := 2*x*y + yˆ2;
GB := GBasis(I);   // ReducedGBasis
K := NewFractionField(NewPolynomialRing(QQ,["a"]));
use R ::= K[x,y];
LM(F);
LT(F);
LC(F);
LPP(F);

//////////////////////////////////////////////////////
/ Procedura (funzione) per calcolare s-polinomi ([CLO, pag. 85]):

Define spoly(f,g);
xgamma := lcm(LT(f),LT(g));
Return (xgamma/LM(f))*f - (xgamma/LM(g))*g;
EndDefine;

///////////////////////////////////////////////////////
/ [CLO, pag. 90]

use R ::= QQ[x,y], DegLex;
f1 := x^3 - 2*x*y;
f2 := x^2*y - 2*y^2 + x;
I := ideal(f1,f2);
G := GBasis(I);
G;
                              ________F   
NR(spoly(f1,f2),[f1,f2]); // S(f1,f2)  con  F=[f1,f2]