## Maple Code Thu Apr 3 08:02:22 METDST 1997 ## UpDate Fri Jun 23 23:04:18 METDST 2000 ## ## ## Title: HYPERG package (for HYPERGeometric series) ## Content: A Maple Package about hypergeometric series ## Created: Thu Apr 3 08:02:22 METDST 1997 ## Author: Bruno Gauthier ## http://www-igm.univ-mlv.fr/~gauthier/HYPERG.html ## Address: Universite of Marne-la-Vallee, ## Institut Gaspard Monge, ## Cite Descartes, ## 5, Bd Descartes, Champs-sur-Marne, ## F-77454 Marne-la-Vallee, CEDEX 2, FRANCE ## ## ## Description: HYPERG is a package for the manipulation of hypergeometric ## series. It also provides tools for automatic proofs ## of identities, but they are just tools: every step ## in a series of manipulations has to be controlled by the ## user. The goal of this package is to make the algorithms ## in this area better known, and to help you enter ## the wonderful world of hypergeometric series. ## ## ## Several features of this package are due to C. Krattenthaler. ## ## Many thanks to C. Krattenthaler, M. Petkovsek, A. Tefera, D. Zeilberger ## for their helpful comments. ## ## ## ## Modifications: ## ## 1.0b HypContig improvement (C86, C118) Jun 2000 ## (thanks to Edgardo S. Cheb-Terrab) Jun 2000 ## 1.0a Oct 1999 ## 1.0 Jun 1999 ## 0.98a HypSolRec improvement (thanks to Akalu Tefera) Mar 1999 ## 0.98 PolySolRec and Gosper improvement Mar 1999 ## 0.97j T2111 Mar 1999 ## 0.97i HypConverg Feb 1999 ## 0.97h QRF modified and Gosper improvement Dec 1998 ## 0.97f MapApply, MapList (with depth) Nov 1998 ## 0.97d SumToHyp (with complex parameters) Oct 1998 ## 0.97b T1101 and fixed bugs Oct 1998 ## 0.97a HypDiff improvement Sep 1998 ## 0.97 PolySolQRec, RatioSolQRec, HypSolQRec, GenQRec Sep 1998 ## 0.96 HypType Jul 1998 ## 0.95 QBIN, IsQBIN, QBinEval Jul 1998 ## 0.94 HypSumList, HypTransfList Jun 1998 ## 0.90 transformation formulas T6501-T7694 Jun 1998 ## 0.88 transformation formulas T3204-T5403 Apr 1998 ## 0.87 summation formulas S7631-S7691 Apr 1998 ## 0.85 transformation formulas T2103-T2192 Apr 1998 ## 0.84 summation formulas S4306-S6532 Apr 1998 ## 0.83 RecOrder Apr 1998 ## 0.82 SimplifyRec, ShiftRec, SubsRec, CheckRec Mar 1998 ## 0.81 IsHomog, Homog Mar 1998 ## 0.80 HypDiff Feb 1998 ## 0.80 IsHyperg, HypergToRec Feb 1998 ## 0.80 contiguous formulas C104-C121 Feb 1998 ## 0.79 contiguous formulas C59-C103 Jan 1998 ## 0.78 very-well-poised basic hypergeometric series Jan 1998 ## 0.77 hypergeometric solutions of q-recurrences Nov 1997 ## 0.76 polynomial and rational solutions of q-recurrences Oct 1997 ## 0.75 basic hypergeometric series Oct 1997 ## 0.74 very-well-poised hypergeometric series Sep 1997 ## 0.73 MapList, MapApply Sep 1997 ## 0.72 contiguous formulas C53-C58 Sep 1997 ## 0.71 contiguous formulas C31-C52 Sep 1997 ## 0.65 contiguous formulas C01-C30 Aug 1997 ## 0.60 summation formulas S1001-S3291 Aug 1997 ## 0.50 rules for manipulating factorial expressions Jun 1997 ## 0.40 Gosper/Zeilberger algorithms Jun 1997 ## 0.30 hypergeometric solutions of recurrences May 1997 ## 0.20 polynomial and rational solutions of recurrences May 1997 ## 0.10 basics Apr 1997 ## ## Please report all bugs to: gauthier@univ-mlv.fr ######################### Global Constants ############################## `HYPERG/init` := proc() global `HYPERG/Verbose`, `HYPERG/Version`, `HYPERG/PrintBool`, INFINITY; `HYPERG/Verbose` := 0: `HYPERG/Version` := `1.0b`: `HYPERG/PrintBool` := true: INFINITY := 9999: end: ########## # File @(#) Basics (HYPERG PACKAGE) Fri Jun 27 08:22:05 METDST 1997 ########## # # HYPERG[AddParam] # # HYPERG[HypPermUp] # HYPERG[HypPermLow] # HYPERG[HypPermBoth] # # BG270697 BG220897 BG150997 HYPERG[AddParam] := proc() local shyp,newp, l1,l2; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting tow arguments`); fi: shyp := args[1]; newp := args[2]; if not ( HYPERG[IsHYP](shyp) or HYPERG[IsQHYP](shyp) ) then ERROR(`Not a standard hypergeometric series`,shyp); fi: l1 := op(1,shyp); l2 := op(2,shyp); if type(newp,numeric) then if ( type(newp,negint) or (newp=0) ) then ERROR(`The new parameter must be positive`); fi: else `HYPERG/Print`(newp,` must be an integer > 0`); fi: if HYPERG[IsHYP](shyp) then HYP[[newp,op(l1)],[newp,op(l2)],op(3,shyp)]; else QHYP[[newp,op(l1)],[newp,op(l2)],op(3..4,shyp)]; fi: end: HYPERG[HypPermUp] := proc() local shyp,perm,l1,l2,m1,i; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting tow arguments`); fi: shyp := args[1]; perm := args[2]; if not ( HYPERG[IsHYP](shyp) or HYPERG[IsQHYP](shyp) ) then ERROR(`Not a standard hypergeometric series`,shyp); fi: if not type(perm,list) then ERROR(`Not a permutation list`,perm); fi: l1 := op(1,shyp); l2 := op(2,shyp); if ( nops(perm) <> nops(l1) ) then ERROR(`Not same length`,perm,l1); fi: if not evalb( [seq(i,i=1..nops(perm))]=sort(perm) ) then ERROR(`Not a permutation`,perm); fi: m1 := [seq(k.i,i=1..nops(l1))]; for i from 1 to nops(perm) do m1 := subsop(i=l1[perm[i]],m1); od: if HYPERG[IsHYP](shyp) then HYP[m1,l2,op(3,shyp)]; else QHYP[m1,l2,op(3..4,shyp)]; fi: end: HYPERG[HypPermLow] := proc() local shyp,perm,l1,l2,m2,i; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: shyp := args[1]; perm := args[2]; if not ( HYPERG[IsHYP](shyp) or HYPERG[IsQHYP](shyp) ) then ERROR(`Not a standard hypergeometric series`,shyp); fi: if not type(perm,list) then ERROR(`Not a permutation list`,perm); fi: l1 := op(1,shyp); l2 := op(2,shyp); if ( nops(perm) <> nops(l2) ) then ERROR(`Not same length`,perm,l2); fi: if not evalb( [seq(i,i=1..nops(perm))]=sort(perm) ) then ERROR(`Not a permutation`,perm); fi: m2 := [seq(k.i,i=1..nops(l2))]; for i from 1 to nops(perm) do m2 := subsop(i=l2[perm[i]],m2); od: if HYPERG[IsHYP](shyp) then HYP[l1,m2,op(3,shyp)]; else QHYP[l1,m2,op(3..4,shyp)]; fi: end: HYPERG[HypPermBoth] := proc() local shyp,perm,l1,l2,elt,m1,m2,i; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: shyp := args[1]; perm := args[2]; if not ( HYPERG[IsHYP](shyp) or HYPERG[IsQHYP](shyp) ) then ERROR(`Not a standard hypergeometric series`,shyp); fi: if not type(perm,list) then ERROR(`Not a permutation list`,perm); fi: l1 := op(1,shyp); l2 := op(2,shyp); if ( nops(l1) <> nops(l2)+1 ) then ERROR(`Not a {r+1}_HYP_{r}`); fi: if ( nops(perm) <> nops(l2) ) then ERROR(`Not same length`,perm,l2); fi: if not evalb( [seq(i,i=1..nops(perm))]=sort(perm) ) then ERROR(`Not a permutation`,perm); fi: elt := op(1,l1); m1 := [seq(k.i,i=1..nops(l1)-1)]; for i from 1 to nops(perm) do m1 := subsop(i=l1[perm[i]+1],m1); od: m1 := [elt, op(m1) ]; m2 := [seq(k.i,i=1..nops(l2))]; for i from 1 to nops(perm) do m2 := subsop(i=l2[perm[i]],m2); od: if HYPERG[IsHYP](shyp) then HYP[m1,m2,op(3,shyp)]; else QHYP[m1,m2,op(3..4,shyp)]; fi: end: ########## # File @(#) CheckRec (HYPERG PACKAGE) Fri Mar 27 08:08:34 MET 1998 ########## # # HYPERG[CheckRec] # # BG270398 BG310398 BG270598 HYPERG[CheckRec] := proc() # INPUT : <-- rec : recurrence equation with polynomial coefficients # <-- U(n) : sequence # <-- term : term # OUTPUT : --> true/false local rec, suite, U,n, term, new; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 3 ) then ERROR(`Expecting three arguments`); fi: rec := args[1]; #if not type(rec,`=`) # then ERROR(rec,`is not a recurrence`); #fi: suite := args[2]; if ( not type(suite,function) ) then ERROR(suite,`is not a sequence`); fi: U := op(0,suite); n := op(1,suite); term := args[3]; new := HYPERG[SubsRec](rec,suite,term); new := normal( expand( op(1,new)-op(2,new) ) ); if ( new=0 ) then true; else false; fi: end: ########## # File @(#) Divers (HYPERG PACKAGE) Wed Sep 10 15:59:25 METDST 1997 ########## # # `HYPERG/MemberHas` # `HYPERG/Mymin` # `HYPERG/Mymax` # `HYPERG/Writeln` # `HYPERG/Print` # `HYPERG/Verbose/Print` # # HYPERG[Time] # # BG100997 BG021097 BG081098 BG201098 `HYPERG/MemberHas` := proc(a,li,posi) local i,n,flag; n := nops(li); flag := false; i := 1; while ( ( not flag ) and ( i<=n ) ) do if ( has(op(i,li),a) ) then flag := true; posi := i; fi: i := i+1; od: flag; end: `HYPERG/Mymin` := proc(a,b) local l1,l2,z,cond; if (a=-infinity) or (b=-infinity) then RETURN(-infinity); fi: if (a=infinity) then RETURN(b); fi: if (b=infinity) then RETURN(a); fi: min(a,b); end: `HYPERG/Mymax` := proc(a,b) local l1,l2,z,cond; if (a=infinity) or (b=infinity) then RETURN(infinity); fi: if (a=-infinity) then RETURN(b); fi: if (b=-infinity) then RETURN(a); fi: max(a,b); end: `HYPERG/Writeln` := proc() local i, expr; printf(`# `); for i from 1 to nargs do expr := args[i]; #if type(expr, integer) then printf(`%d`, expr) #elif type(expr, float) then printf(`%g`, expr) #elif type(expr, string) then printf(`%s`, expr) #else printf(`%a`, expr) #fi od; printf(`\n`); end: `HYPERG/Print` := proc() global `HYPERG/PrintBool`; if (`HYPERG/PrintBool`=true) then `HYPERG/Writeln`(args); #then print(args); fi: end: `HYPERG/Verbose/Print` := proc() global `HYPERG/Verbose`; if (`HYPERG/Verbose`>=args[1]) then printf(args[2..nargs]); fi: end: HYPERG[Time] := proc(f,t) local r,s; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; s := time(); r := f(args[3 .. nargs]); t := time()-s; r; end: ########## # File @(#) EvalFun (HYPERG PACKAGE) Mon Apr 14 09:25:40 MET 1997 ########## # # HYPERG[HypEval] # `HYPERG/HypEval/basic` # # HYPERG[RfEval] # `HYPERG/RfEval/basic` # # BG140497 BG290598 BG151098 BG091198 BG310399 `HYPERG/HypEval/basic`:=proc(shyp,k) local sshyp,l1,l2,z,summand,i; global `HYPERG/PrintBool`; `HYPERG/PrintBool` := false; sshyp := HYPERG[HypSimplify](shyp); `HYPERG/PrintBool` := true; l1 := op(1,sshyp); l2 := op(2,sshyp); z := op(3,sshyp); if has(l1,0) or (z=0) then RETURN(1); fi: if (nops(l1)=0 and nops(l2)=0) then RETURN(exp(z)); fi: summand := convert( [seq(RF[op(i,l1),k],i=1..nops(l1))],`*` ); summand := summand / convert( [seq(RF[op(i,l2),k],i=1..nops(l2))],`*` ); summand := summand * z^(k) / (k)!; Sum(summand,k=0..infinity); end: HYPERG[HypEval] := proc() # this function evaluates hypergeometric series HYP and VHYP local i, # loop variable expr, # any expression tsi, # index summation (by default: k) res; # final result option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs > 2 ) then ERROR(`Wrong number of arguments`); fi: expr := args[1]; if ( nargs = 2 ) then tsi := args[2]; else tsi := k; #[default value] global variable fi: if ( not type(tsi,name) ) then ERROR(`Expecting a name as summation index`,tsi); fi: if ( type(expr,function) and ( op(0,expr)=Sum or op(0,expr)=sum ) ) then res := Sum(HYPERG[HypEval](op(1,expr),tsi),op(2,expr)); elif type(expr,`*`) then res := convert([seq(HYPERG[HypEval](op(i,expr),tsi),i=1..nops(expr))],`*`); elif type(expr,`+`) then res := convert([seq(HYPERG[HypEval](op(i,expr),tsi),i=1..nops(expr))],`+`); elif type(expr,`^`) then res := HYPERG[HypEval](op(1,expr),tsi)^(op(2,expr)); elif ( `HYPERG/IsHYP`(expr) = true ) then res := `HYPERG/HypEval/basic`(expr,tsi); elif ( `HYPERG/IsVHYP`(expr) = true ) then res := `HYPERG/HypEval/basic`(HYPERG[VHypToHyp](expr),tsi); else RETURN (expr); fi; res; end: # BG031297 `HYPERG/RfEval/basic`:=proc(rf) local a,n,i; a := op(1,rf); n := op(2,rf); if ( type(n,numeric) and not type(n,integer) ) then ERROR(`Rising factorial: the second argument is not an integer`,n); fi: if type(n,integer) then if ( n=0 ) then RETURN(1); elif ( n>0 ) then RETURN(product(a+i,i=0..n-1)); else RETURN(1/product(a+n+i,i=0..-n-1)); # (a+n) must be > 0 (else division by 0) fi: else if ( a=0 ) then RETURN(rf); # nothing to return else RETURN(product(a+i,i=0..n-1)); fi: fi: end: HYPERG[RfEval] := proc(expr) # this function evaluates rising factorials RF local i,res; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 1 ) then ERROR(`Expecting only one argument`); elif ( type(expr,function) and ( op(0,expr)=Sum or op(0,expr)=sum ) ) then res := Sum(HYPERG[RfEval](op(1,expr)),op(2,expr)); elif type(expr,`*`) then res := convert([seq(HYPERG[RfEval](op(i,expr)),i=1..nops(expr))],`*`); elif type(expr,`+`) then res := convert([seq(HYPERG[RfEval](op(i,expr)),i=1..nops(expr))],`+`); elif type(expr,`^`) then res := HYPERG[RfEval](op(1,expr))^(op(2,expr)); elif ( `HYPERG/IsRF`(expr) = true ) then res := `HYPERG/RfEval/basic`(expr); else RETURN (expr); fi: res; end: ########## # File @(#) FirstTerms (HYPERG PACKAGE) Mon Jun 15 08:11:15 METDST 1998 ########## # # HYPERG[FirstTerms] # # BG150698 BG220698 HYPERG[FirstTerms] := proc() local s,n, s1,s2,vari,bi,bs, i, nterm,res; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting tow arguments`); fi: s := combine( HYPERG[HypEval](args[1]) ); n := args[2]; if ( op(0,s) <> Sum ) then ERROR(s,`is neither a Sum or a HYPergeometric series`); fi: if not type(n,posint) then ERROR(`The second argument must be an positive integer`); fi: s1 := op(1,s); s2 := op(2,s); if not type(s2,`=`) then ERROR(`Can't extract first terms of the sum`); fi: vari := op(1,s2); bi := op(1,op(2,s2)); bs := op(2,op(2,s2)); if (b1=infinity) or (b1=-infinity) then ERROR(`Can't extract first terms of the sum`,s); fi: if not type(bi,numeric) then ERROR(`Can't extract first terms of the sum`,s); fi: if type(bs,numeric) then if (bs 0 ) then res := res + nterm; fi: od: if (not type(bs,numeric)) or (bs>bi+n-1) then res := res + Sum(s1,vari=bi+n..bs); fi: res; end: ########## # File @(#) GenRec (HYPERG PACKAGE) Thu Aug 14 08:24:40 METDST 1997 ########## # # HYPERG[GenRec] # # BG140897 BG020498 BG240498 HYPERG[GenRec] := proc() # INPUT : <-- solutions : set of solutions {s1,s2,...,sp} # <-- yn : suite [y(n)] # OUTPUT : --> rec : recurrence lineaire a coefficients polynomiaux # dont s1, s2, ..., et sp sont des solutions local yn, solutions, rec, yy, nn, in_mat, i, k, MAT, dim, d; # Casoratian determinant option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: solutions := args[1]; if ( not type(solutions,set) ) then ERROR(solutions,`is not a set`); fi: solutions := [ op(solutions) ]; solutions := map(HYPERG[RfEval],solutions); yn := args[2]; if ( not type(yn,function) ) then ERROR(yn,`is not a sequence`); fi: yy := op(0,yn); nn := op(1,yn); in_mat := [ yn, op(solutions) ]; dim := nops(in_mat); MAT := linalg[matrix](dim,dim,[in_mat, seq(map((pp,vv,mm)->subs(vv=vv+mm,pp), in_mat,nn,k), k=1..dim-1)]); d := linalg[det](MAT); d := normal(expand(d/convert(solutions,`*`))); # si la simplification n'est pas totale, on ne conserve que le numerateur d := numer(d); if (d<>0) then rec := HYPERG[SimplifyRec](d=0,yn); else rec := d=0; fi: rec; end: ########## # File @(#) Gosper (HYPERG PACKAGE) Tue Jun 24 08:09:58 METDST 1997 ########## # # [HYPERG]Gosper` # `HYPERG/Gosper/Bound` # `HYPERG/Gosper/Decomp` # `HYPERG/Gosper/DegreePolyBound` # # BG240697 BG170498 BG121198 BG281298 BG130399 `HYPERG/Gosper/Bound` := proc(n,d,k) local r,s,nr,ns, i,j,rr,ss,drr,dss, aa,bb,cc,dd,res,tmp,disp; r := factor(n): s := factor(d): if ( not type(r,`*`) ) then nr := 1: else nr := nops(r): fi: if ( not type(s,`*`) ) then ns := 1: else ns := nops(s): fi: disp := {}: for i from 1 to nr do # ieme facteur de r if ( nr = 1 ) then rr := r: else rr := op(i,r): fi: if ( type(rr,`^`) ) then rr := op(1,rr): fi: for j from 1 to ns do # jeme facteur de s if ( ns = 1 ) then ss := s: else ss := op(j,s): fi: if ( type(ss,`^`) ) then ss := op(1,ss): fi: # Pour tous les couples (rr,ss) de facteurs de r et s rr := collect(rr,k): ss := collect(ss,k): drr := degree(rr,k): dss := degree(ss,k): if ( ( drr = 0 ) or ( drr <> dss ) ) then tmp := {}: else aa := coeff(rr,k,drr): bb := coeff(rr,k,drr-1): cc := coeff(ss,k,drr): dd := coeff(ss,k,drr-1): res := normal((bb*cc-aa*dd)/(aa*cc*drr)): if not type(res,nonnegint) then tmp := {}: else if ( collect(cc*rr-aa*subs(k=k+res,ss),k) = 0 ) then tmp := {res}: else tmp := {}: fi: fi: fi: disp := disp union tmp: od: od: [op(disp)]: end: `HYPERG/Gosper/Decomp` := proc(r,nn) # INPUT : <-- r(n) : # OUTPUT : --> a(n), b(n), c(n) s.t. r(n)= a(n)/b(n) * c(n+1)/c(n) local rr,a,b,c, f,g, # numerateur et denominateur de r(n) lcf,lcg, # coefficients de tete de f et g Z, # lcf/lcg racines,h, # Compute( f(n), g(n+h), n ) NN, # nombre de racines ss,pp,qq, i,j,k; # variables de boucle rr := normal(r); f := expand(numer(rr)); g := expand(denom(rr)); lcf := lcoeff(f,nn); lcg := lcoeff(g,nn); Z := lcf/lcg; f := expand(f/lcf); g := expand(g/lcg); i := 1; racines:=`HYPERG/Gosper/Bound`(f,g,nn); NN := nops(racines); pp := f; qq := g; ss := array[1..NN]; for j from 1 to NN do ss[j] := gcd(pp,subs(nn=nn+op(j,racines),qq)); pp := simplify( pp/ss[j] ); qq := simplify( qq/subs(nn=nn-op(j,racines),ss[j]) ); od: a := simplify(Z * pp); b := simplify(qq); c := convert( [seq(product(subs(nn=nn-k,ss[i]),k=1..op(i,racines)),i=1..NN)], `*`); c := simplify(c); [a,b,c]; end: `HYPERG/Gosper/DegreePolyBound` := proc(a,b,c,nn) # INPUT : --> a(n), b(n), c(n) s.t. r(n)= a(n)/b(n) * c(n+1)/c(n) # OUTPUT : <-- a degree bound for x(n) local aa,bb,cc,da,db,dc,ens,i,res; aa := collect(a,nn); bb := collect(b,nn); cc := collect(c,nn); da := `HYPERG/MyDegree`(aa,nn); db := `HYPERG/MyDegree`(bb,nn); dc := `HYPERG/MyDegree`(cc,nn); if ( da <> db ) or ( lcoeff(aa,nn) <> lcoeff(bb,nn) ) then ens := { dc-max(da,db) }; else ens := { dc-da+1, (coeff(collect(subs(nn=nn-1,bb),nn),nn,db-1) -coeff(aa,nn,da-1))/lcoeff(aa,nn) }; fi: res := []; for i in ens do if type(i,nonnegint) then res := [ op(res), i ]; fi: od: if ( res=[] ) then -1; else max(op(res)); fi: end: HYPERG[Gosper] := proc(TT,nn) # INPUT : <-- TT(n) hypergeometric sequence # OUTPUT : --> u(n) hypergeometric sequence such that u(n+1) - u(n) = TT(n) local T, # TT r, # rapport T(n+1)/T(n) a,b,c, # decomposition de r(n)= a(n)/b(n) * c(n+1)/c(n) ret, db, # degree bound for r(n) x, # x(n) polynome solution de a(n)*x(n+1)-b(n-1)*x(n)=c(n) sol; # solution de l'eq. precedent option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: T := HYPERG[RfEval](TT); T := convert(T,factorial); # L'algo de Gosper est-il applicable ? if not HYPERG[IsHyperg](T,nn) then ERROR(TT,`is not hypergeometric in`,nn); fi: T := normal(T); r := normal(expand(subs(nn=nn+1,T)/T)); ret := `HYPERG/Gosper/Decomp`(r,nn); a := op(1,ret); b := op(2,ret); c := op(3,ret); `HYPERG/Verbose/Print`(1,`\n Gosper decomposition: %a, %a, %a\n`,a,b,c); db := `HYPERG/Gosper/DegreePolyBound`(a,b,c,nn); if ( db < 0 ) then `HYPERG/Verbose/Print`(1,`\n No polynomial x exists`); print(FAIL); RETURN(NULL); fi: `HYPERG/Verbose/Print`(1,`\n Degree bound for x: %a\n`,db); sol:=traperror( HYPERG[PolySolRec](a*x(nn+1)-subs(nn=nn-1,b)*x(nn)=c,x(nn)) ); if ( sol = lasterror ) then print(FAIL); NULL; else normal(subs(nn=nn-1,b)*sol/c*T); fi: end: ########## # File @(#) Homog (HYPERG PACKAGE) Thu Mar 12 18:15:19 MET 1998 ########## # # HYPERG[Homog] # HYPERG[IsHomog] # `HYPERG/NonHomogTerm` # # BG120398 BG260398 BG050598 `HYPERG/NonHomogTerm` := proc() # INPUT : <-- rec : recurrence [sous forme op(1, )-op(2, )] # <-- U(n) : suite # OUTPUT : --> rec - newh; local rec, suite, U,n, newh, # new recurrence (without inhomogeneous term) li,i,name_c; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: rec := expand(args[1]); suite := args[2]; if ( not type(suite,function) ) then ERROR(suite,`is not a sequence`); fi: U := op(0,suite); n := op(1,suite); li := [ op(indets(rec)) ]; newh := 0; for i from 1 to nops(li) do name_c := op(i,li); if `HYPERG/IsSeq`(name_c,suite) then newh := newh + name_c*coeff(rec,name_c); fi: od: normal(rec-newh); end: HYPERG[IsHomog] := proc() # INPUT : <-- rec : recurrence homogene/inhomogene ? # <-- U(n) : suite # OUTPUT : --> bool : True/false local rec,suite,val; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: rec := args[1]; if type(rec,`=`) then rec := op(1,rec)-op(2,rec); fi: suite := args[2]; if ( not type(suite,function) ) then ERROR(suite,`is not a sequence`); fi: val := `HYPERG/NonHomogTerm`(rec,suite); if ( val=0 ) then true; else false; fi: end: HYPERG[Homog] := proc() # INPUT : <-- rec : recurrence homogene/inhomogene ? # <-- U(n) : suite # OUTPUT : --> rec : recurrence homogene satisfaite par U(n) local rec, suite, U,n, val, homog_r,h_rec; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: rec := args[1]; if type(rec,`=`) then rec := op(1,rec)-op(2,rec); fi: suite := args[2]; if ( not type(suite,function) ) then ERROR(suite,`is not a sequence`); fi: U := op(0,suite); n := op(1,suite); val := `HYPERG/NonHomogTerm`(rec,suite); if ( val=0 ) # si l'equation est deja homogene then RETURN(rec=0); fi: homog_r := rec * subs(n=n+1,val) - subs(n=n+1,rec) * val; h_rec := HYPERG[SimplifyRec](homog_r=0,suite); end: ########## # File @(#) HypContig (HYPERG PACKAGE) Tue Aug 19 08:22:09 METDST 1997 ########## # # `HYPERG/VerifPos` # # HYPERG[HypContig] # HYPERG[HypContigPrint] # `HYPERG/HypContig/heart` # `HYPERG/C01`, `HYPERG/C02`, `HYPERG/C14`, `HYPERG/C15`, `HYPERG/C16`, # `HYPERG/C17`, `HYPERG/C18`, `HYPERG/C19`, `HYPERG/C20`, `HYPERG/C21`, # `HYPERG/C22`, `HYPERG/C23`, `HYPERG/C24`, `HYPERG/C25`, `HYPERG/C26`, # `HYPERG/C27`, `HYPERG/C30`, `HYPERG/C31`, `HYPERG/C32`, `HYPERG/C33`, # `HYPERG/C34`, `HYPERG/C35`, `HYPERG/C36`, `HYPERG/C40`, `HYPERG/C41`, # `HYPERG/C42`, `HYPERG/C43`, `HYPERG/C44`, `HYPERG/C45`, `HYPERG/C46`, # `HYPERG/C49`, `HYPERG/C50`, `HYPERG/C51`, `HYPERG/C52`, `HYPERG/C53`, # `HYPERG/C54`, `HYPERG/C55`, `HYPERG/C56`, `HYPERG/C57`, `HYPERG/C58`, # `HYPERG/C59`, `HYPERG/C60`, `HYPERG/C61`, `HYPERG/C62`, `HYPERG/C63`, # `HYPERG/C64`, `HYPERG/C65`, `HYPERG/C66`, `HYPERG/C67`, `HYPERG/C68`, # `HYPERG/C69`, `HYPERG/C70`, `HYPERG/C71`, `HYPERG/C72`, `HYPERG/C73`, # `HYPERG/C74`, `HYPERG/C75`, `HYPERG/C76`, `HYPERG/C77`, `HYPERG/C78`, # `HYPERG/C79`, `HYPERG/C80`, `HYPERG/C81`, `HYPERG/C82`, `HYPERG/C83`, # `HYPERG/C84`, `HYPERG/C85`, `HYPERG/C86`, `HYPERG/C87`, `HYPERG/C88`, # `HYPERG/C89`, `HYPERG/C90`, `HYPERG/C91`, `HYPERG/C92`, `HYPERG/C93`, # `HYPERG/C94`, `HYPERG/C95`, `HYPERG/C96`, `HYPERG/C97`, `HYPERG/C98`, # `HYPERG/C99`, `HYPERG/C100`, `HYPERG/C101`, `HYPERG/C102`, `HYPERG/C103`, # `HYPERG/C104, `HYPERG/C110`, `HYPERG/C105`, `HYPERG/C112`, `HYPERG/C106`, # `HYPERG/C107, `HYPERG/C114`, `HYPERG/C115`, `HYPERG/C108`, `HYPERG/C118`, # `HYPERG/C109`, `HYPERG/C120`, `HYPERG/C111`, `HYPERG/C113`, `HYPERG/C116`, # `HYPERG/C117`, `HYPERG/C119`, `HYPERG/C121`, # # BG190897 BG160198 BG020298 BG060298 BG170498 BG130898 BG230600 `HYPERG/VerifPos` := proc(pos,binf,bsup) if ( pos < binf ) or ( pos > bsup ) then ERROR(`Wrong parameter position`); fi: end: # Two-term relations # `HYPERG/C01`:=proc(shyp) local l1,l2,z, m1,m2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ 1, seq(op(i,l1)+1,i=1..nops(l1)) ]; m2 := [ 2, seq(op(i,l2)+1,i=1..nops(l2)) ]; 1 + z*prod1/prod2 * HYP[m1,m2,z]; end: `HYPERG/C02`:=proc(shyp) local l1,l2,z,a, m1,m2,prod1,prod2,i,prod,k; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); if ( member(1,l1,'k') = false ) then ERROR(`The integer 1 is absent from the upper parameters`); fi: a := op(k,l1); l1 := subsop(k=NULL,l1); m1 := [ 1, seq(op(i,l1)-1,i=1..nops(l1)) ]; m2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(m1,`*`); prod2 := convert(m2,`*`); prod := prod2/z/prod1; prod * HYP[m1,m2,z] - prod; end: # Three-term relations with one parameter # `HYPERG/C14`:=proc(shyp,up1) local l1,l2,z,a, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); m1 := [ a-1, op(l1) ]; m2 := l2; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C15`:=proc(shyp,up1) local l1,l2,z,a, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); m1 := [ a+1, op(l1) ]; m2 := l2; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C16`:=proc(shyp,up1) local l1,l2,z,a, tmp1,tmp2, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a, op(tmp1) ]; m2 := tmp2; n1 := [ a-1, op(tmp1) ]; n2 := tmp2; prod2/prod1/z * HYP[m1,m2,z] - prod2/prod1/z * HYP[n1,n2,z]; end: `HYPERG/C17`:=proc(shyp,up1) local l1,l2,z,a, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); m1 := [ a-1, op(l1) ]; m2 := l2; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C18`:=proc(shyp,up1) `HYPERG/C15`(shyp,up1): end: `HYPERG/C19`:=proc(shyp,up1) `HYPERG/C16`(shyp,up1): end: `HYPERG/C20`:=proc(shyp,low1) local l1,l2,z,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); b := op(low1,l2); l2 := subsop(low1=NULL,l2); m1 := l1; m2 := [ b+1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ b+2, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + z/b/(b+1) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C21`:=proc(shyp,low1) local l1,l2,z,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); b := op(low1,l2); l2 := subsop(low1=NULL,l2); m1 := l1; m2 := [ b-1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ b+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - z/(b-1)/b * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C22`:=proc(shyp,low1) local l1,l2,z,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); b := op(low1,l2); l2 := subsop(low1=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := tmp1; m2 := [ b-2, op(tmp2) ]; n1 := tmp1; n2 := [ b-1, op(tmp2) ]; (b-2)*(b-1)/z * prod2/prod1 * HYP[m1,m2,z] - (b-2)*(b-1)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C23`:=proc(shyp,low1) `HYPERG/C20`(shyp,low1): end: `HYPERG/C24`:=proc(shyp,low1) `HYPERG/C21`(shyp,low1): end: `HYPERG/C25`:=proc(shyp,low1) `HYPERG/C22`(shyp,low1): end: # Three-term relations with two parameters # `HYPERG/C26`:=proc(shyp,up1,up2) local l1,l2,z,a,b, m1,m2,n1,n2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); m1 := [ a, b+1, op(l1) ]; m2 := l2; n1 := [ a+1, b, op(l1) ]; n2 := l2; b/(b-a) * HYP[m1,m2,z] + a/(a-b) * HYP[n1,n2,z]; end: `HYPERG/C27`:=proc(shyp,up1,up2) local l1,l2,z,a,b, m1,m2,n1,n2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); m1 := [ a-1, b, op(l1) ]; m2 := l2; n1 := [ a-1, b+1, op(l1) ]; n2 := l2; (a-b-1)/(a-1) * HYP[m1,m2,z] + b/(a-1) * HYP[n1,n2,z]; end: `HYPERG/C30`:=proc(shyp,up1,up2) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a-1, b+1, op(l1) ]; m2 := l2; n1 := [ a, b+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (1-a+b)*z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C31`:=proc(shyp,up1,up2) local l1,l2,z,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a, b-1, op(tmp1) ]; m2 := tmp2; n1 := [ a-1, b, op(tmp1) ]; n2 := tmp2; 1/(b-a)/z*prod2/prod1 * HYP[m1,m2,z] - 1/(b-a)/z*prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C32`:=proc(shyp,up1,up2) local l1,l2,z,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a-1, b-1, op(l1) ]; m2 := l2; tmp1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; n1 := [ a, b, a+b, op(tmp1) ]; n2 := [ -1+a+b, op(tmp2) ]; HYP[m1,m2,z] + (a+b-1)*z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C33`:=proc(shyp,up1,up2) local l1,l2,z,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); l1 := subsop(up1=NULL,up2=NULL,l1); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, b+1, op(l1) ]; m2 := l2; tmp1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; n1 := [ a+1, b+1, a+b+2, op(tmp1) ]; n2 := [ a+b+1, op(tmp2) ]; HYP[m1,m2,z] - (1+a+b)*z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C34`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a, op(l1) ]; m2 := [ b-1, op(l2) ]; n1 := [ a+1, op(l1) ]; n2 := [ b, op(l2) ]; (b-1)/(b-1-a) * HYP[m1,m2,z] + a/(1+a-b) * HYP[n1,n2,z]; end: `HYPERG/C35`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ b-1, op(l2) ]; n1 := [ a-1, op(l1) ]; n2 := [ b, op(l2) ]; (b-1)/(a-1) * HYP[m1,m2,z] + (a-b)/(a-1) * HYP[n1,n2,z]; end: `HYPERG/C36`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a, op(l1) ]; m2 := [ b+1, op(l2) ]; n1 := [ a+1, op(l1) ]; n2 := [ b+1, op(l2) ]; (b-a)/b * HYP[m1,m2,z] + a/b * HYP[n1,n2,z]; end: `HYPERG/C40`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ b-1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ b+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (b-a)*z/(b-1)/b * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C41`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ b+1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ b+2, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - (b-a)*z/b/(1+b) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C42`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a, op(tmp1) ]; m2 := [ b-1, op(tmp2) ]; n1 := [ a-1, op(tmp1) ]; n2 := [ b-2, op(tmp2) ]; (b-2)*(b-1)/(b-a-1)/z * prod2/prod1 * HYP[m1,m2,z] - (b-2)*(b-1)/(b-a-1)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C43`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ b+1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a,1+a+b, seq(op(i,l1)+1,i=1..nops(l1))]; n2 := [ b+2,a+b, seq(op(i,l2)+1,i=1..nops(l2))]; HYP[m1,m2,z] + (a+b)*z/b/(1+b) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C44`:=proc(shyp,up1,dw1) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); l1 := subsop(up1=NULL,l1); b := op(dw1,l2); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ b-1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ 1+a,a+b+1, seq(op(i,l1)+1,i=1..nops(l1))]; n2 := [ b+1,a+b, seq(op(i,l2)+1,i=1..nops(l2))]; HYP[m1,m2,z] - (a+b)*z/(b-1)/b * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C45`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, m1,m2,n1,n2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := l1; m2 := [ -1+a, b, op(l2) ]; n1 := l1; n2 := [ a, -1+b, op(l2)]; (a-1)/(a-b) * HYP[m1,m2,z] + (b-1)/(b-a) * HYP[n1,n2,z]; end: `HYPERG/C46`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, m1,m2,n1,n2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := l1; m2 := [ a+1, b-1, op(l2) ]; n1 := l1; n2 := [ a+1, b, op(l2)]; (b-1)/a * HYP[m1,m2,z] + (1+a-b)/a * HYP[n1,n2,z]; end: `HYPERG/C49`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := l1; m2 := [ a+1, b-1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ a+2, b+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (b-a-1)*z/a/(1+a)/(b-1)/b*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C50`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := tmp1; m2 := [ -2+a, b-1, op(tmp2) ]; n1 := tmp1; n2 := [ a-1, b-2, op(tmp2) ]; (a-2)*(a-1)*(b-2)*(b-1)/(b-a)/z * prod2/prod1 * HYP[m1,m2,z] - (a-2)*(a-1)*(b-2)*(b-1)/(b-a)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C51`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := l1; m2 := [ a+1, b+1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a+b+2, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ a+2, b+2, a+b+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (1+a+b)*z/a/(1+a)/b/(1+b)*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C52`:=proc(shyp,dw1,dw2) local l1,l2,z,a,b, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := l1; m2 := [ a-1, b-1, op(l2) ]; prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); n1 := [ a+b, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ a+1, 1+b, b-a+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - (a+b-1)*z/(a-1)/a/(b-1)/b*prod1/prod2 * HYP[n1,n2,z]; end: # Three-term relations with three parameters # `HYPERG/C53`:=proc(shyp,up1,up2,up3) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); c := op(up3,l1); l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); m1 := [ a, b+1, c-1, op(l1) ]; m2 := l2; n1 := [ a+1, b, c-1, op(l1) ]; n2 := l2; b*(c-a-1)/(b-a)/(c-1) * HYP[m1,m2,z] + a*(c-b-1)/(a-b)/(c-1) * HYP[n1,n2,z]; end: `HYPERG/C54`:=proc(shyp,up1,up2,dw1) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); c := op(dw1,l2); l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a, b+1, op(l1) ]; m2 := [ c+1, op(l2) ]; n1 := [ a+1, b, op(l1) ]; n2 := [ c+1, op(l2) ]; b*(c-a)/(b-a)/c * HYP[m1,m2,z] + a*(c-b)/(a-b)/c * HYP[n1,n2,z]; end: `HYPERG/C55`:=proc(shyp,up1,up2,dw1) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(up2,l1); c := op(dw1,l2); l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, b, op(l1) ]; m2 := [ c-1, op(l2) ]; n1 := [ a-1, b+1, op(l1) ]; n2 := [ c, op(l2) ]; (1-a+b)*(c-1)/(a-1)/(1+b-c) * HYP[m1,m2,z] + b*(c-a)/(a-1)/(c-b-1) * HYP[n1,n2,z]; end: `HYPERG/C56`:=proc(shyp,up1,dw1,dw2) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(dw1,l2); c := op(dw2,l2); l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a, op(l1) ]; m2 := [ b-1, c+1, op(l2) ]; n1 := [ a+1, op(l1) ]; n2 := [ b, c+1, op(l2) ]; (b-1)*(c-a)/(b-a-1)/c * HYP[m1,m2,z] + a*(1-b+c)/(1+a-b)/c * HYP[n1,n2,z]; end: `HYPERG/C57`:=proc(shyp,up1,dw1,dw2) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(up1,l1); b := op(dw1,l2); c := op(dw2,l2); l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ b-1, c, op(l2) ]; n1 := [ a-1, op(l1) ]; n2 := [ b, c-1, op(l2) ]; (b-1)*(c-a)/(a-1)/(c-b) * HYP[m1,m2,z] + (b-a)*(c-1)/(a-1)/(b-c) * HYP[n1,n2,z]; end: `HYPERG/C58`:=proc(shyp,dw1,dw2,dw3) local l1,l2,z,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); a := op(dw1,l2); b := op(dw2,l2); c := op(dw3,l2); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := l1; m2 := [ a-1, b, c+1, op(l2) ]; n1 := l1; n2 := [ a, b-1, c+1, op(l2) ]; (a-1)*(1-b+c)/(a-b)/c * HYP[m1,m2,z] + (b-1)*(1-a+c)/(b-a)/c * HYP[n1,n2,z]; end: # Three-term relations with four parameters # `HYPERG/C59`:=proc(shyp,up1,up2,up3,up4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); a := A; b := C; c := B-2+A; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C59 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); m1 := [ a-1, 1-a+c, b, c-b, op(l1) ]; m2 := l2; n1 := [ a-1, 1-a+c, b+1, 1+c-b, op(l1) ]; n2 := l2; (a-b-1)*(1-a-b+c)/(a-1)/(1-a+c) * HYP[m1,m2,z] + b*(c-b)/(a-1)/(1-a+c) * HYP[n1,n2,z]; end: `HYPERG/C60`:=proc(shyp,up1,up2,up3,up4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C60 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); m1 := [ a+1, 1-a+c, b, c-b, op(l1) ]; m2 := l2; n1 := [ a, c-a, b+1, 1+c-b, op(l1) ]; n2 := l2; a*(c-a)/(a-b)/(c-a-b) * HYP[m1,m2,z] - b*(c-b)/(a-b)/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C61`:=proc(shyp,up1,up2,up3,up4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C61 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); m1 := [ a+1, c-a-1, b+1, -1-b+c, op(l1) ]; m2 := l2; n1 := [ 1+(c-1)/2, a, -1-a+c, b, c-b-1, op(l1) ]; n2 := [ (c-1)/2, op(l2) ]; a*b/(c-a-1)/(c-b-1) * HYP[m1,m2,z] - (c-1)(-1-a-b+c)/(c-a-1)/(c-b-1) * HYP[n1,n2,z]; end: `HYPERG/C62`:=proc(shyp,up1,up2,up3,up4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=2-b+c)=false then ERROR(`Enable to apply C62 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, 1-a+c, b-1, 1+c-b, op(l1) ]; m2 := l2; n1 := [ a+1, 1-a+c, b, 2-b+c, c+2, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ c+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (a-b+1)*(1+c)*(c-a-b+1) * z*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C63`:=proc(shyp,up1,up2,up3,up4,plus) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); a := A; b := C; c := B+A-2; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C63 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); m1 := [ a-1, 1-a+c, b+1, 1-b+c, op(l1) ]; m2 := l2; n1 := [ a-1, 1-a+c, b, -b+c, plus+1, 1+c-plus, op(l1) ]; n2 := [ plus, c-plus, op(l2) ]; b*(c-b)*(a-plus-1)*(1-a+c-plus) /(a-1)/(1-a+c)/(b-plus)/(c-b-plus) * HYP[m1,m2,z] + (1-a+b)*(1-a-b+c)*(c-plus)*plus/(a-1) /(1-a+c)/(b-plus)/(c-b-plus) * HYP[n1,n2,z]; end: `HYPERG/C64`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C64 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, c-a, b, op(l1) ]; m2 := [ c-b, op(l2) ]; n1 := [ a-1, c-a, b+1, op(l1) ]; n2 := [ -1-b+c, op(l2) ]; (a-b-1)*(c-a-b)/(a-1)/(c-a) * HYP[m1,m2,z] + b*(c-b-1)/(a-1)/(c-a) * HYP[n1,n2,z]; end: `HYPERG/C65`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C65 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, 1-a+c, b-1, op(l1) ]; m2 := [ 2-b+c, op(l2) ]; n1 := [ a, c-a, b-1, op(l1) ]; n2 := [ 2-b+c, op(l2) ]; a*(c-a)/(b-1)/(1-b+c) * HYP[m1,m2,z] - (1+a-b)*(1-a-b-c)/(b-1)/(1-b+c) * HYP[n1,n2,z]; end: `HYPERG/C66`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C66 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, 1-a+c, b, op(l1) ]; m2 := [ 1-b+c, op(l2) ]; n1 := [ a, c-a, b+1, op(l1) ]; n2 := [ c-b, op(l2) ]; a*(c-a)/(a-b)/(c-a-b) * HYP[m1,m2,z] - b*(c-b)/(a-b)/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C67`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C67 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, c-a, b+1, op(l1) ]; m2 := [ 1-b+c, op(l2) ]; n1 := [ 1+c/2, a, c-a, b, op(l1) ]; n2 := [ c/2, 1-b+c, op(l2) ]; a*b/(c-a)/(c-b) * HYP[m1,m2,z] + c*(c-a-b)/(c-a)/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C68`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C68 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, 1-a+c, b-1, op(l1) ]; m2 := [ c-b, op(l2) ]; n1 := [ 1+(c-1)/2, -1+a, c-a, b-1, op(l1) ]; n2 := [ (c-1)/2, 1-b+c, op(l2) ]; (c-a)*(c-b)/(a-1)/(b-1) * HYP[m1,m2,z] - (c-1)*(1-a-b+c)/(a-1)/(b-1) * HYP[n1,n2,z]; end: `HYPERG/C69`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C69 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, 1-a+c, b-1, op(l1) ]; m2 := [ 2-b+c, op(l2) ]; n1 := [ a+1, 1-a+c, b, c+2, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 3-b+c, c+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (1+a-b)*(1+c)*(1-a-b+c) * z /(1-b+c)/(2-b+c) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C70`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C70 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a-1, c-a, b+1, op(l1) ]; m2 := [ -1-b+c, op(l2) ]; n1 := [ a, 1-a+c, b+1, c+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 1-b+c, c, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - (a-b-1)*c*(c-a-b) * z /(c-b-1)/(c-b) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C71`:=proc(shyp,up1,up2,up3,dw1,plus) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C71 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a-1, c-a, b+1, op(l1) ]; m2 := [ -1-b+c, op(l2) ]; n1 := [ a-1, c-a, b, plus+1, c-plus, op(l1) ]; n2 := [ c-b, plus, c-plus-1, op(l2) ]; b*(c-b-1)*(a-plus-1)*(c-a-plus) /(a-1)/(c-a)/(b-plus)/(c-b-1-plus) * HYP[m1,m2,z] + (1-a+b)*(c-a-b)*(c-plus-1)*plus /(a-1)/(c-a)/(b-plus)/(c-b-1-plus) * HYP[n1,n2,z]; end: `HYPERG/C72`:=proc(shyp,up1,up2,up3,dw1,plus) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C72 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a+1, 1-a+c, b-1, op(l1) ]; m2 := [ 2-b+c, op(l2) ]; n1 := [ a, c-a, b-1, plus+1, 1+c-plus, op(l1) ]; n2 := [ 2-b+c, plus, c-plus, op(l2) ]; a*(c-a)*(b-plus-1)*(1-b+c-plus) /(b-1)/(1-b+c)/(a-plus)/(c-a-plus) * HYP[m1,m2,z] - (b-a-1)*(1-a-b+c)*(c-plus)*plus /(b-1)/(1-b+c)/(a-plus)/(c-a-plus) * HYP[n1,n2,z]; end: `HYPERG/C73`:=proc(shyp,up1,up2,up3,dw1) local l1,l2,z,A,B,C,D,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); a := A; b := B; if `HYPERG/Egalite`(C=a+b)=false or `HYPERG/Egalite`(D=b-a+1)=false then ERROR(`Enable to apply C73 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a, b, op(tmp1) ]; m2 := tmp2; n1 := [ a-1, b-1, op(tmp1) ]; n2 := tmp2; 1/(a+b-1)/z * prod2/prod1 * HYP[m1,m2,z] - 1/(a+b-1)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C74`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C74 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, b, op(l1) ]; m2 := [ 1-a+c, -b+c, op(l2) ]; n1 := [ a-1, b+1, op(l1) ]; n2 := [ 1-a+c, c-b-1, op(l2) ]; (a-b-1)*(c-a-b)/(a-1)/(c-a) * HYP[m1,m2,z] + b*(c-b-1)/(a-1)/(c-a) * HYP[n1,n2,z]; end: `HYPERG/C75`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C75 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, b, op(l1) ]; m2 := [ c-a-1, -b+c, op(l2) ]; n1 := [ a, b+1, op(l1) ]; n2 := [ c-a-1, -1-b+c, op(l2) ]; a*(c-a-1)/(a-b)/(-1-a-b+c) * HYP[m1,m2,z] - b*(c-b-1)/(a-b)/(-1-a-b+c) * HYP[n1,n2,z]; end: `HYPERG/C76`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C76 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, b+1, op(l1) ]; m2 := [ 1-a+c, 1-b+c, op(l2) ]; n1 := [ 1+c/2, a, b, op(l1) ]; n2 := [ c/2, 1-a+c, 1-b+c, op(l2) ]; a*b/(c-a)/(c-b) * HYP[m1,m2,z] + c*(c-a-b)/(c-a)/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C77`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C77 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, b-1, op(l1) ]; m2 := [ c-a-1, c-b-1, op(l2) ]; n1 := [ 1+(c-2)/2, -1+a, b-1, op(l1) ]; n2 := [ (c-2)/2, c-a, c-b, op(l2) ]; (c-a-1)*(c-b-1)/(a-1)/(b-1) * HYP[m1,m2,z] - (c-2)*(c-a-b)/(a-1)/(b-1) * HYP[n1,n2,z]; end: `HYPERG/C78`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C78 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, b-1, op(l1) ]; m2 := [ c-a-1, 1-b+c, op(l2) ]; n1 := [ a+1, b, c+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 1-a+c, 2-b+c, c, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (1+a-b)*c*(c-a-b)*z/(c-a-1)/(c-a)/(c-b)/(1-b+c)*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C79`:=proc(shyp,up1,up2,dw1,dw2,plus) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C79 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, b+1, op(l1) ]; m2 := [ 1-a+c, c-b-1, op(l2) ]; n1 := [ a-1, b, plus+1, c-plus, op(l1) ]; n2 := [ 1-a+c, c-b, plus, c-plus-1, op(l2) ]; b*(c-b-1)*(a-plus-1)*(c-a-plus) /(a-1)/(c-a)/(b-plus)/(c-b-1-plus) * HYP[m1,m2,z] + (1-a+b)*(c-a-b)*(c-plus-1)*plus /(a-1)/(c-a)/(b-plus)/(c-b-1-plus) * HYP[n1,n2,z]; end: `HYPERG/C80`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C80 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, c-a-1, op(l1) ]; m2 := [ b-1, c-b-1, op(l2) ]; n1 := [ a-1, c-a-1, op(l1) ]; n2 := [ b, -b+c, op(l2) ]; (b-1)*(c-b-1)/(a-1)/(c-a-1) * HYP[m1,m2,z] + (a-b)*(c-a-b)/(a-1)/(c-a-1) * HYP[n1,n2,z]; end: `HYPERG/C81`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C81 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, 1-a+c, op(l1) ]; m2 := [ b+1, 1-b+c, op(l2) ]; n1 := [ a, c-a, op(l1) ]; n2 := [ b+1, 1-b+c, op(l2) ]; a*(c-a)/b/(c-b) * HYP[m1,m2,z] - (a-b)*(c-a-b)/b/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C82`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D-2; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C82 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, 1-a+c, op(l1) ]; m2 := [ b, 2-b+c, op(l2) ]; n1 := [ a, c-a, op(l1) ]; n2 := [ b-1, 1-b+c, op(l2) ]; a*(c-a)/(1+a-b)/(1-a-b+c) * HYP[m1,m2,z] - (b-1)*(1-b+c)/(1+a-b)/(1-a-b+c) * HYP[n1,n2,z]; end: `HYPERG/C83`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C83 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, -1-a+c, op(l1) ]; m2 := [ b-1, 1-b+c, op(l2) ]; n1 := [ 1+(c-1)/2, a, -1-a+c, op(l1) ]; n2 := [ (c-1)/2, b, 1-b+c, op(l2) ]; a*(b-1)/(c-a-1)/(c-b) * HYP[m1,m2,z] + (c-1)*(c-a-b)/(c-a-1)/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C84`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C84 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, 1-a+c, op(l1) ]; m2 := [ b+1, 1-b+c, op(l2) ]; n1 := [ a+1, 1-a+c, c+2, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ b+2, 2-b+c, c+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (a-b)*(1+c)*(c-a-b)*z/b/(1+b)/(c-b)/(1-b+c)*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C85`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := B; c := C+A; cp := D+B; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C85 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a-1, c-a-1, op(l1) ]; m2 := [ b-1, -1-b+c, op(l2) ]; n1 := [ a, c-a, c, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 1+b, 1-b+c, c-1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - (a-b)*(c-1)*(c-a-b)*z/(b-1)/b/(c-b-1)/(c-b)*prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C86`:=proc(shyp,up1,up2,dw1,dw2,plus) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C86 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a-1, c-a-1, op(l1) ]; m2 := [ b-1, c-b-1, op(l2) ]; n1 := [ a-1, c-a-1, plus+1, c-plus-1, op(l1) ]; n2 := [ b, c-b, plus, c-plus-2, op(l2) ]; (b-1)*(c-b-1)*(a-plus-1)*(c-a-1-plus) /(a-1)/(c-a-1)/(b-plus-1)/(c-b-1-plus) * HYP[m1,m2,z] + (b-a)*(c-a-b)*(c-plus-2)*plus /(a-1)/(c-a-1)/(b-plus-1)/(c-b-1-plus) * HYP[n1,n2,z]; end: `HYPERG/C87`:=proc(shyp,up1,up2,dw1,dw2,plus) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C; c := A+B; cp := C+D; if `HYPERG/Egalite`(c=cp)=false then ERROR(`Enable to apply C87 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, 1-a+c, op(l1) ]; m2 := [ b+1, 1-b+c, op(l2) ]; n1 := [ a, c-a, plus+1, 1+c-plus, op(l1) ]; n2 := [ b+1, 1-b+c, plus, c-plus, op(l2) ]; a*(c-a)*(b-plus)*(c-b-plus)/b/(c-b)/(a-plus)/(c-a-plus) * HYP[m1,m2,z] - (b-a)*(c-a-b)*(c-plus)*plus/b/(c-b)/(a-plus)/(c-a-plus) * HYP[n1,n2,z]; end: `HYPERG/C88`:=proc(shyp,up1,up2,dw1,dw2) local l1,l2,z,A,B,C,D,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); a := A; b := C-1; if `HYPERG/Egalite`(B=a+b)=false or `HYPERG/Egalite`(D=b-a+1)=false then ERROR(`Enable to apply C88 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a, op(tmp1) ]; m2 := [ b-1, op(tmp2) ]; n1 := [ a-1, op(tmp1) ]; n2 := [ b, op(tmp2) ]; (b-1)*b/(a+b-1)/z * prod2/prod1 * HYP[m1,m2,z] - (b-1)*b/(a+b-1)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C89`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C89 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ 1-a+c, b-1, c-b, op(l2) ]; n1 := [ a-1, op(l1) ]; n2 := [ 1-a+c, b, 1-b+c, op(l2) ]; (b-1)*(c-b)/(a-1)/(c-a) * HYP[m1,m2,z] + (a-b)*(1-a-b+c)/(a-1)/(c-a) * HYP[n1,n2,z]; end: `HYPERG/C90`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C90 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ c-a, b+1, 1-b+c, op(l2) ]; n1 := [ a, op(l1) ]; n2 := [ 1-a+c, b+1, 1-b+c, op(l2) ]; a*(c-a)/b/(c-b) * HYP[m1,m2,z] + (a-b)*(c-a-b)/b/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C91`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C91 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ c-a-1, b, 1-b+c, op(l2) ]; n1 := [ a, op(l1) ]; n2 := [ c-a, b-1, c-b, op(l2) ]; a*(c-a-1)/(1+a-b)/(c-a-b) * HYP[m1,m2,z] - (b-1)*(c-b)/(1+a-b)/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C92`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C92 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ 1-a+c, b-1, 2-b+c, op(l2) ]; n1 := [ 1+c/2, a, op(l1) ]; n2 := [ c/2, 1-a+c, b, 2-b+c, op(l2) ]; a*(b-1)/(c-a)/(1-b+c) * HYP[m1,m2,z] + c*(1-a-b+c)/(c-a)/(1-b+c) * HYP[n1,n2,z]; end: `HYPERG/C93`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C93 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ c-a, b+1, -1-b+c, op(l2) ]; n1 := [ 1+(c-1)/2, -1+a, op(l1) ]; n2 := [ (c-1)/2, 1-a+c, b+1, c-b, op(l2) ]; (c-a)*(c-b-1)/(a-1)/b * HYP[m1,m2,z] - (c-1)*(c-a-b)/(a-1)/b * HYP[n1,n2,z]; end: `HYPERG/C94`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C94 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a+1, op(l1) ]; m2 := [ c-a, b+1, 1-b+c, op(l2) ]; n1 := [ a+1, c+2, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 2-a+c, b+2, 2-b+c, c+1, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] + (a-b)*(1+c)*(c-a-b)*z/b/(1+b)/(c-a)/(1-a+c)/(c-b)/(1-b+c) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C95`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C95 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); m1 := [ a-1, op(l1) ]; m2 := [ 1-a+c, b-1, -b+c, op(l2) ]; n1 := [ a, c+1, seq(op(i,l1)+1,i=1..nops(l1)) ]; n2 := [ 2-a+c, b+1, 2-b+c, c, seq(op(i,l2)+1,i=1..nops(l2)) ]; HYP[m1,m2,z] - (a-b)*c*(1-a-b+c)*z/(b-1)/b/(c-a)/(1-a+c)/(c-b)/(1-b+c) * prod1/prod2 * HYP[n1,n2,z]; end: `HYPERG/C96`:=proc(shyp,up1,dw1,dw2,dw3,plus) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A; if `HYPERG/Egalite`(D=1-b+c)=false then ERROR(`Enable to apply C96 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a-1, op(l1) ]; m2 := [ 1-a+c, b-1, c-b, op(l2) ]; n1 := [ a-1, plus+1, c-plus, op(l1) ]; n2 := [ 1-a+c, b, 1-b+c, plus, c-plus-1, op(l2) ]; (b-1)*(c-b)*(a-plus-1)*(c-a-plus) /(a-1)/(c-a)/(b-plus-1)/(c-b-plus) * HYP[m1,m2,z] + (b-a)*(1-a-b+c)*(c-plus-1)*plus /(a-1)/(c-a)/(b-plus-1)/(c-b-plus) * HYP[n1,n2,z]; end: `HYPERG/C97`:=proc(shyp,up1,dw1,dw2,dw3,plus) local l1,l2,z,A,B,C,D,a,b,c,cp, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := A; b := C; c := B+A-1; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C97 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ c-a, b+1, 1-b+c, op(l2) ]; n1 := [ a, plus+1, 1+c-plus, op(l1) ]; n2 := [ 1-a+c, b+1, 1-b+c, plus, c-plus, op(l2) ]; a*(c-a)*(b-plus)*(c-b-plus)/b/(c-b)/(a-plus)/(c-a-plus) * HYP[m1,m2,z] - (b-a)*(c-a-b)*(c-plus)*plus/b/(c-b)/(a-plus)/(c-a-plus) * HYP[n1,n2,z]; end: `HYPERG/C98`:=proc(shyp,up1,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,a,b, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); a := B-1; b := C-1; if `HYPERG/Egalite`(A=a+b)=false or `HYPERG/Egalite`(D=b-a+1)=false then ERROR(`Enable to apply C98 with parameters`,A,B,C,D); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := tmp1; m2 := [ a-1, b-1, op(tmp2) ]; n1 := tmp1; n2 := [ a, b, op(tmp2) ]; (a-1)*a*(b-1)*b/(a+b-1)/z * prod2/prod1 * HYP[m1,m2,z] - (a-1)*a*(b-1)*b/(a+b-1)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C99`:=proc(shyp,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(dw1,l2); B := op(dw2,l2); C := op(dw3,l2); D := op(dw4,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=2-b+c)=false then ERROR(`Enable to apply C99 with parameters`,A,B,C,D); fi: l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := l1; m2 := [ a+1, 1-a+c, b-1, 1-b+c, op(l2) ]; n1 := l1; n2 := [ a+1, 1-a+c, b, 2-b+c, op(l2) ]; (b-1)*(1-b+c)/a/(c-a) * HYP[m1,m2,z] + (1+a-b)*(1-a-b+c)/a/(c-a) * HYP[n1,n2,z]; end: `HYPERG/C100`:=proc(shyp,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(dw1,l2); B := op(dw2,l2); C := op(dw3,l2); D := op(dw4,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C100 with parameters`,A,B,C,D); fi: l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := l1; m2 := [ a-1, c-a-1, b-1, 1-b+c, op(l2) ]; n1 := l1; n2 := [ a, c-a, b-1, -1-b+c, op(l2) ]; (a-1)*(c-a-1)/(a-b)/(c-a-b) * HYP[m1,m2,z] - (b-1)*(c-b-1)/(a-b)/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C101`:=proc(shyp,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(dw1,l2); B := op(dw2,l2); C := op(dw3,l2); D := op(dw4,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C101 with parameters`,A,B,C,D); fi: l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := l1; m2 := [ a-1, 1-a+c, b-1, 1-b+c, op(l2) ]; n1 := [ 1+(c-1)/2, op(l1) ]; n2 := [ (c-1)/2, a, 1-a+c, b, 1-b+c, op(l2) ]; (a-1)*(b-1)/(c-a)/(c-b) * HYP[m1,m2,z] + (c-1)*(1-a-b+c)/(c-a)/(c-b) * HYP[n1,n2,z]; end: `HYPERG/C102`:=proc(shyp,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(dw1,l2); B := op(dw2,l2); C := op(dw3,l2); D := op(dw4,l2); a := A; b := C; c := A+B-2; if `HYPERG/Egalite`(D=c-b)=false then ERROR(`Enable to apply C102 with parameters`,A,B,C,D); fi: l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); prod1 := convert(l1,`*`); prod2 := convert(l2,`*`); tmp1 := [ seq(op(i,l1)+1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)+1,i=1..nops(l2)) ]; m1 := l1; m2 := [ a-1, 1-a+c, b+1, 1-b+c, op(l2) ]; n1 := [ c+2, op(tmp1) ]; n2 := [ a+1, 3-a+c, b+2, 2-b+c, c+1, op(tmp2) ]; HYP[m1,m2,z] + (a-b-1)*(1+c)*(1-a-b+c)*z/(a-1)/a/b/(1+b)/(1-a+c)/(2-a+c)/(c-b)/(1-b+c) * prod1 / prod2 * HYP[n1,n2,z]; end: `HYPERG/C103`:=proc(shyp,dw1,dw2,dw3,dw4,plus) local l1,l2,z,A,B,C,D,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(dw1,l2); B := op(dw2,l2); C := op(dw3,l2); D := op(dw4,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=2-b+c)=false then ERROR(`Enable to apply C103 with parameters`,A,B,C,D); fi: l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := l1; m2 := [ a+1, 1-a+c, b-1, 1-b+c, op(l2) ]; n1 := [ plus+1, 1+c-plus, op(l1) ]; n2 := [ 1+a, 1-a+c, b, 2-b+c, plus, c-plus, op(l2) ]; (b-1)*(1-b+c)*(a-plus)*(c-a-plus)/a/(c-a)/(b-plus-1)/(1-b+c-plus) * HYP[m1,m2,z] + (b-a-1)*(1-a-b+c)*(c-plus)*plus/a/(c-a)/(b-plus-1)/(1-b+c-plus) * HYP[n1,n2,z]; end: `HYPERG/C104`:=proc(shyp,up1,up2,up3,up4,up5,dw1) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(up5,l1); F := op(dw1,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=c-b)=false or `HYPERG/Egalite`(E=c)=false or `HYPERG/Egalite`(F=c-1)=false then ERROR(`Enable to apply C104 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,up5=NULL,l1); l2 := subsop(dw1=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a-1, c-a-1, b, -b+c, op(tmp1) ]; m2 := tmp2; n1 := [ a, c-a, b-1, -1-b+c, op(tmp1) ]; n2 := tmp2; 1/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[m1,m2,z] - 1/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C110`:=proc(shyp,up1,up2,up3,up4,up5,dw1) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(up5,l1); F := op(dw1,l2); a := B; b := D; c := 2*F; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(C=c-a)=false or `HYPERG/Egalite`(E=c-b)=false then ERROR(`Enable to apply C110 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,up5=NULL,l1); l2 := subsop(dw1=NULL,l2); m1 := [ a, 1-a+c, b, 1-b+c, op(l1) ]; m2 := l2; n1 := [ a+1, c-a, b+1, c-b, op(l1) ]; n2 := l2; (c-a)*(c-b)/c/(c-a-b) * HYP[m1,m2,z] - a*b/c/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C105`:=proc(shyp,up1,up2,up3,up4,dw1,dw2) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(dw1,l2); F := op(dw2,l2); a := A; b := C; c := A+B; if `HYPERG/Egalite`(D=c)=false or `HYPERG/Egalite`(E=1-b+c)=false or `HYPERG/Egalite`(F=-1+c)=false then ERROR(`Enable to apply C105 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a-1, c-a-1, b, op(tmp1) ]; m2 := [ c-b-1, op(tmp2) ]; n1 := [ a, c-a, b-1, op(tmp1) ]; n2 := [ c-b, op(tmp2) ]; (c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[m1,m2,z] - (c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C112`:=proc(shyp,up1,up2,up3,up4,dw1,dw2) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(dw1,l2); F := op(dw2,l2); a := B; b := D; c := 2*E; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(C=c-a)=false or `HYPERG/Egalite`(F=1-b+c)=false then ERROR(`Enable to apply C112 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a, 1-a+c, b, op(l1) ]; m2 := [ c-b, op(l2) ]; n1 := [ a+1, c-a, b+1, op(l1) ]; n2 := [ 1-b+c, op(l2) ]; (c-a)*(c-b)/c/(c-a-b) * HYP[m1,m2,z] - ab/c/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C106`:=proc(shyp,up1,up2,up3,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); E := op(dw2,l2); F := op(dw3,l2); a := A; b := B; c := C; if `HYPERG/Egalite`(D=1-a+c)=false or `HYPERG/Egalite`(E=1-b+c)=false or `HYPERG/Egalite`(F=-1+c)=false then ERROR(`Enable to apply C106 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a-1, b, op(tmp1) ]; m2 := [ -a+c, c-b-1, op(tmp2) ]; n1 := [ a, b-1, op(tmp1) ]; n2 := [ -1-a+c, c-b, op(tmp2) ]; (c-a-1)*(c-a)*(c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[m1,m2,z] - (c-a-1)*(c-a)*(c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C107`:=proc(shyp,up1,up2,up3,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); E := op(dw2,l2); F := op(dw3,l2); a := A; b := D-1; c := C; if `HYPERG/Egalite`(B=c-a)=false or `HYPERG/Egalite`(E=1-b+c)=false or `HYPERG/Egalite`(F=-1+c)=false then ERROR(`Enable to apply C107 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ -1+a, c-a-1, op(tmp1) ]; m2 := [ b-1, c-b-1, op(tmp2) ]; n1 := [ a, c-a, op(tmp1) ]; n2 := [ b, c-b, op(tmp2) ]; (b-1)*b*(c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[m1,m2,z] - (b-1)*b*(c-b-1)*(c-b)/(a-b)/(c-1)/(c-a-b)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C114`:=proc(shyp,up1,up2,up3,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); E := op(dw2,l2); F := op(dw3,l2); a := B; b := C; c := 2*D; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(E=1-a+c)=false or `HYPERG/Egalite`(F=1-b+c)=false then ERROR(`Enable to apply C114 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a, b, op(l1) ]; m2 := [ c-a, -b+c, op(l2) ]; n1 := [ a+1, b+1, op(l1) ]; n2 := [ 1-a+c, 1-b+c, op(l2) ]; (c-a)*(c-b)/c/(c-a-b) * HYP[m1,m2,z] - a*b/c/(c-a-b) * HYP[n1,n2,z]; end: `HYPERG/C115`:=proc(shyp,up1,up2,up3,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); E := op(dw2,l2); F := op(dw3,l2); a := B; b := E; c := 2*D; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(C=c-a)=false or `HYPERG/Egalite`(F=2-b+c)=false then ERROR(`Enable to apply C115 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a, 1-a+c, op(l1) ]; m2 := [ b, 1-b+c, op(l2) ]; n1 := [ a+1, c-a, op(l1) ]; n2 := [ -1+b, 2-b+c, op(l2) ]; (c-a)*(1-b+c)/c/(1-a-b+c) * HYP[m1,m2,z] - a*(b-1)/c/(1-a-b+c) * HYP[n1,n2,z]; end: `HYPERG/C108`:=proc(shyp,up1,up2,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); E := op(dw3,l2); F := op(dw4,l2); a := A; b := D; c := B; if `HYPERG/Egalite`(C=1-a+c)=false or `HYPERG/Egalite`(E=2-b+c)=false or `HYPERG/Egalite`(F=-1+c)=false then ERROR(`Enable to apply C108 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := [ a-1, op(tmp1) ]; m2 := [ c-a, b-2, c-b, op(tmp2) ]; n1 := [ a, op(tmp1) ]; n2 := [ c-a-1, b-1, 1-b+c, op(tmp2) ]; (b-2)*(b-1)*(c-a-1)*(c-a)*(c-b)*(1-b+c)/(1+a-b)/(c-1)/(1-a-b+c)/z * prod2/prod1 * HYP[m1,m2,z] - (b-2)*(b-1)*(c-a-1)*(c-a)*(c-b)*(1-b+c)/(1+a-b)/(c-1)/(1-a-b+c)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C118`:=proc(shyp,up1,up2,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); E := op(dw3,l2); F := op(dw4,l2); a := B; b := E; c := 2*C; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(D=1-a+c)=false or `HYPERG/Egalite`(F=2-b+c)=false then ERROR(`Enable to apply C118 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := [ a, op(l1) ]; m2 := [ c-a, b, 1-b+c, op(l2) ]; n1 := [ a+1, op(l1) ]; n2 := [ 1-a+c, b-1, 2-b+c, op(l2) ]; (c-a)*(1-b+c)/c/(1-a-b+c) * HYP[m1,m2,z] - a*(b-1)/c/(1-a-b+c) * HYP[n1,n2,z]; end: `HYPERG/C109`:=proc(shyp,up1,dw1,dw2,dw3,dw4,dw5) local l1,l2,z,A,B,C,D,E,F,a,b,c, tmp1,tmp2,m1,m2,n1,n2,prod1,prod2,i; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); E := op(dw4,l2); F := op(dw5,l2); a := B; b := D; c := A; if `HYPERG/Egalite`(C=2-a+c)=false or `HYPERG/Egalite`(E=2-b+c)=false or `HYPERG/Egalite`(F=-1+c)=false then ERROR(`Enable to apply C109 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,dw5=NULL,l2); tmp1 := [ seq(op(i,l1)-1,i=1..nops(l1)) ]; tmp2 := [ seq(op(i,l2)-1,i=1..nops(l2)) ]; prod1 := convert(tmp1,`*`); prod2 := convert(tmp2,`*`); m1 := tmp1; m2 := [ a-1, 1-a+c, b-2, c-b, op(tmp2) ]; n1 := tmp1; n2 := [ a-2, c-a, b-1, 1-b+c, op(tmp2) ]; (a-2)*(a-1)*(b-2)*(b-1)*(c-a)*(1-a+c)*(c-b)*(1-b+c)/(a-b)/(c-1)/(2-a-b+c)/z * prod2/prod1 * HYP[m1,m2,z] - (a-2)*(a-1)*(b-2)*(b-1)*(c-a)*(1-a+c)*(c-b)*(1-b+c)/(a-b)/(c-1)/(2-a-b+c)/z * prod2/prod1 * HYP[n1,n2,z]; end: `HYPERG/C120`:=proc(shyp,up1,dw1,dw2,dw3,dw4,dw5) local l1,l2,z,A,B,C,D,E,F,a,b,c, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(dw1,l2); C := op(dw2,l2); D := op(dw3,l2); E := op(dw4,l2); F := op(dw5,l2); a := C; b := E; c := 2*B; if `HYPERG/Egalite`(A=1+c/2)=false or `HYPERG/Egalite`(D=2-a+c)=false or `HYPERG/Egalite`(F=2-b+c)=false then ERROR(`Enable to apply C120 with parameters`,A,B,C,D,E,F); fi: l1 := subsop(up1=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,dw5=NULL,l2); m1 := l1; m2 := [ a, 1-a+c, b, 1-b+c, op(l2) ]; n1 := l1; n2 := [ a-1, 2-a+c, b-1, 2-b+c, op(l2) ]; (1-a+c)*(1-b+c)/c/(2-a-b+c) * HYP[m1,m2,z] - (a-1)*(b-1)/c/(2-a-b+c) * HYP[n1,n2,z]; end: `HYPERG/C111`:=proc(shyp,up1,up2,up3,up4,up5,up6,dw1,dw2) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(up5,l1); F := op(up6,l1); G := op(dw1,l2); H := op(dw2,l2); a := A; b := C; c := A+B; d := G; if `HYPERG/Egalite`(D=c-b)=false or `HYPERG/Egalite`(E=d+1)=false or `HYPERG/Egalite`(F=1+c-d)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C111 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,up5=NULL,up6=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,l2); m1 := [ a+1, 1-a+c, b, -b+c, op(l1) ]; m2 := l2; n1 := [ a, c-a, b+1, 1-b+c, op(l1) ]; n2 := l2; a*(c-a)*(b-d)*(c-b-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[m1,m2,z] - b*(c-b)*(a-d)*(c-a-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/C113`:=proc(shyp,up1,up2,up3,up4,up5,dw1,dw2,dw3) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(up5,l1); F := op(dw1,l2); G := op(dw2,l2); H := op(dw3,l2); a := A; b := C; c := A+B; d := G; if `HYPERG/Egalite`(D=d+1)=false or `HYPERG/Egalite`(E=1+c-d)=false or `HYPERG/Egalite`(F=1-b+c)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C113 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,up5=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,l2); m1 := [ a+1, 1-a+c, b, op(l1) ]; m2 := [ 1-b+c, op(l2) ]; n1 := [ a, c-a, b+1, op(l1) ]; n2 := [ c-b, op(l2) ]; a*(c-a)*(b-d)*(c-b-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[m1,m2,z] - b*(c-b)*(a-d)*(c-a-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/C116`:=proc(shyp,up1,up2,up3,up4,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(dw1,l2); F := op(dw2,l2); G := op(dw3,l2); H := op(dw4,l2); a := A; b := B; c := A+E-1; d := G; if `HYPERG/Egalite`(C=d+1)=false or `HYPERG/Egalite`(D=1+c-d)=false or `HYPERG/Egalite`(F=1-b+c)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C116 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := [ a+1, b, op(l1) ]; m2 := [ c-a, 1-b+c, op(l2) ]; n1 := [ a, b+1, op(l1) ]; n2 := [ 1-a+c, c-b, op(l2) ]; a*(c-a)*(b-d)*(c-b-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[m1,m2,z] - b*(c-b)*(a-d)*(c-a-d)/(b-a)/(c-a-b)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/C117`:=proc(shyp,up1,up2,up3,up4,dw1,dw2,dw3,dw4) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(up4,l1); E := op(dw1,l2); F := op(dw2,l2); G := op(dw3,l2); H := op(dw4,l2); a := A; b := E; c := A+B; d := G; if `HYPERG/Egalite`(C=d+1)=false or `HYPERG/Egalite`(D=1+c-d)=false or `HYPERG/Egalite`(F=2-b+c)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C117 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,up4=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,l2); m1 := [ a+1, 1-a+c, op(l1) ]; m2 := [ b, 2-b+c, op(l2) ]; n1 := [ a, c-a, op(l1) ]; n2 := [ -1+b, 1-b+c, op(l2) ]; a*(c-a)*(b-d-1)*(1-b+c-d)/(b-a-1)/(1-a-b+c)/(c-d)/d * HYP[m1,m2,z] - (b-1)*(1-b+c)*(a-d)*(c-a-d)/(b-a-1)/(1-a-b+c)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/C119`:=proc(shyp,up1,up2,up3,dw1,dw2,dw3,dw4,dw5) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(up3,l1); D := op(dw1,l2); E := op(dw2,l2); F := op(dw3,l2); G := op(dw4,l2); H := op(dw5,l2); a := A; b := E; c := A+D-1; d := G; if `HYPERG/Egalite`(B=d+1)=false or `HYPERG/Egalite`(C=1+c-d)=false or `HYPERG/Egalite`(F=2-b+c)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C119 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,up3=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,dw5=NULL,l2); m1 := [ a+1, op(l1) ]; m2 := [ c-a, b, 2-b+c, op(l2) ]; n1 := [ a, op(l1) ]; n2 := [ 1-a+c, -1+b, 1-b+c, op(l2) ]; a*(c-a)*(b-d-1)*(1-b+c-d)/(b-a-1)/(1-a-b+c)/(c-d)/d * HYP[m1,m2,z] - (b-1)*(1-b+c)*(a-d)*(c-a-d)/(b-a-1)/(1-a-b+c)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/C121`:=proc(shyp,up1,up2,dw1,dw2,dw3,dw4,dw5,dw6) local l1,l2,z,A,B,C,D,E,F,G,H,a,b,c,d, m1,m2,n1,n2; l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); A := op(up1,l1); B := op(up2,l1); C := op(dw1,l2); D := op(dw2,l2); E := op(dw3,l2); F := op(dw4,l2); G := op(dw5,l2); H := op(dw6,l2); a := C; b := E; c := a+D-2; d := G; if `HYPERG/Egalite`(A=d+1)=false or `HYPERG/Egalite`(B=1+c-d)=false or `HYPERG/Egalite`(F=2-b+c)=false or `HYPERG/Egalite`(H=c-d)=false then ERROR(`Enable to apply C121 with parameters`,A,B,C,D,E,F,G,H); fi: l1 := subsop(up1=NULL,up2=NULL,l1); l2 := subsop(dw1=NULL,dw2=NULL,dw3=NULL,dw4=NULL,dw5=NULL,dw6=NULL,l2); m1 := l1; m2 := [ a-1, 1-a+c, b, 2-b+c, op(l2) ]; n1 := l1; n2 := [ a, 2-a+c, -1+b, 1-b+c, op(l2) ]; (a-1)*(1-a+c)*(b-d-1)*(1-b+c-d)/(b-a)/(2-a-b+c)/(c-d)/d * HYP[m1,m2,z] - (b-1)*(1-b+c)*(a-d-1)*(1-a+c-d)/(b-a)/(2-a-b+c)/(c-d)/d * HYP[n1,n2,z]; end: `HYPERG/HypContig/heart`:=proc() local shyp,sup,inf,nb,p1,p2,p3,p4,p5,p6,p7,p8,plus,res; if ( nargs < 2 ) then ERROR(`Wrong number of arguments`); fi: shyp := args[1]; nb := args[2]; if ( nb <= 0 ) then ERROR(`Wrong number of formula`); elif ( nb >=1 ) and ( nb <= 2 ) # no parameter then if ( nargs <> 2 ) then ERROR(`Wrong number of parameters`); fi: elif ( nb >= 14 ) and ( nb <= 25 ) # one parameter then if ( nargs = 3 ) then p1 := args[3]; else ERROR(`Wrong number of parameters`); fi: elif ( nb >= 26 ) and ( nb <= 52 ) # two parameters then if ( nargs = 4 ) then p1 := args[3]; p2 := args[4]; else ERROR(`Wrong number of parameters`); fi: elif ( nb >= 53 ) and ( nb <= 58 ) # three parameters then if ( nargs = 5 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; else ERROR(`Wrong number of parameters`); fi: elif ( ( nb >= 59 ) and ( nb <= 62 ) ) # four parameters or ( ( nb >= 64 ) and ( nb <= 70 ) ) or ( ( nb >= 73 ) and ( nb <= 78 ) ) or ( ( nb >= 80 ) and ( nb <= 85 ) ) or ( ( nb >= 88 ) and ( nb <= 95 ) ) or ( ( nb >= 98 ) and ( nb <= 102 ) ) then if ( nargs = 6 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; else ERROR(`Wrong number of parameters`); fi: elif ( nb = 63 ) or ( nb = 71 ) or ( nb = 72 ) # four parameters or ( nb = 79 ) or ( nb = 86 ) or ( nb = 87 ) # + additional parameter or ( nb = 96 ) or ( nb = 97 ) or ( nb = 103 ) then if ( nargs = 7 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; plus := args[7]; else ERROR(`Wrong number of parameters`); fi: elif ( ( nb >= 104 ) and ( nb <= 110 ) ) # six parameters or ( nb = 112 ) or ( nb = 114 ) or ( nb = 115 ) or ( nb = 118 ) or ( nb = 120 ) then if ( nargs = 8 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; p5 := args[7]; p6 := args[8]; else ERROR(`Wrong number of parameters`); fi: elif ( nb = 111 ) or ( nb = 113 ) or ( nb = 116 ) # height parameters or ( nb = 117 ) or ( nb = 119 ) or ( nb = 121 ) then if ( nargs = 10 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; p5 := args[7]; p6 := args[8]; p7 := args[9]; p8 := args[10]; else ERROR(`Wrong number of parameters`); fi: fi: sup := nops(op(1,shyp)); inf := nops(op(2,shyp)); if ( nb = 1 ) then res := `HYPERG/C01`(shyp); elif ( nb = 2 ) then res := `HYPERG/C02`(shyp); # Three-term relations with one parameter [up1] # elif ( nb >= 14 ) and ( nb <= 19 ) then `HYPERG/VerifPos`(p1,1,sup); res := cat(`HYPERG/C`,nb)(shyp,p1); # Three-term relations with one parameter [dw1] # elif ( nb >= 20 ) and ( nb <= 25 ) then `HYPERG/VerifPos`(p1,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1); # Three-term relations with two parameters [up1,up2] # elif ( ( nb >= 26 ) and ( nb <= 27 ) ) or ( ( nb >= 30 ) and ( nb <= 33 ) ) then if ( p1 = p2 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/Verifpos`(p2,1,sup); res := cat(`HYPERG/C`,nb)(shyp,p1,p2); # Three-term relations with two parameters [up1,dw1] # elif ( ( nb >= 34 ) and ( nb <= 36 ) ) or ( ( nb >= 40 ) and ( nb <= 44 ) ) then `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2); # Three-term relations with two parameters [dw1,dw2] # elif ( ( nb >= 45 ) and ( nb <= 46 ) ) or ( ( nb >= 49 ) and ( nb <= 52 ) ) then if ( p1 = p2 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,inf); `HYPERG/VerifPos`(p2,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2); # Three-term relations with three parameters [up1,up2,up3] # elif ( nb = 53 ) then if ( nops({p1,p2,p3}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3); # Three-term relations with three parameters [up1,up2,dw1] # elif ( nb >= 54 ) and ( nb <= 55 ) then if ( p1 = p2 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3); # Three-term relations with three parameters [up1,dw1,dw2] # elif ( nb >= 56 ) and ( nb <= 57 ) then if ( p2 = p3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3); # Three-term relations with three parameters [dw1,dw2,dw3] # elif ( nb = 58 ) then if ( nops({p1,p2,p3}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,inf); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3); # Three-term relations with four parameters [up1,up2,up3,up4] # elif ( nb >= 59 ) and ( nb <= 62 ) then if ( nops({p1,p2,p3,p4}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4); # Three-term relations with four parameters # + additionnal parameter [up1,up2,up3,up4,plus] # elif ( nb = 63 ) then if ( nops({p1,p2,p3,p4}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,plus); # Three-term relations with four parameters [up1,up2,up3,dw1] # elif ( ( nb >= 64 ) and ( nb <= 70 ) ) or ( nb = 73 ) then if ( nops({p1,p2,p3}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4); # Three-term relations with four parameters # + additionnal parameter [up1,up2,up3,dw1,plus] # elif ( nb = 71 ) or ( nb = 72 ) then if ( nops({p1,p2,p3}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,plus); # Three-term relations with four parameters [up1,up2,dw1,dw2] # elif ( ( nb >= 74 ) and ( nb <= 78 ) ) or ( ( nb >= 80 ) and ( nb <= 85 ) ) or ( nb = 88 ) then if ( p1 = p2 ) or ( p3 = p4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4); # Three-term relations with four parameters # + additionnal parameter [up1,up2,dw1,dw2,plus] # elif ( nb = 79 ) or ( nb = 86 ) or ( nb = 87 ) then if ( p1 = p2 ) or ( p3 = p4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,plus); # Three-term relations with four parameters [up1,dw1,dw2,dw3] # elif ( ( nb >= 89 ) and ( nb <= 95 ) ) or ( nb = 98 ) then if ( nops({p2,p3,p4}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4); # Three-term relations with four parameters # + additionnal parameter [up1,dw1,dw2,dw3,plus] # elif ( nb = 96 ) or ( nb = 97 ) then if ( nops({p2,p3,p4}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,plus); # Three-term relations with four parameters [dw1,dw2,dw3,dw4] # elif ( ( nb >= 99 ) and ( nb <= 102 ) ) then if ( nops({p1,p2,p3,p4}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,inf); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4); # Three-term relations with four parameters # + additionnal parameter [dw1,dw2,dw3,dw4,plus] # elif ( nb = 103 ) then if ( nops({p1,p2,p3,p4}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,inf); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,plus); # Three-term relations with six parameters [up1,up2,up3,up4,up5,dw1] # elif ( ( nb = 104 ) or ( nb = 110 ) ) then if ( nops({p1,p2,p3,p4,p5}) <> 5 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); `HYPERG/VerifPos`(p5,1,sup); `HYPERG/VerifPos`(p6,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with six parameters [up1,up2,up3,up4,dw1,dw2] # elif ( ( nb = 105 ) or ( nb = 112 ) ) then if ( nops({p1,p2,p3,p4}) <> 4 ) or ( p5 = p6 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with six parameters [up1,up2,up3,dw1,dw2,dw3] # elif ( ( nb = 106 ) or ( nb = 107 ) or ( nb = 114 ) or ( nb = 115 ) ) then if ( nops({p1,p2,p3}) <> 3 ) or ( nops({p4,p5,p6}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,inf); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with six parameters [up1,up2,dw1,dw2,dw3,dw4] # elif ( ( nb = 108 ) or ( nb = 118 ) ) then if ( p1 = p2 ) or ( nops({p3,p4,p5,p6}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with six parameters [up1,dw1,dw2,dw3,dw4,dw5] # elif ( ( nb = 109 ) or ( nb = 120 ) ) then if ( nops({p2,p3,p4,p5,p6}) <> 5 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,inf); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with height parameters [up1,up2,up3,up4,up5,up6,dw1,dw2] # elif ( nb = 111 ) then if ( nops({p1,p2,p3,p4,p5,p6}) <> 6 ) or ( p7 = p8 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); `HYPERG/VerifPos`(p5,1,sup); `HYPERG/VerifPos`(p6,1,sup); `HYPERG/VerifPos`(p7,1,inf); `HYPERG/VerifPos`(p8,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6); # Three-term relations with height parameters [up1,up2,up3,up4,up5,dw1,dw2,dw3] # elif ( nb = 113 ) then if ( nops({p1,p2,p3,p4,p5}) <> 5 ) or ( nops({p6,p7,p8}) <> 3 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); `HYPERG/VerifPos`(p5,1,sup); `HYPERG/VerifPos`(p6,1,inf); `HYPERG/VerifPos`(p7,1,inf); `HYPERG/VerifPos`(p8,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6,p7,p8); # Three-term relations with height parameters [up1,up2,up3,up4,dw1,dw2,dw3,dw4] # elif ( ( nb = 116 ) or ( nb = 117 ) ) then if ( nops({p1,p2,p3,p4}) <> 4 ) or ( nops({p5,p6,p7,p8}) <> 4 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,sup); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); `HYPERG/VerifPos`(p7,1,inf); `HYPERG/VerifPos`(p8,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6,p7,p8); # Three-term relations with height parameters [up1,up2,up3,dw1,dw2,dw3,dw4,dw5] # elif ( nb = 119 ) then if ( nops({p1,p2,p3}) <> 3 ) or ( nops({p4,p5,p6,p7,p8}) <> 5 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,sup); `HYPERG/VerifPos`(p4,1,inf); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); `HYPERG/VerifPos`(p7,1,inf); `HYPERG/VerifPos`(p8,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6,p7,p8); # Three-term relations with height parameters [up1,up2,dw1,dw2,dw3,dw4,dw5,dw6] # elif ( nb = 121 ) then if ( p1 = p2 ) or ( nops({p3,p4,p5,p6,p7,p8}) <> 6 ) then ERROR(`Wrong parameter positions`); fi: `HYPERG/VerifPos`(p1,1,sup); `HYPERG/VerifPos`(p2,1,sup); `HYPERG/VerifPos`(p3,1,inf); `HYPERG/VerifPos`(p4,1,inf); `HYPERG/VerifPos`(p5,1,inf); `HYPERG/VerifPos`(p6,1,inf); `HYPERG/VerifPos`(p7,1,inf); `HYPERG/VerifPos`(p8,1,inf); res := cat(`HYPERG/C`,nb)(shyp,p1,p2,p3,p4,p5,p6,p7,p8); else ERROR(`Contiguous formula not implemented`); fi: end: HYPERG[HypContig] := proc() local nb,shyp,p1,p2,p3,p4,p5,p6,p7,p8,ret; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; shyp := args[1]; nb := args[2]; if ( nargs = 2 ) then ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb]); elif ( nargs = 3 ) then p1 := args[3]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1]); elif ( nargs = 4 ) then p1 := args[3]; p2 := args[4]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2]); elif ( nargs = 5 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2,p3]); elif ( nargs = 6 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2,p3,p4]); elif ( nargs = 7 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; p5 := args[7]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2,p3,p4,p5]); elif ( nargs = 8 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; p5 := args[7]; p6 := args[8]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2,p3,p4,p5,p6]); elif ( nargs = 10 ) then p1 := args[3]; p2 := args[4]; p3 := args[5]; p4 := args[6]; p5 := args[7]; p6 := args[8]; p7 := args[9]; p8 := args[10]; ret := `HYPERG/Mapping`(shyp,false,{`HYP`},`HYPERG/HypContig/heart`,[nb,p1,p2,p3,p4,p5,p6,p7,8]); fi: ret; end: HYPERG[HypContigPrint] := proc() args[1] = HYPERG[HypContig](args); end: ########## # File @(#) HypConverg (HYPERG PACKAGE) Mon Feb 15 08:12:11 MET 1999 ########## # # HYPERG[HypConverg] # `HYPERG/GreaterThan` # # BG150298 `HYPERG/GreaterThan` := proc(mysum,val) if type(mysum,numeric) then if ( mysum <= val ) then RETURN(false); fi: else `HYPERG/Print`(mysum,` must be greater than `,val); fi: true; end: HYPERG[HypConverg] := proc() local shyp,l1,l2,n1,n2,z,s; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 1 ) then ERROR(`Expecting only one argument`); fi: shyp := args[1]; if ( IsVHYP(shyp) ) then shyp := VHypToHyp(shyp); fi: if ( not IsHYP(shyp) ) then ERROR(`Expecting a hypergeometric series:`,shyp): fi: l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); n1 := nops(l1); n2 := nops(l2); s := convert(l2,`+`)-convert(l1,`+`); if ( n1 <= n2 ) then RETURN(true); elif ( n1 = n2+1 ) then if type(z,numeric) then if ( abs(z) < 1 ) then RETURN(true); else if ( z = 1 ) then if ( `HYPERG/GreaterThan`(s,0) ) then RETURN(true); else RETURN(false); fi: elif ( z = -1 ) then if ( `HYPERG/GreaterThan`(s,-1) ) then RETURN(true); else RETURN(false); fi: else # |z| > 1 RETURN(false); fi: fi: else `HYPERG/Print`(abs(z),` must be less than `,1); if type(s,numeric) then if (s>0) then `HYPERG/Print`(`or `,z,` must be egal to `,1); fi: if (s>-1) then `HYPERG/Print`(`or `,z,` must be egal to `,-1); fi: else `HYPERG/Print`(`or `,z,` must be egal to `,1,` and `,s>0); `HYPERG/Print`(`or `,z,` must be egal to `,-1,` and `,s>-1); fi: RETURN(true); fi: else # n1 > n2+1 if type(z,numeric) then if ( z = 0 ) then RETURN(true); else RETURN(false); fi: else `HYPERG/Print`(z,` must be egal to `,0); RETURN(true); fi: fi: end: ########## # File @(#) HypDiff (HYPERG PACKAGE) Fri Feb 13 08:03:19 MET 1998 ########## # # HYPERG[HypDiff] # # BG130298 BG230998 BG160399 BG140499 HYPERG[HypDiff] := proc() local shyp,var,co,l1,l2,z,i,prod; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: shyp := args[1]; var := args[2]; if ( IsVHYP(shyp) ) then shyp := VHypToHyp(shyp); fi: if ( not IsHYP(shyp) ) then ERROR(`Expecting a hypergeometric series:`,shyp): fi: l1 := op(1,shyp); l2 := op(2,shyp); z := op(3,shyp); co := diff(z,var); if ( not(has(z,var)) or has(l1,var) or has(l2,var) ) then ERROR(`Can't compute this derivation`): fi: prod := convert(l1,`*`) / convert(l2,`*`); l1 := [ seq(op(i,l1)+1 , i=1..nops(l1))]; l2 := [ seq(op(i,l2)+1 , i=1..nops(l2))]; co*prod*HYP[l1,l2,z]; end: ########## # File @(#) HypOrder (HYPERG PACKAGE) Tue Sep 16 08:18:56 METDST 1997 ########## # # HYPERG[HypOrder] # `HYPERG/HypOrder/Elementary` # # BG160997 `HYPERG/HypOrder/Elementary` := proc(li1,li2,li3,li4,x,y) local l1,l2,l3,l4,i,j; l1 := li1; l2 := li2; l3 := li3; l4 := li4; if ( member(x,l1,'i') and member(y,l2,'j') ) then l1 := subsop(i=NULL,l1); l3 := [ op(l3), x ]; l2 := subsop(j=NULL,l2); l4 := [ op(l4), y ]; fi: [l1,l2,l3,l4]; end: HYPERG[HypOrder] := proc(arg) local l1,l2,z,l1plus1,DeuxADeux,intsec,intsecmult, newl1,newl2,oldl1,oldl2, i,j,var1,var2,maxi,maxel,posx,retour; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( not IsHYP(arg) ) then RETURN(arg): fi: l1 := op(1,arg); l2 := op(2,arg); z := op(3,arg); if ( nops(l1) <> nops(l2)+1 ) then RETURN(arg); fi; l1plus1:= [ seq( op(i,l1)+1,i=1..nops(l1) ) ]; DeuxADeux := NULL; for i from 1 to nops(l1) do for j from 1 to nops(l2) do DeuxADeux := DeuxADeux, op(i,l1)+op(j,l2): od: od: DeuxADeux := [DeuxADeux]; # intersection entre l1plus1 et DeuxADeux intsec := `HYPERG/ListeInter`(DeuxADeux,l1plus1); if ( intsec = [] ) then RETURN (arg); fi: # idem (avec multiplicite des elements) intsecmult := []; for i from 1 to nops(intsec) do var1 := op(i,intsec); var2 := 0; for j from 1 to nops(DeuxADeux) do if ( op(j,DeuxADeux) = var1 ) then var2 := var2+1; fi: od: intsecmult := [ op(intsecmult), [var1,var2] ]; od: # recherche de l'element de intsecmult qui possede une multiplicite maxi maxi := 0; for i from 1 to nops(intsecmult) do if ( op(2,op(i,intsecmult)) > maxi ) then maxi := op(2,op(i,intsecmult)); maxel := op(1,op(i,intsecmult)); fi: od: # on essaye d'ordonner les parametres t.q. "well" poised # construction des futurs listes de parametres newl1 := [maxel-1]; newl2 := []; # destruction des anciennes listes de parametres member(maxel-1,l1,'posx'); oldl1 := subsop(posx=NULL,l1); oldl2 := l2; # on essaye d'ordonner les parametres t.q. "very"-well poised retour := `HYPERG/HypOrder/Elementary`(oldl1,oldl2,newl1,newl2, expand((maxel+1)/2),expand((maxel-1)/2)); oldl1 := op(1,retour); oldl2 := op(2,retour); newl1 := op(3,retour); newl2 := op(4,retour); DeuxADeux := oldl1; for i from 1 to nops(DeuxADeux) do retour := `HYPERG/HypOrder/Elementary`(oldl1,oldl2,newl1,newl2, op(i,DeuxADeux),maxel-op(i,DeuxADeux)); oldl1 := op(1,retour); oldl2 := op(2,retour); newl1 := op(3,retour); newl2 := op(4,retour); od: # s'il reste des elements dans oldl[1|2], la serie n'est pas well-poised, # on ajoute les elements restants newl1 := [ op(newl1), op(oldl1) ]; newl2 := [ op(newl2), op(oldl2) ]; HYP[newl1,newl2,z]; end: ########## # File @(#) HypSimplify (HYPERG PACKAGE) Mon Mar 10 18:27:42 MET 1997 ########## # # HYPERG[HypSimplify] # `HYPERG/HypSimplify/heart` # `HYPERG/HypSimplify/heart/WithFactor` # `HYPERG/HypSimplify/heart/WithCombPow` # `HYPERG/ListeInter` # `HYPERG/Complement` # # BG100397 BG021097 BG090698 BG240998 BG170399 BG200499 `HYPERG/ListeInter` := proc(li1,li2) local i,res,k,l1,l2;; l1 := li1; l2 := li2; res := NULL; i:=1; while ( i <= nops(l1) and l2 <> [] ) do if ( member(op(i,l1),l2,'k') ) then res := res,op(i,l1); l2 := subsop(k=NULL,l2); fi: i := i+1; od: [res]; end: `HYPERG/Complement` := proc(li,e) local i,res,k; res := li; i:=1; while member(e,res,'k') do res := subsop(k=NULL,res); od: res; end: `HYPERG/HypSimplify/heart` := proc(shyp) local l1,l2, intersec,supp,k,var,i; l1 := map(expand,op(1,shyp)); l2 := map(expand,op(2,shyp)); #l1 := op(1,shyp); #l2 := op(2,shyp); intersec := `HYPERG/ListeInter`(l1,l2); while ( intersec <> [] ) do supp := op(1,intersec); member(supp,l1,'k'); l1 := subsop(k=NULL,l1); member(supp,l2,'k'); l2 := subsop(k=NULL,l2); intersec := subsop(1=NULL,intersec); od: #l1 := map(factor,l1); #l2 := map(factor,l2); if ( op(0,shyp) = HYP ) then RETURN( HYP[ l1,l2,normal(op(3,shyp)) ] ); fi: if ( op(0,shyp) = QHYP ) then RETURN( QHYP[ l1,l2,op(3,shyp),normal(op(4,shyp)) ] ); fi: end: `HYPERG/HypSimplify/heart/WithFactor` := proc(shyp) local ret; ret:=`HYPERG/HypSimplify/heart`(shyp); if ( op(0,ret) = HYP ) then RETURN( HYP[ op(1..2,ret),factor(op(3,ret)) ] ); fi: if ( op(0,ret) = QHYP ) then RETURN( QHYP[ op(1..3,ret),factor(op(4,ret)) ] ); fi: end: `HYPERG/HypSimplify/heart/WithCombPow` := proc(shyp) local ret; ret:=`HYPERG/HypSimplify/heart`(shyp); if ( op(0,ret) = HYP ) then RETURN( HYP[ op(1..2,ret),combine(op(3,ret),power) ] ); fi: if ( op(0,ret) = QHYP ) then RETURN( QHYP[ op(1..3,ret),combine(op(4,ret),power) ] ); fi: end: HYPERG[HypSimplify] := proc() option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs=1 ) then `HYPERG/Mapping`(args[1],false,{`HYP`,`QHYP`}, `HYPERG/HypSimplify/heart`,[]); elif ( nargs=2 ) then if (args[2]='factor') then `HYPERG/Mapping`(args[1],false,{`HYP`,`QHYP`}, `HYPERG/HypSimplify/heart/WithFactor`,[]); elif (args[2]='combpow') then `HYPERG/Mapping`(args[1],false,{`HYP`,`QHYP`}, `HYPERG/HypSimplify/heart/WithCombPow`,[]); else ERROR(`Invalid option`,args[2]); fi: else ERROR(`Wrong number of arguments`); fi: end: ########## # File @(#) HypSolRec (HYPERG PACKAGE) Thu May 22 08:30:52 METDST 1997 ########## # # HYPERG[HypSolRec] # `HYPERG/MonicFactor` # # BG220597 BG300399 `HYPERG/MonicFactor` := proc(expr,nn) # INPUT : <-- expr : expression # <-- nn : variable de "expr" # OUTPUT : --> res : liste contenant les facteurs moniques de "expr" local exprf, # expression initiale factorisee liste, # liste contenant initiallement les differents facteurs # de "exprf", res, # liste construite pendant le deroulement de la fonction, # contenant finalement tous les facteurs moniques de "exprf" ret, # idem, mais avec toutes les combinaisons possibles # de produit entre chaque facteur monique tmp, # facteur de "exprf" (tmp = exprf^p) t, # terme de "exprf" p, # puissance de "tmp" c, # coefficient de tete d'un facteur i,j; # variables de boucle `HYPERG/IsPoly`(expr,nn); #exprf := factor(expr); exprf := factor(expr,{solve(expr,nn)}); res := []; if ( type(exprf,`*`) ) then liste := [op(exprf)]; else liste := [exprf]; fi: for i from 1 to nops(liste) do tmp := op(i,liste); if ( indets(tmp) intersect {nn} <> {} ) then if ( type(tmp,`^`) ) then t := op(1,tmp); p := op(2,tmp); else t := tmp; p := 1; fi: c := coeff(t,nn,degree(t,nn)); for j from 1 to p do res := [(t/c)^j, op(res)]; od: fi: od: #MAPLEVR2+ #MAPLEVR2+ res := combinat[choose](res); #MAPLEVR2+ ret := []; for i from 1 to nops(res) do ret := [op(ret),convert(op(i,res),`*`)]; od: ret; end: HYPERG[HypSolRec] := proc(eq,suite) # Petkovsek's HYPER algorithm # INPUT : <-- eq : equation de recurrence a coefficients polynomiaux # <-- suite : suite verifiant la recurrence [U(n)] # OUTPUT : --> solution rationnelle de "eq" local neq, # equation de recurrence solutions, new, nh, # terme de l'eq. de recurrence ne faisant pas # intervenir de U(n+i) [=0 si l'eq. est homogene] nn, # variable de l'equation de recurrence ordre, # ordre de la recurrence CO, # tableau CO[i]... coefficients de U(n+i) l1,l2, # facteurs moniques de a0 et de ak(n-k+1) mini,maxi, # variables utilisees pour determiner "ordre" li, # liste des indets de l'eq [n,U(n),...,U(n+i),...] i,j,k,x,y,z, # variables de boucle indice, A,B, # facteurs moniques respect. de CO[0](nn) et CO[k](nn-k+1) M, # tableau M[i]... ALPHA, # tableau ALPHA[i]... pp, # degre max. des Mi(nn) eqz,zz, sol,zsol, eqc,C,solC, vari; option `Copyright by Bruno Gauthier, IGM, Universite Marne-la-Vallee, France`; if ( nargs <> 2 ) then ERROR(`Expecting two arguments`); fi: if ( not type(suite,function) ) then ERROR(suite,`is not a sequence`); fi: solutions := {}; if type(eq,`=`) then neq := HYPERG[RfEval](op(1,eq)-op(2,eq)); else neq := eq; fi: mini := infinity; maxi := -infinity; nn := op(1,suite); li := [op(indets(neq))]; for i from 1 to nops(li) do vari := op(i,li); if `HYPERG/IsSeq`(vari,suite) then mini := `HYPERG/Mymin`(mini,op(1,vari)-nn); maxi := `HYPERG/Mymax`(maxi,op(1,vari)-nn); fi: od: # "decalage" de la recurrence en 0 ordre:=maxi-mini; neq := subs(nn=nn-mini,neq); li := [op(indets(neq))]; #mise a jour nh := neq; CO := array[0..ordre]; for i from 0 to ordre do CO[i] := 0; od; for i from 1 to nops(li) do vari := op(i,li); if `HYPERG/IsSeq`(vari,suite) then indice := op(1,vari)-nn; CO[indice] := CO[indice] + coeff(neq,vari); nh := nh - coeff(neq,vari)*vari; fi: od: nh := simplify(nh); if ( nh <> 0 ) then ERROR(`Not homogeneous recurrence equation`); fi: l1:=`HYPERG/MonicFactor`(CO[0],nn); l2:=`HYPERG/MonicFactor`(subs(nn=nn-ordre+1,CO[ordre]),nn); M := array[0..ordre]; ALPHA := array[0..ordre]; # pour tous les couples (A,B) de facteurs moniques de CO[0] et CO[k](n-k+1) # faire for x from 1 to nops(l1) do for y from 1 to nops(l2) do A := op(x,l1); B := op(y,l2); `HYPERG/Verbose/Print`(1,`\n Searching hypergeometric solutions with %a and %a\n`,A,B); # on determine les valeurs de M[i] i=0..ordre for i from 0 to ordre do M[i] := expand( CO[i] * product(subs(nn=nn+z,A),z=0..i-1) * product(subs(nn=nn+z,B),z=i..ordre-1) ); od: # on determine pp pp := -1; for i from 0 to ordre do pp := max ( degree(M[i],nn),pp ); od: # on determine les valeurs de ALPHA[i] i=0..ordre for i from 0 to ordre do ALPHA[i] := coeff(M[i],nn,pp); od: # construction de l'eq. \sum_i ALPHA[i] z^i = 0 eqz := 0; for i from 0 to ordre do eqz := eqz + ALPHA[i] * zz^i; od: sol := [op({solve(eqz,zz)})]; for j from 1 to nops(sol) do zsol := op(j,sol); eqc := M[0]*C(nn); for i from 1 to ordre do eqc := eqc + zsol^i*M[i]*C(nn+i); od: solC := traperror(HYPERG[PolySolRec](eqc=0,C(nn)) ); if ( solC <> lasterror ) and ( solC <> 0 ) then new := zsol*A/B*subs(nn=nn+1,solC)/solC; solutions := solutions union {new}; fi: od: od: od: solutions; end: ########## # File @(#) HypSum (HYPERG PACKAGE) Thu Aug 21 08:51:17 METDST 1997 ########## # # HYPERG[HypSum] # HYPERG[HypSumPrint] # `HYPERG/EvalPointEgalTo` # `HYPERG/MustBeNeg` # `HYPERG/Egalite` # `HYPERG/Inegalite` # `HYPERG/Summation1001`, `HYPERG/Summation2101`, `HYPERG/Summation2103`, # `HYPERG/Summation2104`, `HYPERG/Summation2105`, `HYPERG/Summation2106`, # `HYPERG/Summation2131`, `HYPERG/Summation2132`, # `HYPERG/HypSum/heart` # # BG220697 BG180897 BG170498 BG080698 BG021098 `HYPERG/EvalPointEgalTo` := proc(evalpt,val) if type(evalpt,numeric) then if ( evalpt <> val ) then RETURN(false); fi: else `HYPERG/Print`(evalpt,` must be equal to `,val); fi: true; end: `HYPERG/MustBeNeg` := proc(param) if type(param,numeric) then if ( param > 0 ) or ( not type(param,integer) ) then RETURN(false); fi: else `HYPERG/Print`(param,` must be an integer <= 0`); fi: true; end: `HYPERG/Egalite` := proc(eg) local g,d; g := simplify(op(1,eg)); d := simplify(op(2,eg)); if type(g,numeric) and type(d,numeric) then if ( g <> d ) then RETURN(false); fi: else if not evalb( g=d ) then `HYPERG/Print`(g,` must be equal to `,d); fi: fi: true; end: `HYPERG/Inegalite` := proc(eg) local g,d; g := simplify(op(1,eg)); d := simplify(op(2,eg)); if type(g,numeric) and type(d,numeric) then if ( g > d ) then RETURN(false); fi: else `HYPERG/Print`(g,` must be < to `,d); fi: true; end: `HYPERG/Summation1001`:=proc(shyp) #Theoreme Binomial local l1,z,a; l1 := op(1,shyp); a := op(1,l1); z := op(3,shyp); (1-z)^(-a); end: `HYPERG/Summation2101`:=proc(shyp) #Vandermonde's theorem local l1,l2,z,a,b,c; l1 := op(1,shyp); l2 := op(2,shyp); a := op(1,l1); b := op(2,l1);