[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56. grobner


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.1 Introducción a grobner

grobner es un paquete para operar con bases de Groebner en Maxima.

Para hacer uso de las funciones de este paquete es necesario cargar previamente el archivo `grobner.lisp':

load(grobner);

Es posible ejecutar una demostración haciendo

demo("grobner.demo");

o

batch("grobner.demo")

Algunos de los cálculos de la demostración pueden llevar tiempo, razón por la cual sus resultados se han guardado en el archivo `grobner-demo.output', que se encuentra en el mismo directorio que el archivo de demostración.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.1.1 Notas sobre el paquete grobner

El autor del paquete es

Marek Rychlik

http://alamos.math.arizona.edu

habiendo sido distribuido el 24-05-2002 bajo los términos de la General Public License (GPL) (ver archivo `grobner.lisp'). Esta documentación ha sido extraída de los archivos

`README', `grobner.lisp', `grobner.demo' y `grobner-demo.output'

por Günter Nowak. Las sugerencias para mejorar la documentación se pueden hacer en la lista de correos de maxima, maxima@math.utexas.edu.

El código está algo anticuado. Las implementaciones modernas utilizan el algoritmo F4, más rápido, descrito en

 
A new efficient algorithm for computing Gröbner bases (F4) 
Jean-Charles Faugère
LIP6/CNRS Université Paris VI 
January 20, 1999

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.1.2 Implementaciones de órdenes admisibles de monomios


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.2 Funciones y variables para grobner


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.2.1 Variables opcionales

Variable opcional: poly_monomial_order

Valor por defecto: lex

Controla qué orden de monomios utiliza en los cálculos con polinomios y bases de Groebner. Si no se le asigna valor alguno, se utilizará lex.

Variable opcional: poly_coefficient_ring

Valor por defecto: expression_ring

Indica el anillo de coeficientes de los polinomios que se va a utilizar en los cálculos. Si no se le asigna ningún valor, se utilizará el anillo de expresiones propio de maxima. A esta variable se le puede asignar el valor ring_of_integers.

Variable opcional: poly_primary_elimination_order

Valor por defecto: false

Nombre del orden por defecto para las variables eliminadas en las funciones basadas en eliminaciones. Si no se le asigna ningún valor, se utilizará lex.

Variable opcional: poly_secondary_elimination_order

Valor por defecto: false

Nombre del orden por defecto para las variables almacenadas en funciones basadas en eliminaciones. Si no se le asigna ningún valor, se utilizará lex.

Variable opcional: poly_elimination_order

Valor por defecto: false

Nombre del orden de eliminación por defecto utilizado en los cálculos de eliminación. Si se le asigna un valor, ignorará los guardados en poly_primary_elimination_order y poly_secondary_elimination_order. El usuario se asegurará que este es un orden válido de eliminación.

Variable opcional: poly_return_term_list

Valor por defecto: false

Si vale true, todas las funciones de este paquete devolverán los polinomios como una lista de términos en el orden activo de monomios, en lugar de una expresión ordinaria de maxima.

Variable opcional: poly_grobner_debug

Valor por defecto: false

Si vale true, genera una salida de seguimiento y depuración.

Variable opcional: poly_grobner_algorithm

Valor por defecto: buchberger

Valores posibles:

Es el nombre del algoritmo utilizado para encontrar las bases de Groebner.

Variable opcional: poly_top_reduction_only

Valor por defecto: false

Si no vale false, siempre que sea posible el algoritmo de división se detendrá tras la primera reducción.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.2.2 Operadores simples

poly_add, poly_subtract, poly_multiply y poly_expt son los operadores aritméticos para polinomios. Se ejecutan utilizando la representación interna, pero los resultados se devuelven en forma de expresión ordinaria de maxima.

Función: poly_add (poly1, poly2, varlist)

Suma los polinomios poly1 y poly2.

(%i1) poly_add(z+x^2*y,x-z,[x,y,z]);
                                    2
(%o1)                              x  y + x
Función: poly_subtract (poly1, poly2, varlist)

Resta el polinomio poly2 de poly1.

(%i1) poly_subtract(z+x^2*y,x-z,[x,y,z]);
                                      2
(%o1)                          2 z + x  y - x
Función: poly_multiply (poly1, poly2, varlist)

Multiplica poly1 por poly2.

(%i2) poly_multiply(z+x^2*y,x-z,[x,y,z])-(z+x^2*y)*(x-z),expand;
(%o1)                                  0
Función: poly_s_polynomial (poly1, poly2, varlist)

Devuelve el polinomio syzygy (S-polinomio) de dos polinomios poly1 y poly2.

Función: poly_primitive_part (poly1, varlist)

Devuelve el polinomio poly dividido por el MCD de sus coeficientes.

(%i1) poly_primitive_part(35*y+21*x,[x,y]);
(%o1)                              5 y + 3 x
Función: poly_normalize (poly, varlist)

Devuelve el polinomio poly dividido por el coeficiente principal. Da por supuesto que la división es posible, lo cual puede no ser siempre cierto en anillos que no son campos.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.2.3 Otras funciones

Función: poly_expand (poly, varlist)

Esta función expande los polinomios. Equivale a expand(poly) si poly es un polinomio. Si la representación no es compatible con un polinomio de variables varlist, devuelve un error.

(%i1) poly_expand((x-y)*(y+x),[x,y]);
                                     2    2
(%o1)                               x  - y
(%i2) poly_expand((y+x)^2,[x,y]);
                                2            2
(%o2)                          y  + 2 x y + x
(%i3) poly_expand((y+x)^5,[x,y]);
                  5      4         2  3       3  2      4      5
(%o3)            y  + 5 x y  + 10 x  y  + 10 x  y  + 5 x  y + x
(%i4) poly_expand(-1-x*exp(y)+x^2/sqrt(y),[x]);
                                          2
                                  y      x
(%o4)                       - x %e  + ------- - 1
                                       sqrt(y)

(%i5) poly_expand(-1-sin(x)^2+sin(x),[sin(x)]);
                                2
(%o5)                      - sin (x) + sin(x) - 1

Función: poly_expt (poly, number, varlist)

Eleva el polinomio poly a la potencia number, siendo este un entero positivo. Si number no es un número entero positivo, devolverá un error.

(%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand;
(%o1)                                  0
Función: poly_content (poly. varlist)

poly_content calcula el MCD de los coeficientes.

(%i1) poly_content(35*y+21*x,[x,y]);
(%o1)                                  7
Función: poly_pseudo_divide (poly, polylist, varlist)

Realiza la seudo-división del polinomio poly por la lista de n polinomios de polylist. Devuelve varios resultados. El primer resultado es una lista de cocientes a. El segundo resultado es el resto r. El tercer resultado es un coeficiente escalar c, tal que c*poly puede dividirse por polylist dentro del anillo de coeficientes, el cual no es necesariamente un campo. Por último, el cuarto resultado es un entero que guarda el recuento de reducciones realizadas. El objeto resultante satisface la ecuación:

c*poly=sum(a[i]*polylist[i],i=1...n)+r.

Función: poly_exact_divide (poly1, poly2, varlist)

Divide el polinomio poly1 por otro polinomio poly2. Da por supuesto que es posible la división de resto nulo. Devuelve el cociente.

Función: poly_normal_form (poly, polylist, varlist)

poly_normal_form encuentra la forma normal de un polinomio poly respecto de un conjunto de polinomios polylist.

Función: poly_buchberger_criterion (polylist, varlist)

Devuelve true si polylist es una base de Groebner respecto del orden de términos activo, utilizando el criterio de Buchberger: para cualesquiera polinomios h1 y h2 de polylist el S-polinomio S(h1,h2) se reduce a 0 modulo polylist.

Función: poly_buchberger (polylist_fl varlist)

poly_buchberger ejecuta el algoritmo de Buchberger sobre una lista de polinomios y devuelve la base de Groebner resultante.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

56.2.4 Postprocesamiento estándar de bases de Groebner

El k-ésimo ideal de eliminación I_k de un ideal I sobre K[ x[1],...,x[n] ] es el ideal intersect(I, K[ x[k+1],...,x[n] ]).
El ideal I:J es el ideal {h|para todo w en J: w*h pertence a I}.
El ideal I:p^inf es el ideal {h| existe un n en N: p^n*h pertence a I}.
El ideal I:J^inf es el ideal {h| existe un n en N y un p en J: p^n*h pertence a I}.
El ideal radical sqrt(I) es el ideal {h| existe un n en N : h^n pertence a I }.

Función: poly_reduction (polylist, varlist)

poly_reduction reduce una lista de polinomios polylist de manera que cada polinomio se reduce completamente respecto de los otros polinomios.

Función: poly_minimization (polylist, varlist)

Devuelve una sublista de la lista de polinomios polylist con el mismo ideal de monomios que polylist, pero mínimo, esto es, ningún monomio principal de los polinomios de la sublista divide a los monomios principales de los demás polinomios.

Función: poly_normalize_list (polylist, varlist)

poly_normalize_list aplica poly_normalize a cada polinomio de la lista. Esto significa que divide cada polinomio de polylist por su coeficiente principal.

Función: poly_grobner (polylist, varlist)

Devuelve la base de Groebner del ideal asociado a los polinomios de polylist. El resultado depende de las variables globales.

Función: poly_reduced_grobner (polylist, varlist)

Devuelve la base de Groebner reducida del ideal asociado a los polinomios de polylist. El resultado depende de las variables globales.

Función: poly_depends_p (poly, var, varlist)

poly_depends comprueba si el polinomio depende de la variable var.

Función: poly_elimination_ideal (polylist, n, varlist)

poly_elimination_ideal devuelve la base de Groebner del n-ésimo ideal de eliminación de un ideal especificado como una lista de polinomios generadores (no necesariamente una base de Groebner).

Función: poly_colon_ideal (polylist1, polylist2, varlist)

Devuelve la base de Groebner reducida del ideal

I(polylist1):I(polylist2)

siendo polylist1 y polylist2 dos listas de polinomios.

Función: poly_ideal_intersection (polylist1, polylist2, varlist)

poly_ideal_intersection devuelve la intersección de dos ideales.

Función: poly_lcm (poly1, poly2, varlist)

Devuelve el MCM de poly1 y poly2.

Función: poly_gcd (poly1, poly2, varlist)

Devuelve el MCD de poly1 y poly2.

Véanse también ezgcd, gcd, gcdex y gcdivide.

Ejemplo:

(%i1) p1:6*x^3+19*x^2+19*x+6; 
                        3       2
(%o1)                6 x  + 19 x  + 19 x + 6
(%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                  5       4       3       2
(%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
(%i3) poly_gcd(p1, p2, [x]);
                            2
(%o3)                    6 x  + 13 x + 6
Función: poly_grobner_equal (polylist1, polylist2, varlist)

poly_grobner_equal comprueba si dos bases de Groebner generan el mismo ideal. Devuelve true si dos listas de polinomios polylist1 y polylist2, supuestas bases de Groebner, generan el mismo ideal, o false en caso contrario. Eso equivale a comprobar si cada polinomio de la primera base se reduce a 0 módulo la segunda base y viceversa. Nótese que en el ejemplo que sigue la primera lista no es una base de Groebner, por lo que el resultado es false.

(%i1) poly_grobner_equal([y+x,x-y],[x,y],[x,y]);
(%o1)                         false
Función: poly_grobner_subsetp (polylist1, polylist2, varlist)

poly_grobner_subsetp comprueba si el ideal generado por polylist1 está contenido en el ideal generado por polylist2. Para que esta comprobación tenga éxito, polylist2 debe ser una base de Groebner.

Función: poly_grobner_member (poly, polylist, varlist)

Devuelve true si el polinomio poly pertenece al ideal generado por la lista de polinomios polylist, la cual se supone una base de Groebner. Devolverá false en caso contrario.

Función: poly_ideal_saturation1 (polylist, poly, varlist)

Devuelve la base de Groebner reducida de la saturación del ideal

I(polylist):poly^inf

Desde un punto de vista geométrico, sobre un campo algebraicamente cerrado, este es el conjunto de polinomios del ideal generado por polylist que no se anulan sobre la variedad de poly.

Función: poly_ideal_saturation (polylist1, polylist2, varlist)

Devuelve la base de Groebner reducida de la saturación del ideal

I(polylist1):I(polylist2)^inf

Desde un punto de vista geométrico, sobre un campo algebraicamente cerrado, este es el conjunto de polinomios del ideal generado por polylist1 que no se anulan sobre la variedad de polylist2.

Función: poly_ideal_polysaturation1 (polylist1, polylist2, varlist)

polylist2 es una lista de n poliomios [poly1,...,polyn]. Devuelve la base de Groebner reducida del ideal

I(polylist):poly1^inf:...:polyn^inf

obtenida a partir de una secuencia de saturaciones sucesivas de los polinomios de la lista polylist2 del ideal generado por la lista de polinomios polylist1.

Función: poly_ideal_polysaturation (polylist, polylistlist, varlist)

polylistlist es una lista de n listas de polinomios [polylist1,...,polylistn]. Devuelve la base de Groebner reducida de la saturación del ideal

I(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf

Función: poly_saturation_extension (poly, polylist, varlist1, varlist2)

poly_saturation_extension ejecuta el truco de Rabinowitz.

Función: poly_polysaturation_extension (poly, polylist, varlist1, varlist2)

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on agosto, 12 2012 using texi2html 1.76.