print(`Version of Aug. 8, 1996`):
lprint(``):
 
print(`This is rabbit, a small Maple package`):
print(`accompanying the paper `):
print(`"A condensed condensation proof of a determinant evaluation`):
print(`conjectured by Greg Kuperberg and Jim Propp"`):
print(`by Tewodros Amdeberhan and Shalosh B. Ekhad `):
lprint(``):
print(`The most current version is available on WWW at:`):
print(` http://www.math.temple.edu/~ekhad .`):
lprint(``):
print(`The paper itself is also available there, or at`):
print(` http://www.math.temple.edu/~tewodros .`):
 
print(`Please report all bugs to: zeilberg@math.temple.edu .`):
print(`All bugs or other comments used will be acknowledged in future`):
print(`versions.`):
lprint(``):
print(`For general help, and a list of the available functions,`):
print(` type "ezra();". For specific help type "ezra(procedure_name)" `):
lprint(``):
 
 
 
ezra:=proc()
if args=NULL then
print(`rabbit`):
print(`A small Maple package for  simplifying`):
print(` expressions involving the double factorial a!!`):
print(`and for verifying the recurrence implied by Dodgson's`):
print(`condensation rule for conjectured expressions for determinants`):
print(`in which there is a conjectured expression for any consecutive minor`):
lprint(``):
print(`For help with a specific procedure, type "ezra(procedure_name);"`):
print(`Contains procedures: `):
print(`pashet2, Lewis`):
fi:
 
 
if nops([args])=1 and op(1,[args])=`pashet2` then
print(`pashet2(expres): simplifies a quotient of products of`):
print(` double-factorials`):
print(` a!!:=1!2!...a!. a!! should be written TP(a)`):
print(`The input is expres. For example  pashet2(TP(a+1)/TP(a)/(a-1)!)`):
print(`should give a(a+1)`):
 
fi:
 
 
if nops([args])=1 and op(1,[args])=`Lewis` then
print(`Lewis(X,a,b,m): verifies that X(a,b,m) satisfies the recurrence`):
lprint(X(m,a,b),`=`):
print((X(m-1,a,b)*X(m-1,a+1,b+1)-X(m-1,a+1,b)*X(m-1,a,b+1))/X(m-2,a+1,b+1)):
lprint(``):
print(`X(m,a,b) should be given in terms of factorials`):
print(` and double factorials`):
 
print(`The procedures computes the ratio of the right side to the left side.`):
print(`If the output is 1, the recurrence is correct, otherwise, not`):
fi:
 
 
end:
 
 
with(linalg):
 
X1:=TP(a+n)*TP(n-1)*TP(a-b-1)*TP(b)/TP(a)/TP(a-b+n-1)/TP(b+n):
 
X2:=
(2*n+1)!^(m+1)*TP(2*n-m)*TP(m)*TP(m+a+b)*TP(2*n-m-a-b)/
TP(2*n+1)/TP(n-a)/TP(n-b)/TP(m+a)/TP(m+b)*
TP(n-m-a-1)*TP(n-m-b-1)*TP(a)*TP(b)*(a+b)!/TP(2*n-2*m-a-b-1)/TP(a+b)/a!/b!
:
 
 
pashet:=proc(top1,bot1) 
local i,lu,gu,mu:
 
if not( type (top1, function) and type(bot1,function)) then
 RETURN(0):
fi:
 
if not( op(0,top1)=TP and op(0,bot1)=TP ) then
 RETURN(0):
fi:
 
mu:=expand(op(1,top1)-op(1,bot1)):
 
if not type(mu,integer) then
  RETURN(0):
fi:
 
if mu=0 then
RETURN(1):
fi:
 
 
if mu>0 then
gu:=op(1,bot1):
 lu:=1:
 for i from 1 to mu do
   lu:=lu*(gu+i)!:
 od:
RETURN(lu):
fi:
 
 
 
if mu<0 then
mu:=-mu:
gu:=op(1,top1):
 lu:=1:
 for i from 1 to mu do
   lu:=lu/(gu+i)!:
 od:
