@c /zeilberger.texi/1.5/Thu Dec 28 05:44:18 2006//
@menu
* Introdução a zeilberger::
* Definições para zeilberger::
@end menu

@node Introdução a zeilberger, Definições para zeilberger, zeilberger, zeilberger
@section Introdução a zeilberger

@code{zeilberger} é uma implementação do algoritmo de Zeilberger
para somatório hipergeométricos definidos, e também 
para o algoritmo de Gosper para somatórios hipergeométricos
indefinidos.

@code{zeilberger} faz uso do método de optimização "filtering" desenvolvido por Axel Riese.

@code{zeilberger} foi desenvolvido por Fabrizio Caruso.

@code{load (zeilberger)} torna esse pacote disponível para uso.

@subsection O problema dos somatórios hipergeométricos indefinidos

@code{zeilberger} implementa o algoritmo de Gosper
para somatório hipergeométrico indefinido.
Dado um termo hipergeométrico @math{F_k} em @math{k} queremos encontrar sua anti-diferença
hipergeométrica, isto é, um termo hipergeométrico @math{f_k} tal que @math{F_k = f_(k+1) - f_k}.

@subsection O problema dos somatórios hipergeométricos definidos

@code{zeilberger} implementa o algoritmo de Zeilberger
para somatório hipergeométrico definido.
Dado um termo hipergeométrico apropriado (em @math{n} e @math{k}) @math{F_(n,k)} e um
inteiro positivo @math{d} queremos encontrar um @math{d}-ésima ordem de recorrência
linear com coeficientes polinomiais (em @math{n}) para @math{F_(n,k)}
e uma função racional @math{R} em @math{n} e @math{k} tal que

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

onde @math{Delta_k} é o @math{k}-seguinte operador de diferença, i.e.,
@math{Delta_k(t_k) := t_(k+1) - t_k}.

@subsection Níveis de detalhe nas informações

Existe também versões de níveis de detalhe fornecidos pelos comandos
que são chamados (os níveis) através da adição de um dos seguintes prefixos:

@table @code
@item Summary
Apenas um sumário é mostrado no final
@item Verbose
Algumas informações nos passos intermédios
@item VeryVerbose
Muita informação
@item Extra
Muito mais informação incluindo informação sobre
o sistema linear no algoritmo de Zeilberger
@end table

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


@node Definições para zeilberger, , Introdução a zeilberger, zeilberger
@section Definições para zeilberger

@deffn {Função} AntiDifference (@var{F_k}, @var{k})

Retorna a anti-diferença hipergeométrica
de @var{F_k}, se essa anti-diferença.
De outra forma @code{AntiDifference} retorna @code{no_hyp_antidifference}.
@end deffn

@deffn {Função} Gosper (@var{F_k}, @var{k})
Retorna o certificado racional @var{R(k)} para @var{F_k}, isto é,
uma função racional tal que

@math{F_k = R(k+1) F_(k+1) - R(k) F_k}
 
se essa função racional exitir.
De outra forma, @code{Gosper} retorna @code{no_hyp_sol}.
@end deffn

@deffn {Função} GosperSum (@var{F_k}, @var{k}, @var{a}, @var{b}) 

Retorna o somatório de @var{F_k} de @math{@var{k} = @var{a}} a @math{@var{k} = @var{b}}
se @var{F_k} tiver ma diferença hipergeométrica.
De outra forma, @code{GosperSum} retorna @code{nongosper_summable}.

Exemplos:

@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);
(%o1)  /usr/share/maxima/share/contrib/Zeilberger/zeilberger.mac
(%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)                  nonGosper_summable
@end example
@end deffn

@deffn {Função} parGosper (@var{F_@{n,k@}}, @var{k}, @var{n}, @var{d})
Tenta encontrar uma recorrência de @var{d}-ésima ordem para @var{F_@{n,k@}}.

O algoritmo retorna uma sequência
@math{[s_1, s_2, ..., s_m]} de soluções.
Cada solução tem a forma

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

@code{parGosper} retorna @code{[]} caso não consiga encontrar uma recorrência.
@end deffn

@deffn {Função} Zeilberger (@var{F_@{n,k@}}, @var{k}, @var{n})
Tenta calcular o somatório hipergeométrico indefinido de @var{F_@{n,k@}}.

@code{Zeilberger} primeiro invoca @code{Gosper}, e se @code{Gosper} não conseguir encontrar uma solução, então @code{Zeilberger} invoca
@code{parGosper}com ordem 1, 2, 3, ..., acima de @code{MAX_ORD}.
Se Zeilberger encontrar uma solução antes de esticar @code{MAX_ORD},
Zeilberger para e retorna a solução.

O algoritmo retorna uma sequência
@math{[s_1, s_2, ..., s_m]} de soluções.
Cada solução tem a forma

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

@code{Zeilberger} retorna @code{[]} se não conseguir encontrar uma solução.

@code{Zeilberger} invoca @code{Gosper} somente se @code{gosper_in_zeilberger} for @code{true}.
@end deffn

@section Variáveis globais gerais

@defvr {Variável global} MAX_ORD
Valor por omissão: 5

@code{MAX_ORD} é a ordem máxima de recorrência tentada por @code{Zeilberger}.
@end defvr

@defvr {Variável global} simplified_output
Valor por omissão: @code{false}

Quando @code{simplified_output} for @code{true},
funções no pacote @code{zeilberger} tentam
simplificação adicional da solução.
@end defvr

@defvr {Variável global} linear_solver
Valor por omissão: @code{linsolve}

@code{linear_solver} nomeia o resolvedor que é usado para resolver o sistema
de equações no algoritmo de Zeilberger.
@end defvr

@defvr {Variável global} warnings
Valor por omissão: @code{true}

Quando @code{warnings} for @code{true},
funções no pacote @code{zeilberger} imprimem
mensagens de alerta durante a execução.
@end defvr

@defvr {Variável global} gosper_in_zeilberger
Valor por omissão: @code{true}

Quando @code{gosper_in_zeilberger} for @code{true},
a função @code{Zeilberger} chama @code{Gosper} antes de chamar @code{parGosper}.
De outra forma, @code{Zeilberger} vai imediatamente para @code{parGosper}.
@end defvr

@defvr {Variável global} trivial_solutions
Valor por omissão: @code{true}

Quando @code{trivial_solutions} for @code{true},
@code{Zeilberger} retorna soluções
que possuem certificado igual a zero, ou todos os coeficientes iguais a zero.
@end defvr

@section Variáveis relacionadas ao teste modular

@defvr {Variável global} mod_test
Valor por omissão: @code{false}

Quando @code{mod_test} for @code{true},
@code{parGosper} executa um
teste modular discartando sistemas sem solução.
@end defvr

@defvr {Variável global} modular_linear_solver
Valor por omissão: @code{linsolve}

@code{modular_linear_solver} nomeia o resolvedor linear usado pelo  teste modular em @code{parGosper}.
@end defvr

@defvr {Variável global} ev_point
Valor por omissão: @code{big_primes[10]}

@code{ev_point} é o valor no qual a variável @var{n} é avaliada
no momento da execução do teste modular em @code{parGosper}.
@end defvr

@defvr {Variável global} mod_big_prime
Valor por omissão: @code{big_primes[1]}

@code{mod_big_prime} é o módulo usado pelo teste modular em @code{parGosper}.
@end defvr

@defvr {Variável global} mod_threshold
Valor por omissão: 4

@code{mod_threshold} is the
maior ordem para a qual o teste modular em @code{parGosper} é tentado.
@end defvr


