FUNCTION :  mintotORDS - lower bound for sum of ORDS


CALLING SEQUENCE :  mintotORDS()                                            
                    mintotORDS(L,num)                                            

PARAMETERS :      L  - list (or array) [[ORDS(f1), ORDS(f2), ...].        
                  num  - nops(L) (list) or dim(L) (array)          

GLOBAL VARIABLES : xprint (default=false)

SYNOPSIS :   This proc calculates a lower bound for sum ORD g where    
             g = (1 + c1 f1 + c2 f2 + ...)                             
             Here sum is over cusps not equivalent to oo.              
            (Usually) each ORDS(f) was produced by getaprodcuspORDS   
             and the first cusp in the list is oo.                   
             This function is used by the functions provemodfuncid
             and provemodfuncidBATCH.

             If xprint is true then extra info is printed.
EXAMPLES :   
> with(thetaids):

> mintotORDS();
-------------------------------------------------------------
mintotORDS(L,num)                                            
   L is a list (or array) [[ORDS(f1), ORDS(f2), ...].        
   num = nops(L) (list) or dim(L) (array)                    
   This proc calculates a lower bound for sum ORD g where    
   g = (1 + c1 f1 + c2 f2 + ...)                             
   Here sum is over cusps not equivalent to oo.              
   (Usually) each ORDS(f) was produced by getaprodcuspORDS   
   and the first cusp in the list is oo.                     
-------------------------------------------------------------

> JACID:=
> -JAC(5, 25, infinity)^2*JAC(1, 25, infinity)*JAC(2, 25, infinity)
> *JAC(3, 25, infinity)*JAC(4, 25, infinity)*JAC(6, 25, infinity)
> *JAC(7, 25, infinity)*JAC(8, 25, infinity)*JAC(9, 25, infinity)
> *JAC(11, 25, infinity)*JAC(12, 25, infinity)/JAC(0, 25, infinity)^12
> +1
> -JAC(5, 25, infinity)*q/JAC(10, 25, infinity)
> -JAC(5, 25, infinity)^2*q^2/JAC(10, 25, infinity)^2;
                               2
JACID := - JAC(5, 25, infinity)  JAC(1, 25, infinity) JAC(2, 25, infinity)

    JAC(3, 25, infinity) JAC(4, 25, infinity) JAC(6, 25, infinity)

    JAC(7, 25, infinity) JAC(8, 25, infinity) JAC(9, 25, infinity)

                                                  /                     12
    JAC(11, 25, infinity) JAC(12, 25, infinity)  /  JAC(0, 25, infinity)   + 1
                                                /

                                                    2  2
       JAC(5, 25, infinity) q   JAC(5, 25, infinity)  q
     - ---------------------- - ------------------------
       JAC(10, 25, infinity)                          2
                                 JAC(10, 25, infinity)

> 
> JACLIST:= map(rmcofnotqjac,[op(JACID)]);
                                2
JACLIST := [JAC(5, 25, infinity)  JAC(1, 25, infinity) JAC(2, 25, infinity)

    JAC(3, 25, infinity) JAC(4, 25, infinity) JAC(6, 25, infinity)

    JAC(7, 25, infinity) JAC(8, 25, infinity) JAC(9, 25, infinity)

                                                  /                     12
    JAC(11, 25, infinity) JAC(12, 25, infinity)  /  JAC(0, 25, infinity)  , 1,
                                                /

                                                2  2
    JAC(5, 25, infinity) q  JAC(5, 25, infinity)  q
    ----------------------, ------------------------]
    JAC(10, 25, infinity)                         2
                             JAC(10, 25, infinity)

> GPLIST:=map(jac2eprod,JACLIST);         
                      2
GPLIST := [GETA(25, 5)  GETA(25, 1) GETA(25, 2) GETA(25, 3) GETA(25, 4)

    GETA(25, 6) GETA(25, 7) GETA(25, 8) GETA(25, 9) GETA(25, 11) GETA(25, 12),

                                2
       GETA(25, 5)   GETA(25, 5)
    1, ------------, -------------]
       GETA(25, 10)              2
                     GETA(25, 10)

> CW25:=CUSPSANDWIDMAKE1(25):
> _ORDS:=[]:
> for j from 1 to nops(GPLIST) do
>    GP:=GPLIST[j]:
>    if GP<>1 then
>        gltmp:=GETAP2getalist(GP):
>        ordtmp:=getaprodcuspORDS(gltmp,CW25[1],CW25[2]):
>    else
>        ordtmp:=[seq(0,k=1..nops(CW25[1]))]:
>    fi:
>    _ORDS:=[op(_ORDS),ordtmp]:
> od:
> _ORDS;
[[0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, -2, 0, 0, -2, 0, 0, 0, 0, -2, -2, 0,

    0, 0, -2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0,

    -1, 0, 1, 1, 0, -1, -1, 0, 1, 1, -1], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, -2, 0, 0, -2, 0, 2, 2, 0, -2, -2, 0, 2, 2, -2]]

> mintotORDS(_ORDS,4);
                                      -10

DISCUSSION :

sum ORD(JACID, cusp, GAMMA1(25) >= -10

where sum is over cusps<>ioo.  This means to confirm JACID==0 need to
only check that the coeffs of q^0, q^1, ..., q^10 are zero.

SEE ALSO :  provemodfuncid, provemodfuncidBATCH