FUNCTION: zeilb - summation of terminating hypergeometric series by
Zeilberger's algorithm.
Copyright 1992, 1996, 1998, 2000 by Tom H. Koornwinder (thk@science.uva.nl)

VERSION: December 9, 2000, for Maple 6.
The 1992 version was a completely rewritten version of a Maple procedure
ident_prover.maple by D. Zeilberger.
The 1996 version was adapted to Maple V, Release 3 and 4.
The 1998 version was adapted to Maple V, Release 4 and 5.
The present version works in Maple 6, as well as in Maple V, Release 4 and 5.

CALLING SEQUENCE:
zeilb([a1, a2, ... ], [b1, b2, ... ], z, f(n), l, t)

PARAMETERS:
[a1, a2, ... ] - list of numerator coefficients
[b1, b2, ... ] - list of denominator coefficients
z - argument of hypergeometric function
n - truncate hypergeometric series as a sum from 0 to n
f(n) - user proposed name of truncated hypergeometric series as function of n
l - required order of recurrence looked for in Zeilberger's algorithm
t - optional, positive integer determining talklevel of output,
	default max(1,printlevel)

DESCRIPTION:
- The function zeilb(a,b,z,f(n),l) tries to evaluate (if l=0 or 1)
  the truncated hypergeometric series
f(n):=sum(fac(a1,k) * fac(a2,k) ... / (fac(b1,k) * fac(b2,k) * ... ) / k! * z^k,
      k=0..n)
  where the shifted factorial fac(c,k) is defined as
    GAMMA(c+k) / GAMMA(c)
  If l>1 then the function tries to find a recurrence relation in n
  of order l for this series.

- If l>=1 then one of the numerator coefficients must equal -n.

- If l=0 then Gosper's algorithm is applied.

- If l=0 or 1 and if evaluation of the sum
  is possible for all n=0,1,2, ... as a quotient of products
  of shifted factorials then the function will return in this form,
  with the notation fac(c,k) being used for the shifted factorial.

- In all other cases, where the algorithm succeeds, the function will return
  as a recurrence expressing f(n) in terms of
  f(n-1), f(n-2), ... , f(n-l),
  followed by the inequality n>n1 for which the recurrence is valid.

- If the algorithm fails then nothing is returned.

- If  l>0, t>2 and the algorithm succeeds then a short proof of the
  outcome will be printed. There f(n,k) will denote the k th term of f(n).

- This function should be defined by inputting the file zeilb
  with the read command.

- The code has been tested in Maple 6

EXAMPLES:
> read zeilb:
> zeilb([-n,b],[c],1,f(n),1);

                            fac(-b + c, n)
                            --------------
                              fac(c, n)

> zeilb([b],[ ],1,f(n),0);

                          (b + n) fac(b, n)
                          -----------------
                             fac(1, n) b

> zeilb([-n,b,c+1],[b+1,c],1,f(n),1);

                          n f(n - 1)
                          ----------, 1 < n
                            b + n

> zeilb([-n,b],[c],z,f(n),2);

  (z n + z b - c + 2 - 2 n - z) f(n - 1)   (z - 1) (n - 1) f(n - 2)
- -------------------------------------- + ------------------------,
                n - 1 + c                         n - 1 + c

    1 < n

> zeilb([-n,n+3,-y],[2,z],1,g(n),2);

  (z + 2 y) (2 n + 1) g(n - 1)   (n - 1) (n - z + 2) g(n - 2)
  ---------------------------- + ----------------------------, 1 < n
      (n + 2) (n + z - 1)            (n + 2) (n + z - 1)

> zeilb([-n,n+3,y+z],[2,z],1,h(n),2); 

   (z + 2 y) (2 n + 1) h(n - 1)   (n - 1) (n - z + 2) h(n - 2)
 - ---------------------------- + ----------------------------, 1 < n
       (n + 2) (n + z - 1)            (n + 2) (n + z - 1)

> 
# Thus for the last two inputs g(n)=(-1)^n * h(n). (Check case n=1 by hand.)