Manual de Maxima 5.36.0: 56. grobner

[ < ] | [ > ] |  | [ << ] | [ 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

- `lex`

  lexicográfico puro; orden por defecto para la comparación de monomios.

- `grlex`

  grado total, con empates resueltos por el orden lexicográfico.

- `grevlex`

  grado total, con empates resueltos por el orden lexicográfico inverso.

- `invlex`

  orden lexicográfico inverso.

[ < ] | [ > ] |  | [ << ] | [ 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 U-Cygwin\ASSI on julio, 26 2015 using texi2html 1.76.