#------------------ begin program file ---------------- diff1 := proc(f,v,n) option remember: if n=0 then RETURN(normal(f)): fi: if n>0 then RETURN(normal(diff(diff1(f,v,n-1),v))): fi: end: pashet:=proc(p,N) local i,gu,p1: p1:=expand(p): gu:=0: for i from 0 to degree(p,N) do gu:=gu+factor(coeff(p1,N,i))*N^i: od: RETURN(gu): end: nor:=proc(bitu) local i,gu: gu:=0: if type(bitu,`+`) then for i from 1 to nops(bitu) do gu:=gu+normal(op(i,bitu)): od: else gu:=normal(bitu): fi: gu: end: #cv is a program that inputs a functional equation,eq, in #R1(n,y1,y2,m), Y1R1(n,y1,y2,m)(D_y1 R1),R2(n,y1,y2,m), #Y2R2(n,y1,y2,m)(=D_y2 R2) and some proposed Change of dependent Variables #(and hence called cv) OldR1:=NewR1*S1, OldR2:=NewR2*S2. The output is the #functional equation in the NewR1,NewR2. Another part of the input is S1P #(P for previous)S2P, where R1Ancient=S1P*OldR1,R2Ancient=S1P*OldR2, the second and third #part o f the output is the realtion between R1Ancient and R1new, etc, #i.e. S1P*S1, S2P*S2 cv:=proc(S1P,S2P,S3P,S1,S2,S3,eq,y1,y2,m) local gu: gu:=eq: gu:=subs(R1=R1*S1,gu): gu:=subs(R2=R2*S2,gu): gu:=subs(R3=R3*S3,gu): gu:=subs(Y1R1=S1*Y1R1+diff(S1,y1)*R1,gu): gu:=subs(Y2R2=subs(y2=y2+1,S2)*Y2R2,gu): gu:=subs(MR3=subs(m=m+1,S3)*MR3,gu): nor(gu),simplify(S1*S1P),simplify(S2*S2P),simplify(S3*S3P): end: #rf converts (a)_y (Raising Factorial) to GAMMA rf:=proc(a,y) GAMMA(a+y)/GAMMA(a): end: #This program fa, finds the functional equation for the rational functions #R1(n,y1,k1,k2),R2(n,y1,y2), satisfying, for a given CF #P(n,y1,y2) F(n,y1,y2) (P(n,y1,y2) being polynomial) the functional #equation #Operator(N,n)F #D_y1 (R1(n,y1,y2)F)+ #D_y2 (R2(n,y1,y2)F(n,y1,y2)) fa:=proc(P,F,n,y1,y2,m,ORDER,disorcon) local i,gu,lu: gu:=P: if disorcon=continuous then lu:=P*F: for i from 1 to ORDER do lu:=diff(simplify(log(lu)),n)*lu: gu:=gu+a.i*simplify(lu/F): od: else for i from 1 to ORDER do gu:=gu+a.i*subs(n=n+i,P)*simplify(subs(n=n+i,F)/F): od: fi: gu:=gu*Smol- Y1R1-R1*normal(diff(simplify(log(F)),y1)) -Y2R2*simplify(subs(y2=y2+1,F)/F)+R2 -MR3*simplify(subs(m=m+1,F)/F)+R3: end: finddeg:=proc(eq,R1,Y1R1,x): degree(eq,x)-max(degree(coeff(eq,R1),x),degree(coeff(eq,Y1R1),x)): end: #A program that multiplies a polynomial pol by an equation #in R1,R2,Y1R1,Y2R2 multpa:=proc(eq,pol) local pu,i: if type(eq,`+`) then pu:=0: for i from 1 to nops(eq) do pu:=pu+normal(op(i,eq)*pol): od: RETURN(pu): else RETURN(normal(eq*pol)): fi: end: #A program that given a differential equation in R1(y1,y2), #Y1R1:=D_y1 R1(y1,y2), R2(y1,y2), Y2R2:=D_y2 R2(y1,y2), and #prescribed degrees degR1y1,degR1y2,tdegR1,degR2y1,degR2y2,tdegR2 #and prescribed ORDER #solves a given equation eq=0 #ptorpols(eq,y1,y2,degR1y1,degR1y2,tdegR1,degR2y1,degR2y2,tdegR2) #eq is the equation,y1,y2, are the variables spec:=proc(a,dk,dl,dm,tdeg,davar) local i,j,j1,gu: gu:=davar: for i from 0 to dk do for j from 0 to min(dl,tdeg-i) do for j1 from 0 to min(dm,tdeg-i-j) do gu:=subs(a.i.j.j1=0,gu): od: od: od: RETURN(gu): end: #Procedure genpol generates a generic polynomial with degree dk in k #and degree dl in l, and total degree tdeg, the coefficients are #a.i.j genpol:=proc(a,k,l,m,dk,dl,dm,tdeg) local i,j,j1,gu,gu1: gu1:={}: gu:=0: for i from 0 to dk do for j from 0 to min(dl,tdeg-i) do for j1 from 0 to min(dm,tdeg-i-j) do gu:=gu+(a.i.j.j1)*k^i*l^j*m^j1: gu1:=gu1 union {a.i.j.j1}: od: od: od: RETURN(gu,gu1): end: ptorpols:=proc(e,y1,y2,m,degR1y1,degR1y2,degR1y3,tdegR1, degR2y1,degR2y2,degR2y3,tdegR2,degR3y1,degR3y2,degR3y3,tdegR3,ORDER,N) local i,j,j1,eq,equ,var,pol1,pol2,pol3,Y1pol1,Y2pol2, Y3pol3,d1,d2,d3,d4,glu,lu,ope: ope:=1: for i from 1 to ORDER do ope:=ope+a.i*N^i: od: var:={}: for i from 1 to ORDER do var:=var union {a.i} od: eq:=e: pol1:=genpol(a,y1,y2,m,degR1y1,degR1y2,degR1y3,tdegR1): var:=var union pol1[2]: pol1:=pol1[1]: pol2:=genpol(b,y1,y2,m,degR2y1,degR2y2,degR2y3,tdegR2): var:= var union pol2[2]: pol2:=pol2[1]: pol3:=genpol(c,y1,y2,m,degR3y1,degR3y2,degR3y3,tdegR3): var:= var union pol3[2]: pol3:=pol3[1]: Y1pol1:=diff(pol1,y1): Y2pol2:=expand(subs(y2=y2+1,pol2)): Y3pol3:=expand(subs(m=m+1,pol3)): eq:=subs(R1=pol1,eq): eq:=subs(R2=pol2,eq): eq:=subs(R3=pol3,eq): eq:=subs(Y1R1=Y1pol1,eq): eq:=subs(Y2R2=Y2pol2,eq): eq:=subs(MR3=Y3pol3,eq): eq:=expand(eq): equ:={}: d1:=degree(eq,y1): d2:=degree(eq,y2): d3:=degree(eq,m): d4:=degree(eq,{y1,y2,m}): for i from 0 to d1 do for j from 0 to min(d2,d4-i) do for j1 from 0 to min(d3,d4-i-j) do glu:=coeff(coeff(coeff(eq,y1,i),y2,j),m,j1): if glu<>0 then equ:=equ union {glu=0}: fi: od: od: od: lu:=solve(equ,var): if lu=NULL then RETURN(0): fi: pol1:=subs(lu,pol1): pol2:=subs(lu,pol2): pol3:=subs(lu,pol3): ope:=subs(lu,ope): pol1:=spec(a,degR1y1,degR1y2,degR1y3,tdegR1,pol1): pol1:=spec(b,degR2y1,degR2y2,degR2y3,tdegR2,pol1): pol1:=spec(c,degR3y1,degR3y2,degR3y3,tdegR3,pol1): pol2:=spec(a,degR1y1,degR1y2,degR1y3,tdegR1,pol2): pol2:=spec(b,degR2y1,degR2y2,degR2y3,tdegR2,pol2): pol2:=spec(c,degR3y1,degR3y2,degR3y3,tdegR3,pol2): pol3:=spec(a,degR1y1,degR1y2,degR1y3,tdegR1,pol3): pol3:=spec(b,degR2y1,degR2y2,degR2y3,tdegR2,pol3): pol3:=spec(c,degR3y1,degR3y2,degR3y3,tdegR3,pol3): ope:=spec(a,degR1y1,degR1y2,degR1y3,tdegR1,ope): ope:=spec(b,degR2y1,degR2y2,degR2y3,tdegR2,ope): ope:=spec(c,degR3y1,degR3y2,degR3y3,tdegR3,ope): pol1:=factor(pol1): pol2:=factor(pol2): pol3:=factor(pol3): RETURN(ope,pol1,pol2,pol3); end: #Like ptorpolstik, but with random assignments of the parameters in #the list resh ptorpolstik:=proc(e,y1,y2,m,degR1y1,degR1y2,degR1y3,tdegR1, degR2y1,degR2y2,degR2y3,tdegR2,degR3y1,degR3y2,degR3y3,tdegR3, ORDER,resh) local i,j,j1,eq,equ,var,pol1,pol2,pol3,Y1pol1,Y2pol2,Y3pol3, d1,d2,d3,d4,glu,lu,ra: ra:=2: eq:=e: for i from 1 to nops(resh) do eq:=subs(op(i,resh)=ra,eq): od: var:={}: for i from 1 to ORDER do var:=var union {a.i} od: pol1:=genpol(a,y1,y2,m,degR1y1,degR1y2,degR1y3,tdegR1): var:=var union pol1[2]: pol1:=pol1[1]: pol2:=genpol(b,y1,y2,m,degR2y1,degR2y2,degR2y3,tdegR2): var:= var union pol2[2]: pol2:=pol2[1]: pol3:=genpol(c,y1,y2,m,degR3y1,degR3y2,degR3y3,tdegR3): var:= var union pol3[2]: pol3:=pol3[1]: Y1pol1:=diff(pol1,y1): Y2pol2:=expand(subs(y2=y2+1,pol2)): Y3pol3:=expand(subs(m=m+1,pol3)): eq:=subs(R1=pol1,eq): eq:=subs(R2=pol2,eq): eq:=subs(R3=pol3,eq): eq:=subs(Y1R1=Y1pol1,eq): eq:=subs(Y2R2=Y2pol2,eq): eq:=subs(MR3=Y3pol3,eq): eq:=expand(eq): equ:={}: d1:=degree(eq,y1): d2:=degree(eq,y2): d3:=degree(eq,m): d4:=degree(eq,{y1,y2,m}): for i from 0 to d1 do for j from 0 to min(d2,d4-i) do for j1 from 0 to min(d3,d4-i-j) do glu:=coeff(coeff(coeff(eq,y1,i),y2,j),m,j1): if glu<>0 then equ:=equ union {glu=0}: fi: od: od: od: lu:=solve(equ,var): if lu<> NULL then RETURN(1): else RETURN(0): fi: end: findope:=proc(P,F,n,y1,y2,m,ORDER,resh,N,S1,S2,S3,disorcon) local eq,gu,degR1y1,degR1y2,degR1m,tdegR1,degR2y1,degR2y2,degR2m,tdegR2, degR3y1,degR3y2,degR3m,tdegR3,G,ope,R_1,R_2,R_3,mekh: eq:=fa(P,F,n,y1,y2,m,ORDER,disorcon): eq:=subs(Smol=1,eq): gu:=cv(1,1,1,S1,S2,S3,eq,y1,y2,m): eq:=gu[1]; eq:=numer(normal(eq)): degR1y1:=finddeg(eq,R1,Y1R1,y1); degR1y2:=finddeg(eq,R1,Y1R1,y2); degR1m:=finddeg(eq,R1,Y1R1,m); tdegR1:=degR1y1+degR1y2+degR1m: degR2y1:=finddeg(eq,R2,Y2R2,y1); degR2y2:=finddeg(eq,R2,Y2R2,y2); degR2m:=finddeg(eq,R2,Y2R2,m); tdegR2:=degR2y1+degR2y2+degR2m: degR3y1:=finddeg(eq,R3,Y3R3,y1); degR3y2:=finddeg(eq,R3,Y3R3,y2); degR3m:=finddeg(eq,R3,Y3R3,m); tdegR3:=degR3y1+degR3y2+degR3m: gu:=ptorpolstik(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3, ORDER,resh): if gu=0 then degR1y1:=degR1y1+1: degR1y2:=degR1y2+1: degR1m:=degR1m+1: tdegR1:=tdegR1+3: degR2y1:=degR2y1+1: degR2y2:=degR2y2+1: degR2m:=degR2m+1: tdegR2:=tdegR2+3: degR3y1:=degR3y1+1: degR3y2:=degR3y2+1: degR3m:=degR3m+1: tdegR3:=tdegR3+3: gu:=ptorpolstik(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3, ORDER, resh): if gu=0 then print(`probably ORDER is too low, or S1,S2,S3, are inappropriate, try`): print(`different ones`): fi: gu:=ptorpols(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3,ORDER,N); if gu=0 then degR1y1:=degR1y1+1: degR1y2:=degR1y2+1: degR1m:=degR1m+1: tdegR1:=tdegR1+3: degR2y1:=degR2y1+1: degR2y2:=degR2y2+1: degR2m:=degR2m+1: tdegR2:=tdegR2+3: degR3y1:=degR3y1+1: degR3y2:=degR3y2+1: degR3m:=degR3m+1: tdegR3:=tdegR3+3: gu:=ptorpolstik(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3, ORDER, resh): if gu=0 then print(`probably ORDER is too low, or S1,S2,S3, are inappropriate, try`): print(`different ones`): else gu:=ptorpols(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3,ORDER,N); if(gu=0) then print(`probably ORDER is too low, or S1,S2,S3 are inappropiate,try`): print(`different ones`): fi: fi: fi: fi: if gu=0 then print(`Sorry, try a higher order recurrence`): fi: if gu=1 then gu:=ptorpols(eq,y1,y2,m,degR1y1,degR1y2,degR1m,tdegR1, degR2y1,degR2y2,degR2m,tdegR2,degR3y1,degR3y2,degR3m,tdegR3,ORDER,N) fi: if gu=0 then print(`Sorry`): fi: ope:=gu[1]: R_1:=gu[2]*S1: R_2:=gu[3]*S2: R_3:=gu[4]*S3: ope:=normal(ope): mekh:=denom(ope): ope:=numer(ope): ope:=pashet(ope,N): R_1:=normal(R_1*mekh): R_2:=normal(R_2*mekh): R_3:=normal(R_3*mekh): ope,[R_1,R_2,R_3]: end: writepap:=proc(P,F,n,y1,y2,m,N,ope,R1,R2,R3,disorcon) local G: lprint(`Theorem:`): lprint(``): lprint(`Let G(`,y1,`,`,y2,`,`,m,`,`,n,`) be`): lprint(``): print(P*F,``): lprint(``): lprint(`and a(`,n,`) be its integral w.r.t to`,y1,`,sum w.r.t.`,m,y2,`.`): lprint(``): if disorcon=continuous then lprint(`Let`,N,`be differentiation w.r.t.`,n,`.`): lprint(``): lprint(`The function a(`,n,`) satisfies the recurrence`): else lprint(`Let`,N,`be the forward shift operator in`,n,`.`): lprint(``): lprint(`The sequence a(`,n,`) satisfies the recurrence`): fi: lprint(``): print(ope*a(n)=`0.`): lprint(``): lprint(`Proof: It is routinely verifiable that`): lprint(``): print(ope*G(y1,y2,m,n)): lprint(``): lprint(`= D_`,y1,`(`): lprint(``): print(R1*G(y1,y2,m,n)/P): lprint(` )`): lprint(``): lprint(`+(E_`, y2,`-I)(`): lprint(``): print(R2*G(y1,y2,m,n)/P): lprint(``): lprint(`+(E_`, m,`-I)(`): lprint(``): print(R3*G(y1,y2,m,n)/P): lprint(` ),`): lprint(``): lprint(`and the result follows by integrating w.r.t `): lprint(y1,`,`,`and summing w.r.t.`,y2,m,`.`): end: checkeq:=proc(F,n,y1,k1,k2,N,ope,R1,R2,R3,disorcon) local Lf,i,ope1,Rt: if nargs<>11 then ERROR(` Wrong number of arguments`): fi: if not member(disorcon,{discrete,continuous}) then ERROR(args[nargs], ` must be {discrete,continuous}`): fi: ope1:=expand(ope): if disorcon=continuous then Lf:=0: for i from ldegree(ope1,N) to degree(ope1,N) do Lf:=Lf+simplify(coeff(ope1,N,i)*diff1(F,n,i)/F): od: else Lf:=0: for i from ldegree(ope1,N) to degree(ope1,N) do Lf:=Lf+simplify(coeff(ope1,N,i)*subs({n=n+i},F)/F) : od: fi: Rt:=diff(R1,y1)+R1*normal(diff(simplify(log(F)),y1))+ subs({k1=k1+1},F*R2)/F - R2 +subs({k2=k2 + 1},F*R3)/F - R3: simplify(Lf-Rt): end: #-------------end program--------------------------- #P:=1: #F:=rf(al+1,n)*rf(be+1,n)/n!/rf(al+be+1,n)/t^(n+1)* #(1+t)^(-al-be-1)*rf(al+be+1,2*(m+n1))/n1!/m!/rf(al+1,n1)/rf(be+1,m)* #(t/(4*(1+t)^2))^(m+n1)* #(1+x)^m*(1+y)^m*(1-x)^n1*(1-y)^n1; #ORDER:=2: #resh:=[al,be,x,y,n]: #S1:=1/(t+1): #S2:=(n1+al)*n1: #S3:=m*(m+be): #disorcon:=continuous: #cer:=findope(P,F,x,t,n1,m,ORDER,resh,D_x,S1,S2,S3,disorcon); #checkeq(F,x,t,n1,m,D_x,cer[1],cer[2][1],cer[2][2],cer[2][3],disorcon); #_______________________________ HELP INFORMATION ________________________________ print(`THIS IS VERSION 1.1 OF THE MAPLE PACKAGE multi1c2d FOR `): print(`INTEGRAND/SUMMANDS DEPENDING OF ONE CONTINUOUS(INTEGRATION) VARIABLE `): print(`AND TWO DISCRETE(SUMMATION) VARIABLES`): print(` `): print(`THE PREOGRAM multi1c2d BASED ON THE PAPER BY:` ): print(`WILF AND ZEILBERGER:"AN ALGORITHMIC PROOF THEORY FOR (ORDINARY AND 'q')`): print(`MULTISUMS/INTEGRAL HYPERGEOMETRIC IDENTITIES(Invent. Math. 108(1992)`): print(`pp.575-633).`): print(` `): print(`The primilary version of the program was written by Doron Zeilberger`): print(` Please report all bugs and comments to: zeilberg@math.temple.edu`): print(` or akalu@math.temple.edu`): print(` `): print(` For a list of procedures, type:`): print(` ?muti1c2d or help(muti1c2d) `): print(` `): print(` For help with a specific procedure, type:`): print(`?procedure name or help(procedure name) `): print(` Copy write 1998, Akalu Tefera`): `help/text/multi1c2d`:=TEXT( ` `, `This package contains procedures: `, ` findope`, ` writepap`, ` rf`, ` checkeq`, ` `, ` `, `To get help for a specific procedure, type: `, ` ?procedure name or help(procedure name)`, ` `, ` ` ): # .... the help information for the PROCEDURE findope .... `help/text/findope`:=TEXT( `FUNCTION: findope: finds a recurrence( or differential) operator with `, ` rational certificates`, ` `, `CALLING SEQUENCE: findope(P,F,x,y1,k1,k2,ORDER,axpar,D_x,S1,S2,S3,disorcon)`, ` `, `PARAMETERS: `, ` P : polynomial`, ` F : purely factorial/exponential`, ` x : auxiliary var. w.r.t which the desired differential(or`, ` recurrence) operator is`, ` y1 : continuous(integration) var.`, ` k1, k2 : discrete(summation) vars`, ` ORDER : postive integer (guessed order of the differential`, ` (recurrence) operator`, ` axpar : list of the other auxiliary parameters`, ` D_x : the symbol designating differentiation w.r.t. the `, ` auxiliary var. x, or shift if the aux. var. is discrete`, ` S1, S2, S3 : guessed factors in front of the certificates `, ` incorporating 1/< guessed denominator> and optional`, ` factors of the numerator. S1,S2,S3 correspond to the `, ` certificates w.r.t y1,k1,k2,resp.`, ` disorcon : either or according to whether `, ` the x is continuous or discrete resp.`, ` `, `SYNOPSIS: `, ` - The function findope finds a recurrence(or differential) opertaor, with `, ` rational certificates.`,` `, ` - P*F is the integrand/summand, where P is polynomial and F is "purely`, ` factorial/exponential" (P is optional, it is OK to incorporate it in the`, ` F, and put P:=1)`,` `, ` - The function findope output a recurrence operator if x is discrete and a`, ` differential opertator if x is continous.`,` `, ` `, ` - The way to guess S1, S2 and S3 is look at the functional equation`, ` that the program gives with the initial default S1,S2,S3.`, ` This part is still human.`, ` `, `EXAMPLE:`, ` >P:=1:`, ` >F:=rf(al+1,n)*rf(be+1,n)/n!/rf(al+be+1,n)/t^(n+1)*`, `(1+t)^(-al-be-1)*rf(al+be+1,2*(m+n1))/n1!/m!/rf(al+1,n1)/rf(be+1,m)*`, `(t/(4*(1+t)^2))^(m+n1)*(1+x)^m*(1+y)^m*(1-x)^n1*(1-y)^n1;`, ` `, ` (- al - be - 1)`, ` F := GAMMA(al + 1 + n) GAMMA(be + 1 + n) (1 + t)`, ` `, ` / t \(m + n1) m m`, ` GAMMA(al + be + 1 + 2 m + 2 n1) |1/4 --------| (1 + x) (1 + y)`, ` | 2|`, ` \ (1 + t) /`, ` `, ` n1 n1 /`, ` (1 - x) (1 - y) / (`, ` /`, ` (n + 1)`, ` n! GAMMA(al + be + 1 + n) t n1! m! GAMMA(al + 1 + n1) GAMMA(be + 1 + m)`, `> ORDER:=2:`, `>resh:=[al,be,x,y,n]:`, `>S1:=1/(t+1):`, `>S2:=(n1+al)*n1:`, `>S3:=m*(m+be):`, `>disorcon:=continuous:`, `>findope(P,F,x,t,n1,m,ORDER,resh,D_x,S1,S2,S3,disorcon);`, ` `, ` n (al + be + 1 + n) + (- x al - x be - 2 x - al + be) D_x`, ` `, ` 2`, ` - (- 1 + x) (1 + x) D_x ,`, ` `, ` t (- n1 + t n1 + t m - t n - m - al - be - 1 - n) (n1 + al) n1`, ` [-------------------------------------------------, 2 ------------,`, ` 1 + t - 1 + x`, ` `, ` m (m + be)`, ` - 2 ----------]`, ` 1 + x`, ` `, `SEE ALSO:`, ` writepap`, ` ` ): # .... the help information for the PROCEDURE writepap .... `help/text/writepap`:=TEXT( `FUNCTION: writepap: writes a paper with proof`, ` `, `CALLING SEQUENCE: writepap(P,F,x,y1,k1,k2,D_x,ope,R1,R2,R3,disorcon)`, ` `, `PARAMETERS: `, ` P : polynomial`, ` F : purely factorial/exponential`, ` x : auxiliary var. w.r.t which the differential(or`, ` recurrence) operator ope is`, ` y1 : continuous(integration) var.`, ` k1, k2 : discrete(summation) vars`, ` D_x : the symbol designating differentiation w.r.t. the `, ` auxiliary var. x, or shift if the aux. var. is discrete`, ` ope : differential(or recurrence) operator`, ` R1, R2, R3 : certificates corresponding to y1,k1,k2,resp.`, ` disorcon : either or according to whether `, ` the x is continuous or discrete resp.`, ` `, `SYNOPSIS: `, ` - The function writepap is complementary to findope`, ` before using this function, use findope to get ope, and the certificates `, ` R1,R2, and R3`, ` `, `EXAMPLES:`, ` >P:=1:`, ` >F:=rf(al+1,n)*rf(be+1,n)/n!/rf(al+be+1,n)/t^(n+1)*`, `(1+t)^(-al-be-1)*rf(al+be+1,2*(m+n1))/n1!/m!/rf(al+1,n1)/rf(be+1,m)*`, `(t/(4*(1+t)^2))^(m+n1)*(1+x)^m*(1+y)^m*(1-x)^n1*(1-y)^n1;`, `>ORDER:=2:`, `>resh:=[al,be,x,y,n]:`, `>S1:=1/(t+1):`, `>S2:=(n1+al)*n1:`, `>S3:=m*(m+be):`, `>disorcon:=continuous:`, `>cert:=findope(P,F,x,t,n1,m,ORDER,resh,D_x,S1,S2,S3,disorcon):`, `>ope:=cert[1]:`, `>R1:=cert[2][1]:`, `>R2:=cert[2][2]:`, `>R3:=cert[2][3]:`, `>writepap(P,F,x,y1,k1,k2,D_x,ope,R1,R2,R3,disorcon)`, ` `, `SEE ALSO:`, ` findope`, ` ` ): `help/text/rf`:=TEXT( `FUNCTION: rf: converts raising factorial to GAMMA`, ` `, `CALLING SEQUENCE: rf(a,y)`, ` `, `PARAMETERS: `, ` a : algrbraic expression`, ` y : integer`, ` `, `SYNOPSIS: `, ` - The function rf converts (a) where (a):=a(a+1)...(a+y-1) if y>=0,`, ` y y`, ` `, ` (a) := 1/(a-1)(a-2)...(a+y) if y<0`, ` y`, ` ` ): `help/text/checkeq`:=TEXT( `FUNCTION: checkeq: verifies whether a given function satisfies a given`, ` functional equation`, ` `, `CALLING SEQUENCE: checkeq(F,x,y1,k1,k2,D_x,ope,R1,R2,R3,disorcon)`, ` `, `PARAMETERS: `, ` F : algebraic expression which invloves x,y1,k1 or k2`, ` x : auxiliary var. w.r.t which the differential(or`, ` recurrence) operator ope is`, ` y1 : continuous(integration) var.`, ` k1, k2 : discrete(summation) vars`, ` D_x : the symbol designating differentiation w.r.t. the `, ` auxiliary var. x, or shift if the aux. var. is discrete`, ` ope : differential(or recurrence) operator`, ` R1, R2, R3 : certificates corresponding to y1,k1,k2,resp.`, ` disorcon : either or according to whether `, ` the x is continuous or discrete resp.`, ` `, `SYNOPSIS: `, ` - The function checkeq applies the functional operator:`,` `, ` ope - D_y1(R1*F) - Delta_k1(R2*F) - Delta_k2(R3*F)`,` `, ` on F and output the result of the action.`, ` `, ` ` ):