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

# 79. zeilberger

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

## 79.1 Introducción a zeilberger

El paquete `zeilberger` implementa el algoritmo de Zeilberger para la suma hipergeométrica definida y el algoritmo de Gosper para la suma hipergeométrica indefinida. Además, hace uso del método de optimización por filtrado desarrollado por Axel Riese.

El autor de este paquete es Fabrizio Caruso.

Antes de hacer uso de las funciones aquí definidas, ejecútese la sentencia `load (zeilberger)`.

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

### 79.1.1 El problema de la suma indefinida

El paquete `zeilberger` implementa el algoritmo de Gosper para la suma hipergeométrica indefinida. Dado el término general hipergeométrico F_k de índice k, se plantea el problema de encontrar su antidiferencia hipergeométrica, esto es, el término hipergeométrico tal que

F_k = f_(k+1) - f_k.

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

### 79.1.2 El problema de la suma definida

El paquete `zeilberger` implementa el algoritmo de Zeilberger para la suma hipergeométrica definida. Dados el término hipergeométrico propio F_(n,k), de índices n y k, y el entero positivo d, se plantea el problema de encontrar una expresión recurrente lineal de orden d con coeficientes polinomiales en n y una función racional R en n y k tales que

a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))

donde Delta_k es el k-ésimo operador diferencia hacia adelante, esto es, Delta_k(t_k) := t_(k+1) - t_k.

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

### 79.1.3 Niveles de información

Hay versiones extendidas de los nombres de las instrucciones, que se construyen añadiendo uno de los siguientes prefijos:

`Summary`

  Tan solo muestra un sumario al final

`Verbose`

  Alguna información en los niveles intermedios

`VeryVerbose`

  Más información

`Extra`

  Aún más información, incluida alguna sobre el sistema lineal en el algoritmo de Zeilberger.

Por ejemplo: `GosperVerbose`, `parGosperVeryVerbose`, `ZeilbergerExtra`, `AntiDifferenceSummary`.

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

## 79.2 Funciones y variables para zeilberger

Función: AntiDifference (F_k, k)

  Returns the hypergeometric anti-difference of F_k, if it exists. Otherwise `AntiDifference` returns `no_hyp_antidifference`.

Función: Gosper (F_k, k)

  Devuelve, si existe, el elemento racional asociado a F_k, esto es, la función racional que verifica

  F_k = R(k+1) F_(k+1) - R(k) F_k,

  En caso de no existir este elemento, `Gosper` devuelve `no_hyp_sol`.

Función: GosperSum (F_k, k, a, b)

  Devuelve la suma de los términos F_k desde k = a hasta k = b si F_k tiene una antidiferencia hipergeométrica. En caso contrario, `GosperSum` devuelve `nongosper_summable`.

  Ejemplos:

      (%i1) load (zeilberger)$
      (%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
      Dependent equations eliminated:  (1)
                                 3       n + 1
                            (n + -) (- 1)
                                 2               1
      (%o2)               - ------------------ - -
                                        2        4
                            2 (4 (n + 1)  - 1)
      (%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
                                      3
                                - n - -
                                      2       1
      (%o3)                  -------------- + -
                                      2       2
                             4 (n + 1)  - 1
      (%i4) GosperSum (x^k, k, 1, n);
                                n + 1
                               x          x
      (%o4)                    ------ - -----
                               x - 1    x - 1
      (%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
                                      n + 1
                      a! (n + 1) (- 1)              a!
      (%o5)       - ------------------------- - ----------
                    a (- n + a - 1)! (n + 1)!   a (a - 1)!
      (%i6) GosperSum (k*k!, k, 1, n);
      Dependent equations eliminated:  (1)
      (%o6)                     (n + 1)! - 1
      (%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
                        (n + 1) (n + 2) (n + 1)!
      (%o7)             ------------------------ - 1
                                (n + 2)!
      (%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
      (%o8)                  NON_GOSPER_SUMMABLE

Función: parGosper (F_{n,k}, k, n, d)

  Intenta calcular una recurrecia de orden d para F_{n,k}.

  El algoritmo devuelve una secuencia [s_1, s_2, ..., s_m] de soluciones, cada una de las cuales tiene la forma

  [R(n, k), [a_0, a_1, ..., a_d]].

  La función `parGosper` devuelve `[]` si no encuentra ninguna recurrencia.

Función: Zeilberger (F_{n,k}, k, n)

  Intenta calcular la suma hipergeométrica indefinida de F_{n,k}.

  La función `Zeilberger` invoca en primer lugar a `Gosper`, y en caso de no encontrar una solución, llama después a `parGosper` con los órdenes 1, 2, 3, ..., hasta `max_ord`. Si `Zeilberger` encuentra una solución antes de alcanzar `max_ord`, se detiene su ejecución y devuelve el resultado.

  El algoritmo devuelve una secuencia [s_1, s_2, ..., s_m] de soluciones, cada una de las cuales tiene la forma

  [R(n, k), [a_0, a_1, ..., a_d]].

  La función `Zeilberger` devuelve `[]` si no encuentra ninguna solución.

  La función `Zeilberger` llama a `Gosper` sólo si `Gosper_in_Zeilberger` tiene el valor `true`.

Variable opcional: max_ord

  Valor por defecto: 5

  `max_ord` es el máximo orden de recurrencia que ensayará la función `Zeilberger`.

Variable opcional: simplified_output

  Valor por defecto: `false`

  Si `simplified_output` vale `true`, las funciones del paquete `zeilberger` tratan de presentar las soluciones simplificadas.

Variable opcional: linear_solver

  Valor por defecto: `linsolve`

  La variable `linear_solver` guarda el nombre de la función que se utilizará para resolver el sistema de ecuaciones del algoritmo de Zeilberger.

Variable opcional: warnings

  Valor por defecto: `true`

  Si `warnings` vale `true`, las funciones del paquete `zeilberger` emiten mensajes de aviso durante su ejecución.

Variable opcional: Gosper_in_Zeilberger

  Valor por defecto: `true`

  Si `Gosper_in_Zeilberger` vale `true`, la función `Zeilberger` llama a la función `Gosper` antes de llamar a `parGosper`. En caso contrario, `Zeilberger` invoca inmediatamente a `parGosper`.

Variable opcional: trivial_solutions

  Valor por defecto: `true`

  Si `trivial_solutions` vale `true`, la función `Zeilberger` devuelve soluciones triviales.

Variable opcional: mod_test

  Valor por defecto: `false`

  Si `mod_test` vale `true`, la función `parGosper` ejecuta una prueba modular para descartar sistemas sin soluciones.

Variable opcional: modular_linear_solver

  Valor por defecto: `linsolve`

  La variable `modular_linear_solver` guarda el nombre de la función que deberá ser llamada por la prueba modular de `parGosper` para resolver sistemas lineales.

Variable opcional: ev_point

  Valor por defecto: `big_primes[10]`

  La variable `ev_point` guarda el valor para el que debe evaluarse n durante la ejecución de la prueba modular de `parGosper`.

Variable opcional: mod_big_prime

  Valor por defecto: `big_primes[1]`

  La variable `mod_big_prime` guarda el módulo utilizado por la prueba modular de `parGosper`.

Variable opcional: mod_threshold

  Valor por defecto: 4

  La variable `mod_threshold` es el máximo orden que ensaya la prueba modular de `parGosper`.

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

This document was generated by Viktor T. Toth on octubre, 3 2017 using texi2html 1.76.