# This is version 1.1 of SMint: a Maple Package that contains # functions to find an annihilator of hypergeometric function by using # Multi-WZ Method. This is the updated and generalized version of the package # TRIPLE_INTEGRAL which was written by Doron Zeilberger. This package is # specially written to handle identities which involve multiple intergal of # special functions F(n,x), where F(n,x) is SYMMETRIC wrt the variable # x=(x1,...,xn). #To use it, download it as SMint, go into Maple, type read `SMint`; and follow #the instructions given there. # This package is written by Akalu Tefera # Temple University, Math Dept. # last update: May 15, 1999. # ------------------------------------------------------------------------------ # freeintgrand(intgrand, vars) return true if integrand does not contain all # the variables in vars. A message is printed in this case. freeintgrand:=proc(intgrand,vars) local i: if not type(vars,list) then ERROR(`expecting list`) fi: if member(false,convert([seq(has(intgrand,vars[i]),i=1..nops(vars))],set)) then lprint(intgrand, ` does not contain all variables in `,vars,`.`): RETURN(true) fi: RETURN(false): end: #------------------------------------------------------------------------------ # notdistvars returns true if the variable list contains multiple elements, # and false otherwise. notdistvars:=proc(vars) if not type(vars,list) then ERROR(`expecting list of vars`): fi: if nops(convert(vars,set)) = nops(vars) then false else lprint(` The variable list in input contain the same variable twice.`): true fi: end: #---------------------------------------------------------------------------- # checks the validity of the args: f, mainvar, intnvars chkargs:=proc(f,mainvar,intnvars,axvars1) local i, axvars: axvars:=axvars1: if axvars=[] then axvars:=[mainvar] fi: if notdistvars(map(op,[mainvar,intnvars])) or freeintgrand(f, map(op,[mainvar,intnvars])) or (not validaxvar(f,axvars,mainvar,intnvars)) then NULL else [seq(args[i],i=1..nargs-1),axvars]: fi: end: #------------------------------------------------------------------------------ # varfree: true if expr is free of every variable in list of vars varfree:=proc(expr,vars) local i,t: t:=[algebraic,list]: if nargs=0 then ERROR(`varfree uses 2 args`) fi: if not type([args],t) then ERROR(cat(`varfree expects its args to be of type`,convert(t,string))) fi: evalb(convert([seq(has(expr,vars[i]),i=1..nops(vars))] ,set) ={false}) end: #----------------------------------------------------------------------------- # checks the validity of axvars validaxvar:=proc(expr,axvars,mainvar,intnvars) local i: if convert(axvars,set) intersect convert(intnvars,set) = {} then if {seq(has(expr,op(i,axvars)),i=1..nops(axvars))}={true} then true else lprint(cat(convert(axvars,string),` contains parameter(s) not appearing in the integrand`)): false fi: else lprint(` vars of integration must not appear in auxiliary vars list.`): false fi: end: #----------------------------------------------------------------------------- makindx1:=proc(n) local lst,i,t: t:=[posint]: if not type([args],t) then ERROR(` Invalid input`): fi: lst:=[]: for i from 1 to n-1 do lst:=[op(lst),[i,i+1]]: od: lst: end: #--------------------------------------------------------------------------- makindx2:=proc(n1,n2,len) local indx,indxset,indxset1,temp,i,j,t: t:=[nonnegint,nonnegint,posint]: if not type([args],t) then ERROR(cat(`expecting an arg of type`,convert(t,string))) fi: if nargs(args)=0 then ERROR(` invalid input `) fi: indx := [seq(0,i=1..len)]: indxset := {}: while indx[nops(indx)] <= floor(n2/nops(indx)) do indxset:=indxset union {indx}: # increment index i := 1: while indx[i]>= floor((n2+ i*indx[i] -sum('j*indx[j]','j'=1..nops(indx)))/i) and (i2 then ERROR([args], ` must of type [[rec. equation,R_[...]=rational expr.], alg. expression]`): fi: if op(0,lhs(rec[2]))<>R_ or not type(rhs(rec[2]),algebraic) then ERROR([args], ` must of type [[rec. equation,R_[...]=rational expr.], alg. expression]`): fi: receq:=rec[1]: RC:=rhs(rec[2]): ope:=lhs(receq): Dpart:=rhs(receq): if has(ope,D_) then expr:=select(has,ope,D_) : if has(expr,D_) then ope:=ope - expr: Dpart:=Dpart+expr: fi: fi: if has(Dpart,F_) then expr:=select(has,Dpart,F_) : if has(expr,F_) and not has(expr,D_) then ope:=ope + expr: Dpart:=Dpart - expr: fi: fi: ope_vars:=extrctope_vars(ope,N): ope1:=ope_vars[1]: mainvar:=ope_vars[2]: intnvars:=ope_vars[3]: Rlst:=extrctRlst(Dpart,mainvar,intnvars): p:=Rlst[2]: Rlst:=Rlst[1]: evalrec(p,f,mainvar,intnvars,ope1,N,Rlst,RC) end: #------------------------------------------------------------------------------ extrctRlst:=proc(Dpart,mainvar,intnvars) local Rlst,i, indetset,indetset1,indx,Rindx,p: global R_,F_,D_: R_:='R_': F_:='F_': D_:='D_': indetset:=indets(Dpart): indetset:=select(type,indetset,indexed): if nops(indetset)=0 then ERROR(`rec eq must contain an expression involving D_[]`): fi: indetset1:=indetset: for i from 1 to nops(indetset) do indx:=op(i,indetset): if op(0,indx)<>D_ then indetset1:=indetset1 minus {indx}: fi: od: indetset:=convert(indetset1,list): indx:=op(1,indetset): p:=1: if op(0,indx)=D_ then p:=coeff(collect(op(2,indx),F_[mainvar,op(intnvars)]),F_[mainvar,op(intnvars)]): if type(p,indexed) then p:=1: else Rindx:=select(type,p,indexed): p:=simplify(p/Rindx): if op(0,Rindx)<> R_ then ERROR(`1 indexed variable conflict, avoid using indexed vars.`): fi: fi else ERROR(` invalid rec. equation `): fi: if p<>1 then for i from 1 to nops(indetset) do indx:=op(i,indetset): if op(0,indx)=D_ then indx:=subsop(2=simplify(op(2,indx)/p),indx): indetset:=subsop(i=indx,indetset): else ERROR(` invalid rec. equation `): fi: od: fi: Rlst:=[]: for i from 1 to nops(indetset) do indx:=op(i,indetset): Rindx:=coeff(collect(op(2,indx),F_[mainvar,op(intnvars)]),F_[mainvar,op(intnvars)]): if op(0,Rindx) = R_ then Rlst:=[op(Rlst),[op(1,indx),subsop(0=NULL,Rindx)]]: else ERROR(`2 indexed variable conflict, avoid using indexed vars.`): fi: od: [Rlst,p]: end: #--------------------------------------------------------------------------- extrctope_vars:=proc(ope,N) local mainvar,intnvars, i, expon, indetset,indx, ope1: global F_,D_: F_:='F_': D_:='D_': indetset:=indets(ope): indetset:=select(type,indetset,indexed): if nops(indetset)=0 then ERROR(` rec eq. must contain an expression involving F_[]`): fi: indx:=op(1,indetset): mainvar:=op(1,indx): mainvar:=indets(mainvar): mainvar:=select(type,mainvar,name): intnvars:=subsop(0=NULL,indx): intnvars:=subsop(1=NULL,intnvars): if nops(mainvar)=0 or nops(mainvar)<>1 then ERROR(` invalid rec. equation`): fi: mainvar:=op(mainvar): ope1:=0: for i from 1 to nops(indetset) do indx:=op(i,indetset): if op(0,indx)=F_ then expon:=simplify(op(1,indx)-mainvar): if not type(expon,nonnegint) then ERROR(` invalid rec. equation.`): fi: ope1:=ope1 + coeff(ope,indx)*N^expon: fi: od: RETURN(ope1,mainvar,intnvars): end: #----------------------------------------------------------------------------- evalrec:=proc(p,f,mainvar,intnvars,ope,N,Rlst,RC) local s,i,j,ope1,rc,r,v: s:=0: ope1:=collect(ope,N): for i from 0 to degree(ope1,N) do s:= s+ simplify(coeff(ope1,N,i)*subs(mainvar=mainvar+i,f)/f): od: for i from 1 to nops(Rlst) do rc:=Rlst[i]: r:=op(2,rc): v:=op(1,rc): if RC<>0 then j:='j': rc:=subs({seq(op(j,intnvars)=op(j,r),j=1...nops(intnvars))},RC): rc:=rc*p: s:=s-normal(diff(simplify(log(rc*f)),v)*rc): fi: od: s:=simplify(s): if s<>0 then false else true fi: end: #---------------------------------------------------------------------------- # makindx computes, given a list of nonnengative integers, a list of indices # s.t. for each entry index[i] <= min(degs[i], # tdeg-index[nops(index)]-sum(indx[j],j=1..(i-1))) holds # (for all i <= nops(degs)). makindx:=proc(degs,tdeg) local indx,indxset,i,j,t: t:=[list(nonnegint),nonnegint]: if not type([args],t) then ERROR(cat(`expecting an arg of type`,convert(t,string))) fi: if nargs(args)=0 then ERROR(` invalid input `) fi: if member(true,convert( map(proc(x) x<0 end,[op(degs),tdeg]),set)) then ERROR(cat(`expecting an arg of type`,convert(t,string))) fi: indx := [seq(0,i=1..nops(degs))]: indxset := {}: while indx[nops(indx)] <= degs[nops(degs)] do indxset:=indxset union {indx}: # increment index i := 1: while indx[i]>= min(degs[i],tdeg-indx[nops(indx)]-sum('indx[j]','j'=1..(i-1))) and (i NULL then RETURN(1): else RETURN(0): fi: end: #------------------------------------------------------------------------------- searchann2:=proc(p,f,mainvar,intnvars,axvars,mainorder,denompoly1,st) local d,dM,d1,d2,eq,gu,i,j,RC,Rvars,Rcf,ope,mekh,denompoly,extra,u,v,nv,N: global D_,F_,R_: #option remember: nv:=nops(intnvars): extra:=2*(degree(collect(denompoly1,{op(intnvars)}),{op(intnvars)}) +nv): Rvars:=[u.1,seq(v.i,i=1..nv-1)]: u:=Rvars[1]: v:=subsop(1=NULL,Rvars): denompoly:=subs({intnvars[1]=Rvars[1], seq(intnvars[j+1]=Rvars[j+1], j=1..nv-1)}, denompoly1): dM:=mainorder+extra: for d from nv to dM do # ... checking existence of rational certificate #with total degree of the generic polynomial d and denominator denompoly1 for d1 from 0 to d do d2:=d-d1: RC:=genR2(u,v,d1,d2): Rcf:=RC[2]: RC:=RC[1]: RC:=RC/denompoly: eq:=fa(p,f,mainvar,intnvars,mainorder,RC,Rvars): eq:= numer(normal(eq)): gu:=ptorpolstik(eq,mainorder, intnvars, axvars,Rcf): if gu<>0 then # lprint(` Checking complete. Time used: `, time() -st): # lprint(` High probability! (but no guarantee) to get a non-trivial annihilator. `): # lprint(`Now trying to get a non-trivial annihilator ...`): print(``): gu:=ptorpols(eq,intnvars,mainorder,RC,Rcf,N); if gu<>0 then ope:=op(1,gu): ope:=normal(ope): mekh:=denom(ope): ope:=numer(ope): ope:=pashet(ope,N,mainvar,intnvars): RC:=op(2,gu): RC:=subs({Rvars[1]=intnvars[1], seq(Rvars[j+1]=intnvars[j+1], j=1..nv-1)},RC): RC:=normal(RC*mekh): lprint(` Cheers! for the success after `, time() -st, ` seconds.`): print(``): D_:='D_': F_:='F_': R_:='R_': RETURN([ope=sum('D_[intnvars[i],R_[intnvars[i],op(subsop(i=NULL,intnvars))]* F_[mainvar,op(intnvars)]/p]','i'=1..nv), R_[op(intnvars)] = RC]): fi: fi: od: od: RETURN(NULL): end: #---------------------------------------------------------------------------- searchann1:=proc(p,f,mainvar,intnvars,axvars,mainorder,denompoly1,st) local d,eq,gu,i,j,RC,Rcf,ope,mekh,denompoly,extra,u,N,Rvars: global F_,D_,R_: extra:=2*(degree(collect(denompoly1,{op(intnvars)}),{op(intnvars)}) +nops(intnvars)): Rvars:=[u.1]: u:=Rvars[1]: denompoly:=subs({intnvars[1]=Rvars[1]}, denompoly1): for d from 0 to mainorder+extra do #print(``): # ... checking existence of rational certificate : #` with total degree of the generic polynomial d and denominator denompoly1 RC:=genR1(u,d): Rcf:=RC[2]: RC:=RC[1]: RC:=RC/denompoly: eq:=fa(p,f,mainvar,intnvars,mainorder,RC,Rvars): eq:=numer(normal(eq)): gu:=ptorpolstik(eq,mainorder, intnvars, axvars,Rcf): if gu<>0 then # Checking complete. # High probability! (but no guarantee) to get a non-trivial annihilator. # Now trying to get a non-trivial annihilator ... gu:=ptorpols(eq,intnvars,mainorder,RC,Rcf,N); if gu<>0 then ope:=op(1,gu): ope:=normal(ope): mekh:=denom(ope): ope:=numer(ope): ope:=pashet(ope,N,mainvar,intnvars): RC:=op(2,gu): RC:=subs({Rvars[1]=intnvars[1], seq(Rvars[j+1]=intnvars[j+1], j=1..nops(intnvars)-1)},RC): RC:=normal(RC*mekh): lprint(` Cheers! for the success after `, time() -st, ` seconds.`): print(``): D_:='D_': F_:='F_': R_:='R_': RETURN([ope=sum('D_[intnvars[i],R_[intnvars[i],op(subsop(i=NULL,intnvars))]* F_[mainvar,op(intnvars)]/p]','i'=1..nops(intnvars)), R_[op(intnvars)] = RC]): fi: fi: od: RETURN(NULL): end: #------------------------------------------------------------------------------ findrec0:=proc(p,f,mainvar,intnvars,axvars,mainorder,denompoly1,st) if nops(intnvars)=1 then searchann1(p,f,mainvar,intnvars,axvars,mainorder,denompoly1,st): elif nops(intnvars)>1 then searchann2(p,f,mainvar,intnvars,axvars,mainorder,denompoly1,st): fi: end: #----------------------------------------------------------------------------- findrec1:=proc(p,f,mainvar,intnvars,axvars,mainorder,st) local i,den,den1,den2,result,poly,maxd,factr,factrs: result:=NULL: den:=extrctdenom(f,intnvars): factrs:=op(2,factors(den)): maxd:=0: for i from 1 to nops(factrs) do factr:=collect(op(1,op(i,factrs))^op(2,op(i,factrs)),intnvars,'distributed'): maxd:=max(maxd,degree(factr,{op(intnvars)})): od: den1:=select(type,den,{name ^ nonnegint, name ^ 1}): if result=NULL and den1<>NULL and has(den1,intnvars) then for i from 0 to mainorder + maxd while result=NULL do poly:=den1^i: if sym(poly,intnvars) then result:=findrec0(p,f,mainvar,intnvars,axvars,mainorder,poly,st): fi: od: fi: if result=NULL and den1<>NULL and has(den1,intnvars) then den2:=normal(den/den1): for i from 0 to mainorder + maxd while result=NULL do poly:=den1^i*den2: if sym(poly,intnvars) then result:=findrec0(p,f,mainvar,intnvars,axvars,mainorder,poly,st): fi: od: fi: if result=NULL and sym(den,intnvars) then for i from 0 to mainorder + maxd while result=NULL do poly:=den^i: if sym(poly,intnvars) then result:=findrec0(p,f,mainvar,intnvars,axvars,mainorder,poly,st): fi: od: fi: if result=NULL and sym(den^2,intnvars) then den:=den^2: for i from 0 to mainorder + maxd while result=NULL do poly:=den^i: result:=findrec0(p,f,mainvar,intnvars,axvars,mainorder,poly,st): od: fi: if result=NULL then lprint(cat(` Could not find a non -trivial recurrence eq with order `, mainorder )): print(``): else result: fi: end: #----------------------------------------------------------------------------- findrec2:=proc(p,f,mainvar,intnvars,axvars,poly,st) local result,maxorder,mainorder: maxorder:=6: result:=NULL: for mainorder from 1 to maxorder while result=NULL do lprint(cat(` ... trying to find a non-trivial recurrence eq with order `, mainorder)): print(``): result:=findrec0(p,f,mainvar,intnvars,axvars,mainorder,poly,st): od: if result=NULL then lprint(cat(` Could not get a non-trivial recurrence eq with max order `, maxorder )): print(``): else result: fi: end: #----------------------------------------------------------------------------- findrec3:=proc(p,f,mainvar,intnvars,axvars,st) local mainorder,maxorder,result: maxorder:=6: result:=NULL: for mainorder from 1 to maxorder while result=NULL do lprint(cat(` ... trying to find a non-trivial recurrence eq with order `, mainorder)): result:=findrec1(p,f,mainvar,intnvars,axvars,mainorder,st): od: if result=NULL then lprint(cat(` Could not get a non -trivial recurrence eq with max order `, maxorder )): else result: fi end: # __________________________________ # # recurrence finders # __________________________________ # # findrec(f, n,x,axvar,i,polylst) : # looks for x-free annihilators of a specified maximal order i, # where n is the main variable, x the (list of) integration # variable(s), polylst is the (list of) polynomials which are the # denominator of the Rational Certificates. # #- findrec(f,n,x,axvars,order,denompoly) tries to find a non-trivial, # annihilator of f with polynomial coeff in n(free of x) of and output # a recurrence of the form poly(n)*F_[n+i,x1,x2,..] + ... = # D_[x1,R_(x1,...)F_[n,x1,...] + # In this case findrec searches for a recurrence differential operator whose # order i is less or equal to "order" and looks of rational certificate R_ , # whose denominators are "denompoly". # # - findrec(f,n,intnvars,axvars,order) the same as the above findrec(args), but # searches for appropriate denominators of the Certificates automatically # # - findrec(f,n,intnvars,axvars,denompoly) is like either of the above # findrec(args),but looks for non-trivial annihilator whose order is at most # 6(the default max order) and having "denompoly" as the denominators of the # rational certificates # # - findrec(f,n,intnvars,axvars) is the like either of the above findrec(args), # but in this case findrec searches for the appropriate denominators and # output (if any) a nontrivial annihilator whose order is at most 6 findrec:=proc() local args1,i,p,f,poly,t1,t2,t3,t4,st: if nargs< 4 then ERROR(`findrec uses at least four arguments`) fi: #defining the correct args types st:=time(): t1:=[algebraic,name,list(name),list(name), nonnegint,polynom]: t2:=[algebraic,name,list(name),list(name), nonnegint]: t3:=[algebraic,name,list(name),list(name), polynom]: t4:=[algebraic,name,list(name),list(name)]: if type([args],t1) then args1:=chkargs(seq(args[i],i=1..4)): if args1=NULL then ERROR(` Invalid input, expecting an arg type `, convert(t1,string)): fi: if not sym(args[1],args[3]) then print(args[1]): print(cat( ` is not symetric with respect to `, convert(args[3],string))): ERROR(` in this case use the package Mint. `): fi: args1:=subsop(1=NULL,args1): poly:=subs(0=1,args[nargs]): p:=extrctP(seq(args[i],i=1..4)): f:=p[2]: p:=p[1]: findrec0(p,f,op(args1),args[5],poly,st): elif type([args],t2) then args1:=chkargs(seq(args[i],i=1..4)): if not sym(args[1],args[3]) then print(args[1]): print(cat( ` is not symetric with respect to `, convert(args[3],string))): ERROR(` in this case use the package Mint. `): fi: if args1=NULL then ERROR(` Invalid input, expecting an arg type `, convert(t2,string)): fi: args1:=subsop(1=NULL,args1): p:=extrctP(seq(args[i],i=1..4)): f:=p[2]: p:=p[1]: findrec1(p,f,op(args1),args[5],st): elif type([args],t3) then args1:=chkargs(seq(args[i],i=1..4)): if not sym(args[1],args[3]) then print(args[1]): print(cat( ` is not symetric with respect to `, convert(args[3],string))): ERROR(` in this case use the package Mint. `): fi: if args1=NULL then ERROR(` Invalid input, expecting an arg type `, convert(t3,string)): fi: args1:=subsop(1=NULL,args1): poly:=subs(0=1,args[nargs]): p:=extrctP(seq(args[i],i=1..4)): f:=p[2]: p:=p[1]: findrec2(p,f,op(args1),poly,st): elif type([args],t4) then args1:=chkargs(seq(args[i],i=1..4)): if not sym(args[1],args[3]) then print(args[1]): print(cat( ` is not symetric with respect to `, convert(args[3],string))): ERROR(` in this case use the package Mint. `): fi: if args1=NULL then ERROR(` Invalid input, expecting an arg type `, convert(t4,string)): fi: args1:=subsop(1=NULL,args1): p:=extrctP(seq(args[i],i=1..4)): f:=p[2]: p:=p[1]: findrec3(p,f,op(args1),st): else lprint(` Invalid input, expecting an arg type `, convert(t1,string)): lprint(`or `, convert(t2,string)): lprint(`or `, convert(t3,string)): ERROR(` or `, convert(t4,string)): fi: end: #-------------------------------------------- interface(labeling = false): #_____________________________ HELP INfORMATION ______________________________ print(`SMint: a Maple Package that contains functions to prove `): print(` identities which involve pure multiple integrals with special`): print(` integrand(symmetric Hyper geometric), using Multi-WZ Method.`): print(``): print(` For a list of procedures, type:`): print(` ?SMint or help(SMint) `): print(` `): print(` For help with a specific procedure, type:`): print(`?procedure name or help(procedure name) `): print(``): `help/text/SMint`:=TEXT( ``, `This package contains functions to prove identities which involves pure`, `multiple integrals with special integrand(symmetric Hyper geometric).`, ``, `SMint consists of the following functions:`, ``,` findrec `, ``, ` checkrec`,``, `To get help for a specific procedure, type: `, ` ?procedure name or help(procedure name)`, `CAUTION: the following variables are global: `,``, ` F_, D_, R_ `, `` ): `help/text/findrec`:=TEXT( ``, `FUNCTION: findrec: tries to find a recurrence for a given fun`, ``, `CALLING SEQUENCES:`, ` findrec(f,n,intnvars,axvars,order,denompoly)`, `or findrec(f,n,intnvars,axvars,order) `, `or findrec(f,n,intnvars,axvars,denompoly)`, `or findrec(f,n,intnvars,axvars)`, ``, `PARAMETERS: `, ` f : integrand `, ` n : a variable w.r.t. which the recurrence`, ` (differential) operator to be sought`, ` intnvars : list of integration vars.`, ` axvars : list of auxiliary vars(parameters) in f,`, ` (if any), excluding "n" and "intnvars".`, ` input [], for null.`, ` order : a postive integer(a desired rec. order) `, ` denompoly : is a list of guessed polynomials to be taken as`, ` denominators of the rational certificates.`, ` `, `SYNOPSIS:`, `- findrec(f,n,intnvars,axvars,order,denompoly) tries to find a non-trivial`, ` annihilator of f with polynomial coeff in n and output a recurrence of ,`, ` the form poly(n)*F_[n+i,x1,x2,...,xm] + ... = `, ` D_[x1,R_[x1,...,xm]F_[n,x1,...,xm]] + ... .`, ` In this case findrec searches for a recurrence differential operator whose`, ` order i is less or equal to "order" and looks of rational certificate R_ `, ` whose denominators are "denompoly".`, ``, ` - findrec(f,n,intnvars,axvars,order) the same as `, ` findrec(f,n,intnvars,axvars,order,denompoly), but searches for appropriate`, ` denominators of the certificate automatically`, ``, `- findrec(f,n,intnvars,axvars,denompoly) is like either of the above`, ` findrec(args),but looks for non-trivial annihilator whose order is at most`, ` 6(the default max order) and having "denompoly" as the denominators of the`, ` rational certificates`,``, `- findrec(f,n,intnvars,axvars) is the like either of the above`, ` findrec(args),but in this case findrec searches for the appropriate`, ` denominators and output (if any) a nontrivial annihilator whose order is`, ` at most 6`. ``, `EXAMPLES:`, ` `, ``,``,`>findrec(((1+x)*(1+y))^(2*n)/y^n/x^n,n,[x,y],[n])`, ` ... trying to find a non-trivial recurrence eq with order 1`, ` ... solving 14 equations for 13 unknowns`, ``, ` Cheers! for the success after 42.184 seconds.`, ``, ``, ` 2 2 2 2`, `[4 (n + 1) (2 n + 1) F_[n, x, y] - (n + 2) n F_[n + 1, x, y] =`, ``, ` D_[x, R_[x, y] F_[n, x, y]] + D_[y, R_[y, x] F_[n, x, y]],`, ``, ` 2 2 2 3`, ` R_[x, y] = - 1/2 (- 4 x y - 4 n - 4 n - 4 y - 4 n x - 8 x y n + 7 x y n`, ``, ` 2 2 3 2 2 2 2 2`, ` + 13 x y n - 20 x y n + 2 x y n - 8 x y n + 4 x y n + 2 n x y`, ``, ` 3 2 2 3 2 2 2 2 2 3 3 2 2`, ` - x n - 4 x n - 8 n y + n x y - 6 x y n - x y n - n - 8 n y`, ``, ` 3 2 3 2`, ` - 5 y n - 21 y n - 24 y n - 2 n y )/y`, ``, ` ]`, ``, ` ` ): #----------------------------------------------------------------------------- # checkrec: checkrec(rec, f) takes a recurrence equation rec, involving the # symbols F_ orD_, and returns True if term satisfies this rec. # `help/text/checkrec`:=TEXT( ``, `FUNCTION: checkrec: takes a recurrence equation rec which involves `, ` the symbols F_ or D_, and returns True if f satisfies rec.` , ``, `CALLING SEQUENCES:`, ` checkrec(rec,f)`, ``, `PARAMETERS: `, ` rec : recurrence equation `, ` f : integrand`, ` `, `SYNOPSIS:`, `- checkrec is useful in particular to verify the output of the procedure`, ` findrec`, ``, `EXAMPLES:`, ` `, `> rec := `, `[4*(n+1)^2*(2*n+1)^2*F_[n,x,y]-(n+2)^2*n^2*F_[n+1,x,y] = D_[x,R_[x,y]*F_[n,x,`, `y]]+D_[y,R_[y,x]*F_[n,x,y]], R_[x,y] = -1/2*(-4*x*y-4*n^2-4*n-4*y-4*n*x-8*x*y^2`, `*n+7*x^2*y*n^3+13*x^2*y*n^2-20*x*y*n+2*x*y*n^3-8*x*y*n^2+4*x^2*y*n+2*n^2*x^2*y^`, `2-x*n^3-4*x*n^2-8*n*y^2+n^3*x^2*y^2-6*x*y^2*n^2-x*y^2*n^3-n^3-8*n^2*y^2-5*y*n^3`, `-21*y*n^2-24*y*n-2*n^3*y^2)/y]`, `>checkrec(rec, ((1+x)*(1+y))^(2*n)/x^n/y^n);`, ` true`,``, ``, `SEE ALSO: findrec`, `` ):