@c English version: 2010-11-01
@menu
* Introducción a solve_rec::
* Funciones y variables para solve_rec::
@end menu

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

El paquete @code{solve_rec} resuelve expresiones recurrentes lineales con
coeficientes polinomiales.

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

Ejemplo:

@example
(%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)
@end example

@node Funciones y variables para solve_rec,  , Introducción a solve_rec, solve_rec

@section Funciones y variables para solve_rec


@deffn {Función} reduce_order (@var{rec}, @var{sol}, @var{var})

Reduce el orden de la expresión recurrente lineal @var{rec} cuando
se conoce una solución particular @var{sol}. La recurrencia
reducida puede utilizarse para obterner más soluciones.

Ejemplo:

@example
(%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
             ====        j
             \      (- 1)
       %k  n  >    -------- + %k  n
         2   /     (j + 1)!     1
             ====
             j = 0
@end example

@end deffn

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

Si @code{simplify_products} vale @code{true}, @code{solve_rec} intentará
simplificar los productos del resultado.

Véase también @code{solve_rec}.

@end defvr



@deffn {Función} simplify_sum (@var{expr})

Intenta reducir todas las sumas que aparecen en @var{expr} a una forma
cerrada.

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

Ejemplo:

@c ===beg===
@c load("simplify_sum")$
@c sum(binomial(n+k,k)/2^k, k, 1, n) + sum(binomial(2*n, 2*k), k, 1,n);
@c simplify_sum(%);
@c ===end===
@example
(%i1) load("simplify_sum")$
@group
(%i2) sum(binomial(n+k,k)/2^k,k,1,n)+sum(binomial(2*n,2*k),k,1,n);
        n                          n
       ====                       ====
       \     binomial(n + k, k)   \
(%o2)   >    ------------------ +  >    binomial(2 n, 2 k)
       /              k           /
       ====          2            ====
       k = 1                      k = 1
@end group
@group
(%i3) simplify_sum(%);

                         2 n - 1    n
(%o3)                   2        + 2  - 2
@end group
@end example


@end deffn


@deffn {Función} solve_rec (@var{eqn}, @var{var}, [@var{init}])

Obtiene las soluciones hipergeométricas de la expresión recurrente @var{eqn}
con coeficientes lineales en la variable @var{var}. Los argumentos opcionales
@var{init} son condiciones iniciales.

La función @code{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 @code{load(solve_rec);}.

Ejemplo de recurrencia lineal con coeficientes constantes:

@example
(%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
@end example

Ejemplo de recurrencia lineal con coeficientes polinomiales:

@example
(%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
@end example

Ejemplo de recurrencia de Ricatti:

@example
(%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
@end example


Véanse también @code{solve_rec_rat}, @code{simplify_products} y @code{product_use_gamma}.

@end deffn

@deffn {Función} solve_rec_rat (@var{eqn}, @var{var}, [@var{init}])

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

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

Ejemplo:

@example
(%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)
@end example

Véase también @code{solve_rec}.

@end deffn

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

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

Véanse también @code{simplify_products} y @code{solve_rec}.

@end defvr

@deffn {Función} summand_to_rec (@var{summand}, @var{k}, @var{n})

Devuelve la expresión recurrente que satisface la suma

@example
    inf
    ====
    \
     >     sumando
    /
    ====
  k = minf
@end example

donde el sumando es hipergeométrico en  @var{k} y @var{n}.

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

@example
(%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
@end example

@end deffn