RETURN(lu):
fi:
end:
 
 
pashet1:=proc(bitu)
local i,j,mone,mekh,bitu1,khelek1,khelek2,lu:
 
bitu1:=normal(bitu):
mone:=numer(bitu1):
mekh:=denom(bitu1):
 
if type(mone,`*`) and type(mekh,`*`) then
for i from 1 to nops(mone) do
khelek1:=op(i,mone):
if type(khelek1,`^`) then
 khelek1:=op(1,khelek1):
fi:
for j from 1 to nops(mekh) do
khelek2:=op(j,mekh):
if type(khelek2,`^`) then
 khelek2:=op(1,khelek2):
fi:
 
lu:=pashet(khelek1,khelek2) :
 
if lu<>0 then
 RETURN(normal(simplify(bitu1/khelek1*khelek2)), lu):
fi:
od:
od:
fi:
 
 
 
 
if type(mone,`*`) and (type(mekh,`^`)  or type(mekh,function)) then
for i from 1 to nops(mone) do
khelek1:=op(i,mone):
if type(khelek1,`^`) then
 khelek1:=op(1,khelek1):
fi:
 
khelek2:=mekh:
if type(khelek2,`^`) then
 khelek2:=op(1,khelek2):
fi:
 
lu:=pashet(khelek1,khelek2) :
 
if lu<>0 then
 RETURN(normal(simplify(bitu1/khelek1*khelek2)), lu):
fi:
od:
 
fi:
 
 
if type(mekh,`*`) and (type(mone,function) or type(mone,`^`)) then
 
khelek1:=mone:
if type(khelek1,`^`) then
 khelek1:=op(1,khelek1):
fi:
for j from 1 to nops(mekh) do
khelek2:=op(j,mekh):
if type(khelek2,`^`) then
 khelek2:=op(1,khelek2):
fi:
 
lu:=pashet(khelek1,khelek2) :
 
if lu<>0 then
 RETURN(normal(simplify(bitu1/khelek1*khelek2)), lu):
fi:
od:
fi:
 
 
 
 
if type(mone,function ) and type(mekh,function) then
lu:=pashet(mone,mekh) :
if lu<>0 then
 RETURN(normal(simplify(bitu1/mone*mekh)), lu):
fi:
 
fi:
 
 
if type(mone,`^`) then
 khelek1:=op(1,mone):
else
 khelek1:=mone:
fi:
 
 
if type(mekh,`^`) then
 khelek2:=op(1,mekh):
else
 khelek2=mekh:
fi:
 
lu:=pashet(khelek1,khelek2) :
if lu<>0 then
 RETURN(normal(simplify(bitu1/khelek1*khelek2)), lu):
fi:
 
 
 
 
0:
end:
 
 
pashet2:=proc(bitu)
local mu,lu,gu,bitu1:
gu:=1:
bitu1:=bitu:
mu:=1:
while mu<>0 do
mu:=pashet1(bitu1):
 
if mu=0 then
RETURN(normal(expand(simplify(expand(bitu1*gu))))):
fi:
 
lu:=mu[2]:
 
 
bitu1:=mu[1]:
gu:=gu*lu:
od:
 
normal(expand(simplify(expand(bitu1*gu)))):
end:

Lewis:=proc(X,a,b,m):

 
gu1:=subs(m=m-1,X)*subs({m=m-1,a=a+1,b=b+1},X)/X/subs({m=m-2,a=a+1,b=b+1},X):
 
gu2:=subs({m=m-1,a=a+1},X)*
subs({m=m-1,b=b+1},X)/X/subs({m=m-2,a=a+1,b=b+1},X):

gu1:=normal(simplify(gu1)):
gu2:=normal(simplify(gu2)):
gu1:=pashet2(gu1):
gu2:=pashet2(gu2):

gu1:=factor(gu1):
gu2:=factor(gu2):
print(`(R(m-1,a,b)*R(m-1,a+1,b+1))/R(m,a,b)/R(m-2,a+1,b+1) =` ):
print(gu1):

print(`and`):

print(`(R(m-1,a+1,b)*R(m-1,a,b+1))/R(m,a,b)/R(m-2,a+1,b+1) =`):
print(gu2):

end: