@c English version: 2011-05-30
@menu
* Introducción a zeilberger::
* Funciones y variables para zeilberger::
@end menu

@node Introducción a zeilberger, Funciones y variables para zeilberger, zeilberger, zeilberger
@section Introducción a zeilberger

El paquete @code{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 @code{load (zeilberger)}.


@subsection El problema de la suma indefinida

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

@tex
$$F_k = f_{k+1} - f_k.$$
@end tex
@ifnottex
@math{F_k = f_(k+1) - f_k}.
@end ifnottex

@subsection El problema de la suma definida

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

@math{a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))}

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

@subsection Niveles de información

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

@table @code
@item Summary
Tan solo muestra un sumario al final
@item Verbose
Alguna información en los niveles intermedios
@item VeryVerbose
Más información
@item Extra
Aún más información, incluida alguna sobre
el sistema lineal en el algoritmo de Zeilberger.
@end table

Por ejemplo:
@code{GosperVerbose}, @code{parGosperVeryVerbose},
@code{ZeilbergerExtra}, @code{AntiDifferenceSummary}.


@node Funciones y variables para zeilberger,  , Introducción a zeilberger, zeilberger
@section Funciones y variables para zeilberger

@deffn {Función} AntiDifference (@var{F_k}, @var{k})

Returns the hypergeometric anti-difference
of @math{F_k}, if it exists.
Otherwise @code{AntiDifference} returns @code{no_hyp_antidifference}.
@end deffn

@deffn {Función} Gosper (@var{F_k}, @var{k})
Devuelve, si existe, el elemento racional asociado a @var{F_k}, esto es,
la función racional que verifica

@tex
$F_k = R\left(k+1\right) \, F_{k+1} - R\left(k\right) \, F_k$,
@end tex
@ifnottex
@math{F_k = R(k+1) F_(k+1) - R(k) F_k},
@end ifnottex

En caso de no existir este elemento, @code{Gosper} devuelve @code{no_hyp_sol}.
@end deffn

@deffn {Función} GosperSum (@var{F_k}, @var{k}, @var{a}, @var{b}) 
Devuelve la suma de los términos @math{F_k} desde @math{@var{k} = @var{a}} hasta
@math{@var{k} = @var{b}} si @math{F_k} tiene una antidiferencia
hipergeométrica. En caso contrario, @code{GosperSum} devuelve
@code{nongosper_summable}.

Ejemplos:

@c ===beg===
@c load (zeilberger)$
@c GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
@c GosperSum (1 / (4*k^2 - 1), k, 1, n);
@c GosperSum (x^k, k, 1, n);
@c GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
@c GosperSum (k*k!, k, 1, n);
@c GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
@c GosperSum (1 / ((a - k)!*k!), k, 1, n);
@c ===end===
@example
(%i1) load (zeilberger)$
@group
(%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)
@end group
@group
(%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
                                3
                          - n - -
                                2       1
(%o3)                  -------------- + -
                                2       2
                       4 (n + 1)  - 1
@end group
@group
(%i4) GosperSum (x^k, k, 1, n);
                          n + 1
                         x          x
(%o4)                    ------ - -----
                         x - 1    x - 1
@end group
@group
(%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)!
@end group
@group
(%i6) GosperSum (k*k!, k, 1, n);
Dependent equations eliminated:  (1)
(%o6)                     (n + 1)! - 1
@end group
@group
(%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
                  (n + 1) (n + 2) (n + 1)!
(%o7)             ------------------------ - 1
                          (n + 2)!
@end group
@group
(%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
(%o8)                  NON_GOSPER_SUMMABLE
@end group
@end example

@end deffn

@deffn {Función} parGosper (@var{F_@{n,k@}}, @var{k}, @var{n}, @var{d})
Intenta calcular una recurrecia de orden @var{d} para @var{F_@{n,k@}}.

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

@math{[R(n, k), [a_0, a_1, ..., a_d]]}.

La función @code{parGosper} devuelve @code{[]} si no encuentra
ninguna recurrencia.
@end deffn

@deffn {Función} Zeilberger (@var{F_@{n,k@}}, @var{k}, @var{n})
Intenta calcular la suma hipergeométrica indefinida de @var{F_@{n,k@}}.

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

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

@math{[R(n, k), [a_0, a_1, ..., a_d]]}.

La función @code{Zeilberger} devuelve @code{[]} si no encuentra
ninguna solución.

La función @code{Zeilberger} llama a @code{Gosper} sólo si 
@code{Gosper_in_Zeilberger} tiene el valor @code{true}.
@end deffn

@defvr {Variable opcional} max_ord
Valor por defecto: 5

@code{max_ord} es el máximo orden de recurrencia que ensayará la función @code{Zeilberger}.
@end defvr

@defvr {Variable opcional} simplified_output
Valor por defecto: @code{false}

Si @code{simplified_output} vale @code{true},
las funciones del paquete @code{zeilberger} tratan de
presentar las soluciones simplificadas.
@end defvr

@defvr {Variable opcional} linear_solver
Valor por defecto: @code{linsolve}

La variable @code{linear_solver} guarda el nombre de la función que
se utilizará para resolver el sistema de ecuaciones del algoritmo de
Zeilberger.
@end defvr

@defvr {Variable opcional} warnings
Valor por defecto: @code{true}

Si @code{warnings} vale @code{true},
las funciones del paquete @code{zeilberger} emiten
mensajes de aviso durante su ejecución.
@end defvr

@defvr {Variable opcional} Gosper_in_Zeilberger
Valor por defecto: @code{true}

Si @code{Gosper_in_Zeilberger} vale @code{true},
la función @code{Zeilberger} llama a la función @code{Gosper}
antes de llamar a @code{parGosper}.
En caso contrario, @code{Zeilberger} invoca inmediatamente a @code{parGosper}.
@end defvr

@defvr {Variable opcional} trivial_solutions
Valor por defecto: @code{true}

Si @code{trivial_solutions} vale @code{true},
la función @code{Zeilberger} devuelve soluciones triviales.
@end defvr

@defvr {Variable opcional} mod_test
Valor por defecto: @code{false}

Si @code{mod_test} vale @code{true},
la función @code{parGosper} ejecuta una prueba modular 
para descartar sistemas sin soluciones.
@end defvr

@defvr {Variable opcional} modular_linear_solver
Valor por defecto: @code{linsolve}

La variable @code{modular_linear_solver} guarda el nombre de la función
que deberá ser llamada por la prueba modular de @code{parGosper} para
resolver sistemas lineales.
@end defvr

@defvr {Variable opcional} ev_point
Valor por defecto: @code{big_primes[10]}

La variable @code{ev_point} guarda el valor para el que debe evaluarse @var{n}
durante la ejecución de la prueba modular de @code{parGosper}.
@end defvr

@defvr {Variable opcional} mod_big_prime
Valor por defecto: @code{big_primes[1]}

La variable @code{mod_big_prime} guarda el módulo utilizado por la prueba
modular de @code{parGosper}.
@end defvr

@defvr {Variable opcional} mod_threshold
Valor por defecto: 4

La variable @code{mod_threshold} es el máximo orden que ensaya la prueba modular
de @code{parGosper}.
@end defvr

