Introducción a solve_rec
========================

El paquete solve_rec resuelve expresiones recurrentes lineales con coeficientes polinomiales.

Ejecútese demo(solve_rec); para ver una demostración sobre la utilización de este paquete.

Ejemplo:

     (%i1) load("solve_rec")$
     (%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]);
                                         n
                      %k  (2 n + 3) (- 1)          %k
                        1                            2
     (%o2)       s  = -------------------- + ---------------
                  n     (n + 1) (n + 2)      (n + 1) (n + 2)

Funciones y variables para solve_rec
====================================

 -- Función: reduce_order (REC, SOL, VAR)

     Reduce el orden de la expresión recurrente lineal REC cuando se conoce una solución particular SOL. La recurrencia reducida puede utilizarse para obterner más soluciones.

     Ejemplo:

          (%i3) rec: x[n+2] = x[n+1] + x[n]/n;
                                                x
                                                 n
          (%o3)               x      = x      + --
                               n + 2    n + 1   n
          (%i4) solve_rec(rec, x[n]);
          WARNING: found some hypergeometrical solutions!
          (%o4)                    x  = %k  n
                                    n     1
          (%i5) reduce_order(rec, n, x[n]);
          (%t5)                    x  = n %z
                                    n       n

                                     n - 1
                                     ====
                                     \
          (%t6)                %z  =  >     %u
                                 n   /        %j
                                     ====
                                     %j = 0

          (%o6)             (- n - 2) %u     - %u
                                        n + 1     n
          (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
                                               n
                                      %k  (- 1)
                                        1
          (%o6)                 %u  = ----------
                                  n    (n + 1)!

     So the general solution is

                       n - 1
                       ====        n
                       \      (- 1)
                 %k  n  >    -------- + %k  n
                   2   /     (n + 1)!     1
                       ====
                       n = 0

 -- Variable opcional: simplify_products
     Valor por defecto: true

     Si simplify_products vale true, solve_rec intentará simplificar los productos del resultado.

     Véase también solve_rec.

 -- Función: simplify_sum (EXPR)

     Intenta reducir todas las sumas que aparecen en EXPR a una forma cerrada. La función simplify_sum utiliza los algoritmos de Gosper y Zeilberger para reducir las sumas.

     Para utilizar esta función cárguese previamente el paquete simplify_sum ejecutando la instrucción load(simplify_sum).

     Ejemplo:

          (%i1) load("simplify_sum")$
          (%i2) sum(binom(n+k,k)/2^k, k, 0, n) +
                    sum(binom(2*n, 2*k), k, 0, n);
                   n                            n
                  ====                         ====
                  \      binomial(n + k, k)    \
          (%o2)    >     ------------------ +   >    binomial(2 n, 2 k)
                  /               k            /
                  ====           2             ====
                  k = 0                        k = 0
          (%i3) simplify_sum(%);
                                         n
                                        4     n
          (%o3)                         -- + 2
                                        2

 -- Función: solve_rec (EQN, VAR, [INIT])

     Obtiene las soluciones hipergeométricas de la expresión recurrente EQN con coeficientes lineales en la variable VAR. Los argumentos opcionales INIT son condiciones iniciales.

     La función solve_rec puede resolver expresiones recurrentes con coeficientes constantes, encuentra soluciones hipergeométricas de expresiones recurrentes lineales homogéneas con coeficientes polinomiales, obtiene soluciones racionales de expresiones recurrentes lineales con coeficientes lineales y resuelve también expresiones recurrentes de Ricatti.

     Nótese que el tiempo de ejecución del algoritmo para encontrar soluciones hipergeométricas es exponencial respecto del grado del coeficiente principal.

     Para hacer uso de esta función ejecútese previamente load(solve_rec);.

     Ejemplo de recurrencia lineal con coeficientes constantes:

          (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
                                  n          n
                     (sqrt(5) - 1)  %k  (- 1)
                                      1           n
          (%o2) a  = ------------------------- - ----
                 n               n                  n
                                2                5 2
                                                          n
                                             (sqrt(5) + 1)  %k
                                                              2    2
                                           + ------------------ - ----
                                                      n              n
                                                     2            5 2

     Ejemplo de recurrencia lineal con coeficientes polinomiales:

          (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
                                   2
          (%o7) (x - 1) y      - (x  + 3 x - 2) y      + 2 x (x + 1) y
                         x + 2                   x + 1                x
          (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
                                        x
                                     3 2    x!
          (%o9)                 y  = ---- - --
                                 x    4     2

     Ejemplo de recurrencia de Ricatti:

          (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
                                      y         y
                                       x + 1     x
          (%o2)         x y  y      - ------ + ----- = 0
                           x  x + 1   x + 2    x - 1
          (%i3) solve_rec(%, y[x], y[3]=5)$
          (%i4) ratsimp(minfactorial(factcomb(%)));
                                             3
                                         30 x  - 30 x
          (%o4) y  = - -------------------------------------------------
                 x        6      5       4       3       2
                       5 x  - 3 x  - 25 x  + 15 x  + 20 x  - 12 x - 1584

     Véanse también solve_rec_rat, simplify_products y product_use_gamma.

 -- Función: solve_rec_rat (EQN, VAR, [INIT])

     Calcula las soluciones racionales de las expresiones recurrentes lineales. Véase solve_rec para la descripción de sus argumentos.

     Para hacer uso de esta función ejecútese previamente load(solve_rec);.

     Ejemplo:

          (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
          (%o1)  (x + 4) a      + (x + 3) a      - x a
                          x + 3            x + 2      x + 1
                                                             2
                                                         + (x  - 1) a
                                                                      x
          (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
                                 1
          (%o2)      a  = ---------------
                      x   (x - 1) (x + 1)

     Véase también solve_rec.

 -- Variable opcional: product_use_gamma
     Valor por defecto:true

     Si product_use_gamma vale true,  solve_rec introduce la función gamma en la expresión del resultado cuando se simplifican productos.

     Véanse también simplify_products y solve_rec.

 -- Función: summand_to_rec (SUMMAND, K, N)

     Devuelve la expresión recurrente que satisface la suma

              inf
              ====
              \
               >     sumando
              /
              ====
            k = minf

     donde el sumando es hipergeométrico en  K y N.

     Para hacer uso de esta función deben cargarse previamente los paquetes zeilberger y solve_rec mediante la ejecución de las sentencias load(solve_rec) y load(zeilberger).

          (%i17) load("zeilberger")$
          (%i18) summand: binom(3*k+1,k)*binom(3*(n-k),n-k)/(3*k+1)$
          (%i19) summand_to_rec(summand, k, n);
          Dependent equations eliminated:  (3 2)
          (%o19) - 4 (n + 2) (2 n + 3) (2 n + 5) sm
                                                   n + 2
                              2
           + 12 (2 n + 3) (9 n  + 27 n + 22) sm
                                               n + 1
           - 81 (n + 1) (3 n + 2) (3 n + 4) sm
                                              n
          (%i21) sum(''summand, k, 0, n), n=0;
          (%o21)                       1
          (%i22) sum(''summand, k, 0, n), n=1;
          (%o22)                       4
          (%i23) product_use_gamma: false$
          (%i24) solve_rec(%o19, sm[n], sm[0]=1, sm[1]=4);
                        n - 1               n - 1
                        /===\               /===\
                         ! !                 ! !                n
                       ( ! !   (3 %j + 2)) ( ! !   (3 %j + 4)) 3
                         ! !                 ! !
                        %j = 0              %j = 0
          (%o24) sm  = ------------------------------------------
                   n            n - 1
                                /===\
                                 ! !                n
                               ( ! !   (2 %j + 3)) 2  n!
                                 ! !
                                %j = 0