FUNCTION :  ETA[provemodfuncGAMMA0UpETAidBATCH] -  proving U[p] eta-combo identity

CALLING SEQUENCE :  provemodfuncGAMMA0UpETAidBATCH()
                    provemodfuncGAMMA0UpETAidBATCH(EP,p,etacombo,N)

PARAMETERS :    
      EP - one eta-product                                   
       p - prime                                             
etacombo - sum of modular functions on Gamma[0](N)           
           Each term in the sum is a eta-quotient to base N. 
       N - Positive integer multiple of p                    
                                                             
                  -            

GLOBAL VARIABLES : 
    qcheck,modfunccheck, totcheck, _ORDS,jptmp,jpqd,eptmp,gltmp
    etaPRODL,GPL,COFS,conpres,CONTERMS,mintottmp,consL,MFLB
    xprint,_CUSPS,UpORDL,_ORDS2,noprint

SYNOPSIS :   
      This a BATCH version of provemodfuncGAMMA0UpETAid            
      This function PROVES the id U[p](EP) = etacombo           

EXAMPLES :   

> with(qseries):
> with(ETA):
> provemodfuncGAMMA0UpETAidBATCH();
-------------------------------------------------------------
provemodfuncGAMMA0UpETAidBATCH(EP,p,etacombo,N)              
This a BATCH version of provemodfuncGAMMA0UpETAid            
      EP = one eta-product                                   
       p = prime                                             
etacombo = sum of modular functions on Gamma[0](N)           
           Each term in the sum is a eta-quotient to base N. 
       N = Positive integer multiple of p                    
                                                             
   This function PROVES the id U[p](EP) = etacombo           
   global vars (can be used for error-checking):             
   qcheck, modfunccheck, totcheck, _ORDS, jptmp, jpqd, eptmp,
   gltmp, EPRODL, GETAL, COFS, conpres, CONTERMS, mintottmp  
                                                             
-------------------------------------------------------------
> gpg:=[100, -3, 50, 5, 25, -2, 10, -8, 5, 4, 4, 3, 2, 3, 1, -2]:
> epg:=gp2etaprod(gpg);
                              5           4           3           3
                   eta(50 tau)  eta(5 tau)  eta(4 tau)  eta(2 tau)
            epg := -------------------------------------------------
                               3            2            8         2
                   eta(100 tau)  eta(25 tau)  eta(10 tau)  eta(tau)

> gpf1:=[10, 8, 5, -4, 2, -8, 1, 4]:
> epf1:=gp2etaprod(gpf1);
                                           8         4
                                eta(10 tau)  eta(tau)
                        epf1 := -----------------------
                                          4           8
                                eta(5 tau)  eta(2 tau)

> gpf2:=[20, -3, 10, 5, 5, -2, 4, -1, 2, -1, 1, 2]:
> epf2:=gp2etaprod(gpf2);
                                            5         2
                                 eta(10 tau)  eta(tau)
             epf2 := ----------------------------------------------
                                3           2
                     eta(20 tau)  eta(5 tau)  eta(4 tau) eta(2 tau)

> etacombo:=5*epf1 + 2*epf2:
> noprint:=false:
> provemodfuncGAMMA0UpETAidBATCH(epg,5,etacombo,20);
*** There were NO errors. 
*** o EP is an MF on Gamma[0](100)
*** o Each term in the etacombo is a  modular function on
      Gamma0(20). 
*** o We also checked that the total order of
      each term etacombo was zero.
*** To prove the identity U[5](EP)=etacombo we need to show
    that v[oo](ID) > 3    This means checking up to q^(4).
memory used=4.2MB, alloc=40.3MB, time=0.09
We find that LHS - RHS is 
                                        43
                                     O(q  )

                                           43
                                [1, -3, O(q  )]

> noprint:=true:
> provemodfuncGAMMA0UpETAidBATCH(epg,5,etacombo,20);
                                           43
                                [1, -3, O(q  )]


DISCUSSION :

SEE ALSO :