doc/info/es/zeilberger.texi

   1 @c English version: 2011-05-30
   2 @menu
   3 * Introducción a zeilberger::
   4 * Funciones y variables para zeilberger::
   5 @end menu
   6
   7 @node Introducción a zeilberger, Funciones y variables para zeilberger, zeilberger, zeilberger
   8 @section Introducción a zeilberger
   9
  10 El paquete @code{zeilberger} implementa el algoritmo de Zeilberger
  11 para la suma hipergeométrica definida y el algoritmo de Gosper
  12 para la suma hipergeométrica indefinida. Además, hace uso del
  13 método de optimización por filtrado desarrollado por Axel Riese.
  14
  15 El autor de este paquete es Fabrizio Caruso.
  16
  17 Antes de hacer uso de las funciones aquí definidas,
  18 ejecútese la sentencia @code{load ("zeilberger")}.
  19
  20
  21 @subsection El problema de la suma indefinida
  22
  23 El paquete @code{zeilberger} implementa el algoritmo de Gosper
  24 para la suma hipergeométrica indefinida.
  25 Dado el término general hipergeométrico @math{F_k} de
  26 índice @math{k}, se plantea el problema de encontrar su
  27 antidiferencia hipergeométrica, esto es, el término
  28 hipergeométrico tal que
  29
  30 @tex
  31 $$F_k = f_{k+1} - f_k.$$
  32 @end tex
  33 @ifnottex
  34 @math{F_k = f_(k+1) - f_k}.
  35 @end ifnottex
  36
  37 @subsection El problema de la suma definida
  38
  39 El paquete @code{zeilberger} implementa el algoritmo de Zeilberger
  40 para la suma hipergeométrica definida.
  41 Dados el término hipergeométrico propio @math{F_(n,k)}, de
  42 índices @math{n} y @math{k}, y el entero positivo
  43 @math{d}, se plantea el problema de encontrar una expresión recurrente
  44 lineal de orden @math{d} con coeficientes polinomiales en @math{n}
  45 y una función racional @math{R} en @math{n} y @math{k} tales que
  46
  47 @math{a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))}
  48
  49 donde @math{Delta_k} es el @math{k}-ésimo operador diferencia hacia
  50 adelante, esto es,
  51 @math{Delta_k(t_k) := t_(k+1) - t_k}.
  52
  53 @subsection Niveles de información
  54
  55 Hay versiones extendidas de los nombres de las instrucciones,
  56 que se construyen añadiendo uno de los siguientes prefijos:
  57
  58 @table @code
  59 @item Summary
  60 Tan solo muestra un sumario al final
  61 @item Verbose
  62 Alguna información en los niveles intermedios
  63 @item VeryVerbose
  64 Más información
  65 @item Extra
  66 Aún más información, incluida alguna sobre
  67 el sistema lineal en el algoritmo de Zeilberger.
  68 @end table
  69
  70 Por ejemplo:
  71 @code{GosperVerbose}, @code{parGosperVeryVerbose},
  72 @code{ZeilbergerExtra}, @code{AntiDifferenceSummary}.
  73
  74
  75 @node Funciones y variables para zeilberger,  , Introducción a zeilberger, zeilberger
  76 @section Funciones y variables para zeilberger
  77
  78 @deffn {Función} AntiDifference (@var{F_k}, @var{k})
  79
  80 Returns the hypergeometric anti-difference
  81 of @math{F_k}, if it exists.
  82 Otherwise @code{AntiDifference} returns @code{no_hyp_antidifference}.
  83 @end deffn
  84
  85 @deffn {Función} Gosper (@var{F_k}, @var{k})
  86 Devuelve, si existe, el elemento racional asociado a @var{F_k}, esto es,
  87 la función racional que verifica
  88
  89 @tex
  90 $F_k = R\left(k+1\right) \, F_{k+1} - R\left(k\right) \, F_k$,
  91 @end tex
  92 @ifnottex
  93 @math{F_k = R(k+1) F_(k+1) - R(k) F_k},
  94 @end ifnottex
  95
  96 En caso de no existir este elemento, @code{Gosper} devuelve @code{no_hyp_sol}.
  97 @end deffn
  98
  99 @deffn {Función} GosperSum (@var{F_k}, @var{k}, @var{a}, @var{b})
 100 Devuelve la suma de los términos @math{F_k} desde @math{@var{k} = @var{a}} hasta
 101 @math{@var{k} = @var{b}} si @math{F_k} tiene una antidiferencia
 102 hipergeométrica. En caso contrario, @code{GosperSum} devuelve
 103 @code{nongosper_summable}.
 104
 105 Ejemplos:
 106
 107 @c ===beg===
 108 @c load ("zeilberger")$
 109 @c GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
 110 @c GosperSum (1 / (4*k^2 - 1), k, 1, n);
 111 @c GosperSum (x^k, k, 1, n);
 112 @c GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
 113 @c GosperSum (k*k!, k, 1, n);
 114 @c GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
 115 @c GosperSum (1 / ((a - k)!*k!), k, 1, n);
 116 @c ===end===
 117 @example
 118 (%i1) load ("zeilberger")$
 119 @group
 120 (%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
 121 Dependent equations eliminated:  (1)
 122                            3       n + 1
 123                       (n + -) (- 1)
 124                            2               1
 125 (%o2)               - ------------------ - -
 126                                   2        4
 127                       2 (4 (n + 1)  - 1)
 128 @end group
 129 @group
 130 (%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
 131                                 3
 132                           - n - -
 133                                 2       1
 134 (%o3)                  -------------- + -
 135                                 2       2
 136                        4 (n + 1)  - 1
 137 @end group
 138 @group
 139 (%i4) GosperSum (x^k, k, 1, n);
 140                           n + 1
 141                          x          x
 142 (%o4)                    ------ - -----
 143                          x - 1    x - 1
 144 @end group
 145 @group
 146 (%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
 147                                 n + 1
 148                 a! (n + 1) (- 1)              a!
 149 (%o5)       - ------------------------- - ----------
 150               a (- n + a - 1)! (n + 1)!   a (a - 1)!
 151 @end group
 152 @group
 153 (%i6) GosperSum (k*k!, k, 1, n);
 154 Dependent equations eliminated:  (1)
 155 (%o6)                     (n + 1)! - 1
 156 @end group
 157 @group
 158 (%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
 159                   (n + 1) (n + 2) (n + 1)!
 160 (%o7)             ------------------------ - 1
 161                           (n + 2)!
 162 @end group
 163 @group
 164 (%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
 165 (%o8)                  NON_GOSPER_SUMMABLE
 166 @end group
 167 @end example
 168
 169 @end deffn
 170
 171 @deffn {Función} parGosper (@var{F_@{n,k@}}, @var{k}, @var{n}, @var{d})
 172 Intenta calcular una recurrecia de orden @var{d} para @var{F_@{n,k@}}.
 173
 174 El algoritmo devuelve una secuencia @math{[s_1, s_2, ..., s_m]} de
 175 soluciones, cada una de las cuales tiene la forma
 176
 177 @math{[R(n, k), [a_0, a_1, ..., a_d]]}.
 178
 179 La función @code{parGosper} devuelve @code{[]} si no encuentra
 180 ninguna recurrencia.
 181 @end deffn
 182
 183 @deffn {Función} Zeilberger (@var{F_@{n,k@}}, @var{k}, @var{n})
 184 Intenta calcular la suma hipergeométrica indefinida de @var{F_@{n,k@}}.
 185
 186 La función @code{Zeilberger} invoca en primer lugar a @code{Gosper},
 187 y en caso de no encontrar una solución, llama después a @code{parGosper}
 188 con los órdenes 1, 2, 3, ..., hasta @code{max_ord}. Si @code{Zeilberger}
 189 encuentra una solución antes de alcanzar @code{max_ord}, se detiene su
 190 ejecución y devuelve el resultado.
 191
 192 El algoritmo devuelve una secuencia @math{[s_1, s_2, ..., s_m]} de
 193 soluciones, cada una de las cuales tiene la forma
 194
 195 @math{[R(n, k), [a_0, a_1, ..., a_d]]}.
 196
 197 La función @code{Zeilberger} devuelve @code{[]} si no encuentra
 198 ninguna solución.
 199
 200 La función @code{Zeilberger} llama a @code{Gosper} sólo si
 201 @code{Gosper_in_Zeilberger} tiene el valor @code{true}.
 202 @end deffn
 203
 204 @defvr {Variable opcional} max_ord
 205 Valor por defecto: 5
 206
 207 @code{max_ord} es el máximo orden de recurrencia que ensayará la función @code{Zeilberger}.
 208 @end defvr
 209
 210 @defvr {Variable opcional} simplified_output
 211 Valor por defecto: @code{false}
 212
 213 Si @code{simplified_output} vale @code{true},
 214 las funciones del paquete @code{zeilberger} tratan de
 215 presentar las soluciones simplificadas.
 216 @end defvr
 217
 218 @defvr {Variable opcional} linear_solver
 219 Valor por defecto: @code{linsolve}
 220
 221 La variable @code{linear_solver} guarda el nombre de la función que
 222 se utilizará para resolver el sistema de ecuaciones del algoritmo de
 223 Zeilberger.
 224 @end defvr
 225
 226 @defvr {Variable opcional} warnings
 227 Valor por defecto: @code{true}
 228
 229 Si @code{warnings} vale @code{true},
 230 las funciones del paquete @code{zeilberger} emiten
 231 mensajes de aviso durante su ejecución.
 232 @end defvr
 233
 234 @defvr {Variable opcional} Gosper_in_Zeilberger
 235 Valor por defecto: @code{true}
 236
 237 Si @code{Gosper_in_Zeilberger} vale @code{true},
 238 la función @code{Zeilberger} llama a la función @code{Gosper}
 239 antes de llamar a @code{parGosper}.
 240 En caso contrario, @code{Zeilberger} invoca inmediatamente a @code{parGosper}.
 241 @end defvr
 242
 243 @defvr {Variable opcional} trivial_solutions
 244 Valor por defecto: @code{true}
 245
 246 Si @code{trivial_solutions} vale @code{true},
 247 la función @code{Zeilberger} devuelve soluciones triviales.
 248 @end defvr
 249
 250 @defvr {Variable opcional} mod_test
 251 Valor por defecto: @code{false}
 252
 253 Si @code{mod_test} vale @code{true},
 254 la función @code{parGosper} ejecuta una prueba modular
 255 para descartar sistemas sin soluciones.
 256 @end defvr
 257
 258 @defvr {Variable opcional} modular_linear_solver
 259 Valor por defecto: @code{linsolve}
 260
 261 La variable @code{modular_linear_solver} guarda el nombre de la función
 262 que deberá ser llamada por la prueba modular de @code{parGosper} para
 263 resolver sistemas lineales.
 264 @end defvr
 265
 266 @defvr {Variable opcional} ev_point
 267 Valor por defecto: @code{big_primes[10]}
 268
 269 La variable @code{ev_point} guarda el valor para el que debe evaluarse @var{n}
 270 durante la ejecución de la prueba modular de @code{parGosper}.
 271 @end defvr
 272
 273 @defvr {Variable opcional} mod_big_prime
 274 Valor por defecto: @code{big_primes[1]}
 275
 276 La variable @code{mod_big_prime} guarda el módulo utilizado por la prueba
 277 modular de @code{parGosper}.
 278 @end defvr
 279
 280 @defvr {Variable opcional} mod_threshold
 281 Valor por defecto: 4
 282
 283 La variable @code{mod_threshold} es el máximo orden que ensaya la prueba modular
 284 de @code{parGosper}.
 285 @end defvr
 286