QEtaSpecification

qetaspec.spad line 112 [edit on github]

QEtaSpecification helps translate various formats of user data into a common format that specifies a (generalized) eta-quotient.

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

/: (%, %) -> %

from Group

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> %

from Group

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

allGeneralizedEtaFunctionIndices: PositiveInteger -> List List Integer

allGeneralizedEtaFunctionIndices(nn) returns all indices that can be used. In fact it is the union of etaFunctionIndices(nn) and properGeneralizedEtaFunctionIndices(d) where d runs over all divisors of nn.

allPureExponents: % -> List Integer

allPureExponents(x) returns the exponents of the pure eta-quotient part of the specification. The resulting list has as many entries as divisors(x).

alphaInfinity: (%, %, PositiveInteger, List NonNegativeInteger) -> Integer

alphaInfinity(sspec,rspec,m,orb) implements the definition eqref{eq:alphaInfinity}, i.e. the definition of Radu in cite{Radu_RamanujanKolberg_2015}, DOI=10.1016/j.jsc.2017.02.001, http://www.risc.jku.at/publications/download/risc_5338/DancingSambaRamanujan.pdf and can also be extracted from from formula (10.4) of cite{ChenDuZhao_FindingModularFunctionsRamanujan_2019} when the respective cofactor part is taken into account. Note that it does not agree with alpha(t) as defined in cite{ChenDuZhao_FindingModularFunctionsRamanujan_2019}.

coerce: % -> OutputForm

from CoercibleTo OutputForm

commutator: (%, %) -> %

from Group

conjugate: (%, %) -> %

from Group

denom: % -> %

denom(x) returns the part of the specification that corresponds to negative exponents. It holds: x=numer(x)/denom(x).

dilate: (%, PositiveInteger) -> %

dilate(x,n) is the respective operation of replacing q by q^n. At the same time the level of the specification in multiplied by n.

etaFunctionIndices: PositiveInteger -> List List Integer

etaFunctionIndices(nn) returns the divisors of n as indices in the form [[d] for d in divisors nn].

etaQuotientSpecification: (List PositiveInteger, List Integer) -> %

etaQuotientSpecification(divs, r) returns the specification for the eta-quotient $prod_{d} eta(d*tau)^{r_d}$ where d runs over divs. The two input lists are supposed to be of the same length.

etaQuotientSpecification: (PositiveInteger, List Integer) -> %

etaQuotientSpecification(mm, r) returns the specification for the eta-quotient $prod_{d} eta(d*tau)^{r_d}$ where d runs over all divisors of mm.

etaQuotientSpecification: (PositiveInteger, List List Integer) -> %

etaQuotientSpecification(mm, rbar) returns the specification of a generalized eta-quotient given by a list of (index, exponent) pairs where an index can be either a divisor of mm or a pair (d,g) of a divisor d and a number g (0<g<d/2). In more detail an element l of rbar can have the following form: a) [d[ -- this is equivalent to [d,1], b) [d,e] -- stands for $eta(d*tau)^e$, c) [d,g,e] -- stands for $eta_{d,g}^{[R]}(tau)^e$.

etaQuotientSpecification: (PositiveInteger, List List Integer, List Integer) -> %

etaQuotientSpecification(mm,idxs,le) returns etaQuotientSpecification(mm, rbar) where rbar is [concat(i,e) for e in le for i in idxs] without the entries whose corresponding exponent e is zero.

etaQuotientSpecification: (PositiveInteger, List List Integer, Vector Integer) -> %

etaQuotientSpecification(mm,idxs,v) returns etaQuotientSpecification(mm,idxs,members(v)).

etaQuotientSpecification: List List Integer -> %

etaQuotientSpecification(rbar) returns eaQuotientSpecification(mm, rbar) for mm=lcm[first l for l in rbar]. mm is 1 if rbar is empty.

generalizedEtaFunctionIndices: PositiveInteger -> List List Integer

generalizedEtaFunctionIndices(nn) returns all the indices of a generalized eta-quotient of level nn (without exponents), i.e. it return the list in eqref{eq:sorted-indices} where the 0 in the second argument is removed. To be precise, it returns [[d1],[d2],…,[dn],[d2,1],…,[d2,f2],…,[dn,1],…,[dn,fn]] where di is the i-th positive divisor of nn and fi=ceiling(di/2)-1.

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

inv: % -> %

from Group

latex: % -> String

from SetCategory

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

level: % -> PositiveInteger

level(x) returns either the level that was given at specification time or the lcm of all the indices.

modularGamma0?: % -> Boolean

