zeilberger (Manual de Maxima 5.50.0)

## 79 zeilberger ¶

### 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")`.

#### 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\).

#### 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\).

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

### 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 \(\mathit{k} = \mathit{a}\) hasta \(\mathit{k} = \mathit{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`.

Información de licencia de JavaScript