QEtaSpecification

qetaspec.spad line 215 [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 PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

^: (%, 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 correspontds to 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, https://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: % -> %

from QEtaSpecificationCategory

dilate: (%, PositiveInteger) -> %

from QEtaSpecificationCategory

etaFunctionIndices: PositiveInteger -> List List Integer

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

etaPolynomial: (Polynomial Integer, List %) -> Polynomial Integer

etaPolynomial(mpol,mspecs) returns etaPolynomial(mpol,mspecs,”e”,"y").

etaPolynomial: (Polynomial Integer, List %, String, String) -> Polynomial Integer

etaPolynomial(mpol,mspecs,e,y) returns etaPolynomial(mpol,mspecs,m,e,y) where the common letter for the variables is extracted via first(string(first(variables(first(mpol))))).

etaPolynomial: (Polynomial Integer, List %, String, String, String) -> Polynomial Integer

etaPolynomial(mpol,mspecs,m,e,y) assumes that mpol is given in variables mi (i in 1..#mspecs) that corresponds to mspecs.i. This function replaces mi in mpol by monomial(mspecs.i,e,y).

etaQuotient: (%, (Integer, Integer) -> OutputForm) -> OutputForm

etaQuotient(rspec, v, e) returns the generalized eta-quotient given by rspec where each part is formatted by the function v.

etaRationalFunction: (Polynomial Integer, List %) -> Fraction Polynomial Integer

etaRationalFunction(mpol,mspecs) returns etaRationalFunction(mpol,mspecs,”e”).

etaRationalFunction: (Polynomial Integer, List %, String) -> Fraction Polynomial Integer

etaRationalFunction(mpol,mspecs,e) returns etaRationalFunction(mpol,mspecs,m,e) where the common letter for the variables is extracted via first(string(first(variables(first(mpol))))).

etaRationalFunction: (Polynomial Integer, List %, String, String) -> Fraction Polynomial Integer

etaRationalFunction(mpol,mspecs,m,e) assumes that mpol is given in variables mi (i in 1..#mspecs) that corresponds to mspecs.i. This function replaces mi in mpol by quotient(mspecs.i,e).

exponent: (%, List Integer) -> Integer

exponent(x, idx) returns exponent(x, vector idx).

exponent: (%, Vector Integer) -> Integer

exponent(x,idx) returns the exponent of x corresponding to the index idx. The index is either given as a two element list [d,g] with 0<2*g<=d or as [d] or [d,0]. The latter two cases are equivalent and correspond to asking for the exponent of a pure eta-function.

exponents: (%, List List Integer) -> List Integer

exponents(x,idxs) returns the exponents of x corresponding to the indices idxs.

expression: (Integer, Integer) -> OutputForm

expression(d,g) generates $eta_{d,g}(tau)$ as an OutputForm. Requirement: 0<2*g<d.

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 Hashable

hashUpdate!: (HashState, %) -> HashState

from Hashable

indices: % -> List List Integer

indices(x) returns the indices of x corresponding to non-zero exponents.

inv: % -> %

from Group

latex: % -> String

from SetCategory

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

level: % -> PositiveInteger

from QEtaSpecificationCategory

max: (%, %) -> %

from OrderedSet

min: (%, %) -> %

from OrderedSet

modularGamma0?: PositiveInteger -> % -> Boolean

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

modularGamma0: PositiveInteger -> % -> Integer

modularGamma0(nn)(x) returns 0 if all conditions are fulfilled that x specifies a modular function for Gamma0(nn). 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?: PositiveInteger -> % -> Boolean

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

modularGamma1: PositiveInteger -> % -> Integer

modularGamma1(nn)(x) returns 0 if the parameters specify a generalized eta-quotient that is modular for Gamma1(nn). 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.

monomial: % -> Polynomial Integer

from QEtaSpecificationCategory

monomial: (%, (Integer, Integer) -> OutputForm) -> OutputForm

monomial(spec,v) applies v to parts(spec) and multiplies the results together.

monomial: (%, String, String) -> Polynomial Integer

from QEtaSpecificationCategory

monomialQuotient: (%, (Integer, Integer) -> OutputForm) -> OutputForm

monomialQuotient(spec,v) essentually returns monomial(numer(spec))/monomial(denom(spec))

numer: % -> %

from QEtaSpecificationCategory

one?: % -> Boolean

from MagmaWithUnit

parts: % -> List List Integer

parts(x) returns concat(pureParts x, properGeneralizedParts x).

pretty: % -> OutputForm

pretty(x) returns pretty(x, expression), i.e. shows x as a product of eta-functions.

pretty: (%, (Integer, Integer) -> OutputForm) -> OutputForm

pretty(x, v) shows x with possibly negative exponents where the format is given by v.

prettyQuotient: % -> OutputForm

prettyQuotient(x) returns prettyQuootient(x, expression), i.e. shows x as a quotient of eta-functions.

prettyQuotient: (%, (Integer, Integer) -> OutputForm) -> OutputForm

prettyQuotient(x) basically returns pretty(numer(x),v)/pretty(denom(x),v), i.e. shows x as a quotient.

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. It returns allPureExponents(x) with zeros at the end of the list 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 two-element list [d,e] that stands for $eta(d*tau)^e$.

purify: % -> %

from QEtaSpecificationCategory

qEtaQuotient: (%, (Integer, Integer) -> OutputForm) -> OutputForm

qEtauotient(rspec, v) returns qQuotient(rspec, v, e) with e=rhoInfinity(rspec).

qQuotient: (%, (Integer, Integer) -> OutputForm, Fraction Integer) -> OutputForm

qQuotient(rspec, v, e) returns the generalized eta-quotient given by rspec where each part is formatted by the function v. The whole eta-quotient comes multiplied with a q power with exponent e.

quotient: % -> Fraction Polynomial Integer

from QEtaSpecificationCategory

quotient: (%, String) -> Fraction Polynomial Integer

from QEtaSpecificationCategory

recip: % -> Union(%, failed)

from MagmaWithUnit

rho0: (PositiveInteger, %) -> Fraction Integer

rho0(mm,x) returns mm*rhobar0(x) See eqref{eq:rhozero} in qeta.tex.

rho0ProperGeneralized: (PositiveInteger, %) -> Fraction Integer

rho0ProperGeneralized(mm,x) returns mm*rhobar0ProperGeneralized(x). See eqref{eq:rhozero} in qeta.tex.

rho0Pure: (PositiveInteger, %) -> Fraction Integer

rho0Pure(mm,x) returns mm*rhobar0(x). See eqref{eq:rhozero} in qeta.tex.

rhobar0: % -> Fraction Integer

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

rhobar0ProperGeneralized: % -> Fraction Integer

rhobar0ProperGeneralized(x) returns the value of rhobar0(x) considering only the properGeneralizedParts of x. See eqref{eq:rhobarzero} in qeta.tex.

rhobar0Pure: % -> Fraction Integer

rhobar0Pure(x) returns the value of rhobar0(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.

rhoInfinity: (%, PositiveInteger, NonNegativeInteger) -> Fraction Integer

rhoInfinity(x,m,k) returns the value corresponding to $frac{k+rho_infty(r)}{m}$ in eqref{eq:alphaInfinity} in qeta.tex. This is, in fact, part of eqref{eq:beta}.

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from MagmaWithUnit

smaller?: (%, %) -> Boolean

from Comparable

specDelta: List Integer -> PositiveInteger

If x is a specification and l=[d,e] or 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,e] or l=[d,g,e] is an element of parts(x), then specExponent(l) returns e.

specification: (Fraction Polynomial Integer, String) -> %

specification(f,e) returns nspec/dspec for nspec:=specification(numer(f),e) and dspec:=specification(denom(f),e).

specification: (List List Integer, List Integer) -> %

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

specification: (List List Integer, Vector Integer) -> %

specification(idxs,v) returns specification(idxs,members(v)). Input condition: #idxs=#v.

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

specification(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.

specification: (Polynomial Integer, String) -> %

specification(p,e) assumes that p is a polynomial with only one monomial. Furthermore, it assumes that p is in the variables ed or ed_g and 0<=g<=d) and no other variables. The coefficient of this monomial is ignored. The function collects the d's and g's and the corresponding exponent of the variable and creates the respective eta-specification.

specification: (PositiveInteger, List Integer) -> %

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

specification: Fraction Polynomial Integer -> %

from QEtaSpecificationCategory

specification: List List Integer -> %

specification(rbar) returns the specification of a generalized eta-quotient given by a list l of (index,exponent) pairs where an index can be either a positive integer d or a pair (d,g) with 0<=g<=d. 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$. Note that [d,g,e] will silently be translated to [d,d-g,e] if 2*g>d. Note that you can apply the function purify to such an eta-quotient. If rbar is empty, then the result corresponds to 1.

specification: Polynomial Integer -> %

from QEtaSpecificationCategory

specIndex: List Integer -> List Integer

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

specSubindex: List Integer -> Integer

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

var: Symbol -> (Integer, Integer) -> OutputForm

var(v)(d,g) generates vd_g as an OutputForm. Requirement: 0<2*g<d.

varPower: (List Integer, (Integer, Integer) -> OutputForm) -> OutputForm

varPower([d,g,e], v) returns v(d,g)^e as an OutputForm.

varsub: Symbol -> (Integer, Integer) -> OutputForm

varsub(v)(d,g) generates subscript(v,[d,g]) as an OutputForm. Requirement: 0<2*g<d.

weaklyModularGamma0?: PositiveInteger -> % -> Boolean

weaklyModularGamma0?(nn)(x) returns true iff the eta-quotient corresponding to r is a weakly modular function for Gamma_0(nn). It is equivalent to zero?(weaklyModularGamma0(nn,x)).

weaklyModularGamma0: PositiveInteger -> % -> Integer

We refer 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:pure-rho0}, and eqref{eq:productsquare} in qeta.tex where condition eqref{eq:sum=0} is replaced (according to the Theorem of Gordon-Hughes-Newman, see cite{Ono_ParityOfThePartitionFunctionInArithmeticProgression_1996}) by $sum_{d|nn} r_d = 2k$ or $weight(r)=k$ for some integer k. weaklyModularGamma0(nn)(r) returns 0 if all conditions are fulfilled. Otherwise it returns a positive number in the range 1 to 4 that corresponds to the condition that is not met. It is equivalent to check whether there is an extension v of r such that matrixModular(nn)*v is 0 (except for the first row where an integer weight is checked).

weaklyModularGamma1?: PositiveInteger -> % -> Boolean

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

weaklyModularGamma1: PositiveInteger -> % -> Integer

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

weight: % -> Fraction Integer

weight(x) returns 1/2*reduce(+,pureExponents(x),0) and is thus the weight of the modular eta-quotient, i.e. the exponent for $(c tau + d)$ in a transformation with the matrix[[a,b],[c,d]].

BasicType

CoercibleTo OutputForm

CommutativeStar

Comparable

Group

Hashable

Magma

MagmaWithUnit

Monoid

OrderedSet

PartialOrder

QEtaSpecificationCategory

SemiGroup

SetCategory

TwoSidedRecip

unitsKnown