modularGamma0?(x) returns true iff x corresponds to a eta-quotient that is a modular function for Gamma_0(level(x)). It is equivalent to zero?(modularGamma0(x)).

modularGamma0: % -> Integer

modularGamma0(x) returns 0 if all conditions are fulfilled that x specifies a modular function for Gamma0(level(x)). Otherwise it returns a positive number in the range 1 to 4 that corresponds to the condition that is not met. This corresponds to the conditions given for R(N,i,j,k,l) on page 226 of cite{Radu_RamanujanKolberg_2015} and to the conditions eqref{eq:sum=0}, eqref{eq:pure-rhoinfinity}, eqref{eq:rho0}, and eqref{eq:productsquare} in qeta.tex. It is an error if pure?(x) is false.

modularGamma1?: % -> Boolean

modularGamma1?(x) returns true iff the generalized eta-quotient corresponding to x is a modular function for Gamma_1(level(x)). It is equivalent to zero?(modularGamma1(x)).

modularGamma1: % -> Integer

modularGamma1(x) returns 0 if the parameters specify a generalized eta-quotient that is modular for Gamma1(level(x)). It returns 1, if condition eqref{eq:generalized-weight} is not met, 2, if condition eqref{eq:rhoInfinity} is not met, and 3 if condition eqref{eq:rho0} does not hold.

numer: % -> %

numer(x) returns the part of the specification that corresponds to positive exponents.

one?: % -> Boolean

from MagmaWithUnit

parts: % -> List List Integer

pureParts(x) returns a list of triples of the form [delta,g,e] for the specification of a power of a (generalized) eta-function [d,-1,e] that specifies $eta(d*tau)^e$ whereas [d,g,e] for g~=-1 specifies $eta_{d,g}(tau)^e$.

properGeneralizedEtaFunctionIndices: PositiveInteger -> List List Integer

properGeneralizedEtaFunctionIndices(nn) returns the indices of a proper generalized eta-quotient of level nn. The first entries of the indices are always nn, i.e, it returns [[nn,1],…,[nn,floor(nn/2)]].

properGeneralizedParts: % -> List List Integer

properGeneralizedParts(x) returns the list of indicies and exponents of the proper generalized part of the (generalized) eta-quotient. Each element is a 3-element list of the form [d, g, e] that stands for $eta_{d,g}^{[R]}(tau)^e$.

pure?: % -> Boolean

pure?(x) returns true if x contains no proper generalized eta-functions, i.e. if empty?(generalizedParts(x)).

pureExponents: % -> List Integer

pureExponents returns the exponents of the pure eta-quotient part of the specification. Zeros at the end of the list are removed.

pureParts: % -> List List Integer

pureParts(x) returns the part of the (generalized) eta-quotient that corresponds to pure eta-functions. Each element of the result is a three-element list [d,-1,e] that stands for $eta(d*tau)^e$.

purify: % -> %

Some generalized eta-functions can be expressed as pure eta-quotients. This function translates [2*g,g,e] into the pair [[g,2*e],[2*g,-2*e]] and [d,0,e] int [d,2*e].

recip: % -> Union(%, failed)

from MagmaWithUnit

rho0: % -> Fraction Integer

rho0(x) returns the value corresponding to eqref{eq:rhozero} in qeta.tex.

rho0ProperGeneralized: % -> Fraction Integer

rho0ProperGeneralized(x) returns the value of rho0(x) considering only the properGeneralizedParts of x. See eqref{eq:rhozero} in qeta.tex.

rho0Pure: % -> Fraction Integer

rho0Pure(x) returns the value of rho0(x) considering only the pureParts of x. See eqref{eq:rhozero} in qeta.tex.

rhoInfinity: % -> Fraction Integer

rhoInfinity(x) returns the value corresponding to eqref{eq:rhoinfty} in qeta.tex.

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from MagmaWithUnit

specDelta: List Integer -> PositiveInteger

If x is a specification and l=[d,g,e] is an element of parts(x), then specDelta(l) returns d.

specExponent: List Integer -> Integer

If x is a specification and l=[d,g,e] is an element of parts(x), then specExponent(l) returns e.

specIndex: List Integer -> List Integer

If x is a specification and l=[d,g,e] is an element of parts(x), then specIndex(l) returns [d] if g=-1, and returns [d,g] otherwise.

specSubindex: List Integer -> Integer

If x is a specification and l=[d,g,e] is an element of parts(x), then specSubindex(l) returns g.

BasicType

CoercibleTo OutputForm

CommutativeStar

Group

Magma

MagmaWithUnit

Monoid

SemiGroup

SetCategory

TwoSidedRecip

unitsKnown