QEtaModularPackage QMOD

qetamodpkg.spad line 124 [edit on github]

undocumented

etaCofactorInfinity: (PositiveInteger, List List Integer, List QEtaSpecification) -> QEtaSpecification

etaCofactorInfinity(nn,idxs,rspecs) returns a specification sspec such that sspec has only indices from idxs and for every rspec from rspecs modular?(sspec,rspec,1,0)$QMOD is true and etaQuotient(sspec,rspec,1,0)$SymbolicModularEtaQuotient(QMOD) corresponds to a modular function with poles only at infinity and with smallest pole order. It is an error if all rspecs cannot be made modular by a common cofactor, i.e. we require that for every rspec in rspecs the specification (rspec/rspecs.1) specifies a modular eta-quotient.

etaCofactorInfinity: (PositiveInteger, List List Integer, QEtaSpecification, PositiveInteger, NonNegativeInteger) -> QEtaSpecification

etaCofactorInfinity(nn,idxs,rspec,m,t) returns a specification sspec such that sspec has only indices from idxs, modular?(sspec,rspec,m,t)$QMOD and etaQuotient(sspec,rspec,m,t)$SymbolicModularEtaQuotient(QMOD) corresponds to a modular function with poles only at infinity and with smallest pole order. It returns etaCofactorNoPoles(nn,idxs,rspec,m,t,nopolesat) for nopolesat:=remove(ininity$Cusp,cusps(nn)$QMOD).

etaCofactorNoPoles: (PositiveInteger, List List Integer, QEtaSpecification, PositiveInteger, NonNegativeInteger, List Cusp) -> QEtaSpecification

etaCofactorNoPoles(nn,idxs,rspec,m,t,nopolesat) returns a specification sspec such that sspec has only indices from idxs, modular?(sspec,rspec,m,t)$QMOD and etaQuotient(sspec,rspec,m,t)$SymbolicModularEtaQuotient(QMOD) corresponds to a modular function with no poles at the cusps nopolesat and with minimal length order vector at these cusps.

etaCofactorNoPolesSystem: (Record(level: PositiveInteger, indices: List List Integer, particular: Union(Vector Integer, failed), basis: List Vector Integer), List Integer, List Cusp) -> Record(zmat: Matrix Integer, zrels: Vector Integer, zrhs: Vector Integer, zsgn: List Integer)

etaCofactorNoPolesSystem(bspecs,ords,nopolesat) is used as a second step to etaCofactorSpace for the computation of a cofactor that has no poles at the cusps nopolesat, for example in etaCofactorInfinity or etaCofactorNoPoles. The input bspecs (usually) represents the group generators for the group of all eta-quotients that are modular functions wrt. QMOD (and poles only at the cusps), i.e. they come from ecs:=etaCofactorSpace(nn,idxs,rspec,m,t); bspecs:=[etaQuotientSpecification(nn,idxs,x) for x in ecs.basis] (see implementation of etaCofactorInfinity). It returns an r times c matrix A and a right-hand side v for a system A*x>=v where r=#ords=#nopolesat, c=#bspecs and the right-hand side is v=-ords (which is the expansion orders at the cusps nopolesat of (sspec,rspec,m,t) where sspec comes from the particular solution of ecs) and A is the expansion orders of the basis elements given by bspecs (one order column for each element of bspec). The rows are indexed by the cusps nopolesat, which also means that ords corresponds to order at nopolesat for each entry respectively. A solution to this system should give rise to an sspec such that (sspec,rspec,m,t) specifies a modular function with no poles at the cusps nopolesat.

etaCofactorSpace: (PositiveInteger, List List Integer, QEtaSpecification, PositiveInteger, NonNegativeInteger) -> Record(level: PositiveInteger, indices: List List Integer, particular: Union(Vector Integer, failed), basis: List Vector Integer)

etaCofactorSpace(nn,idxs,rspec,m,t) returns etaCofactorSpace(nn,idxs,rspec,m,t,cusps(nn)$QMOD).

etaCofactorSpace: (PositiveInteger, List List Integer, QEtaSpecification, PositiveInteger, NonNegativeInteger, List Cusp) -> Record(level: PositiveInteger, indices: List List Integer, particular: Union(Vector Integer, failed), basis: List Vector Integer)

etaCofactorSpace(nn,idxs,rspec,m,t,spitzen) computes ecs:=etaCofactorSpace(nn,idxs,rspec,m,t)$QMOD and then applies minimizeOrderVectors to ecs.basis and minimizeVector to ecs.particular (with the just computed minimized basis) and returns the result as an ECS (eta cofactor space) structure. minimizeOrderVectors is applied to ecs.basis even if ecs.particular is “failed”. For the special case that spitzen=cusps(``nn`)$QMOD`, only those integer-linear combination of ecs.basis elements are returned that give rise to sspec such that (sspec,``rspec`,m,t)` is a constant modular function. This list might be empty.

minimizeOrderVectors: (PositiveInteger, List List Integer, List Vector Integer, List Cusp) -> List Vector Integer

mbasis:=minimizeOrderVectors(nn,idxs,hbasis,spitzen) returns a ZZ-linear combinations of the basis given by hbasis such that (1) mbasis generates the same ZZ-module as hbasis, (2) the order vectors of mbasis are not longer than the order vectors of hbasis and possibly as small as (cheaply) computable. Here an “order vector of e” is meant to be the orders at the cusps given by spitzen of the) eta-quotient given by etaQuotient(nn,idx,e) (without considering the (c*tau+d) factor). Minimality of the lengths is not required. Note that an input condition is that the elements of hbasis must represent modular eta-quotients with poles only at the cusps.

qetaGrades: (QEtaSpecification, QEtaSpecification, PositiveInteger, NonNegativeInteger) -> List Integer

qetaGrades(sspec,rspec,m,t) returns qetaGrades(y) where y=etaQuotient(sspec,rspec,m,t)$SymbolicModularEtaQuotient(QMOD).

qetaGrades: (QEtaSpecification, QEtaSpecification, PositiveInteger, NonNegativeInteger, List Cusp) -> List Integer

qetaGrades(sspec,rspec,m,t,spitzen) returns qetaGrades(y) where y=etaQuotient(sspec,rspec,m,t,spitzen) from SymbolicModularEtaQuotient(QMOD).

qetaGrades: SymbolicModularEtaQuotient QMOD -> List Integer

qetaGrades(y) returns the poleorders of the modular function corresponding to y. In the special case when e is the expansion and qetaGrade(e.c) is less than 0 for every cusp c in transformationMatrices(y), the function returns a value of -1 for each cusp although this might not be the true poleorder of the expansion, it rather is the value for the case that y represents zero. This special treatment avoids running into an infinite loop if y represents the zero function. If the dissection is done with multiplier 1, then this function computes the grades without an explicit series expansion.

reduceSystem: Record(zmat: Matrix Integer, zrels: Vector Integer, zrhs: Vector Integer, zsgn: List Integer) -> Record(zmat: Matrix Integer, zrels: Vector Integer, zrhs: Vector Integer, zsgn: List Integer)

reduceSystem([A,v]) returns a matrix B and a right-hand side w such that A*x >= v and B*x >= w have the same solutions, but B has duplicate rows removed. The order of distinct rows is kept.