QEtaSpecification

qetaspec.spad line 114 [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 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, 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}.

asExpression?: Integer -> Boolean

asExpression?(fmt) is true if the respective bit in fmt corresponding to formatAsExpression() is set.

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].

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.

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

etaQuotientSpecification(p,e) is like etaQuotientSpecification(level,f,e) where level is the lcm of all d corresponding to the number after the string e in the variables of f.

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

etaQuotientSpecification(idxs,le) returns etaQuotientSpecification(mm,idxs,le) where mm:=lcm[first l for l in idxs].

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

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

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, Fraction Polynomial Integer, String) -> %

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

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). 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 translated to [d,d-g,e] if 2*g>d. Note that you can apply the function purify to such an eta-quotient.

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: (PositiveInteger, Polynomial Integer, String) -> %

etaQuotientSpecification(level,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 (where d is a divisor of level 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.

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.

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 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,-1]. The latter two case are equivalent and correspond to asking for the exponent of a pure eta-function.

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,-1]. The latter two case 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.

formatAsExpression: (Integer)

formatAsExpression() is a number to be used as a format value in the function prettyVariable. If set like prettyVariable(x,…+formatAsExpression()+…,e) it means that the output is in terms of full expression instead of just variables. The corresponding test is asExpression?.

formatWithQFactor: (Integer)

formatWithQFactor() is a number to be used as a format value in the function prettYVariable. If set like prettyVariable(x,…+formatWithQFactor()+…,e) it means that the output is in terms of qPochhammer symbols instead of Dedekind eta-functions. The corresponding test is withQFactor?.

formatWithSubscript: (Integer)

formatWithSubscript() is a number to be used as a format value in the function prettyVariable. If set like prettyVariable(x,…+formatWithSubscript()+…,e) it means that the output is in terms of variables with subscripts instead of just E1, E2, etc. The corresponding test is withSubscript?.

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

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.

monomial: % -> Polynomial Integer

monomial(s) returns monomial(s,”E”,"Y").

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

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

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

monomial(s,e,y) translates the specification of a (generalized) eta-quotient to a monomial. The indices i are translated into a variable via indexedSymbol(e,i) if the exponent is positive and to indexedSymbol(y,i) if the exponent is negative. All those variables with their (absolute) value of) the exponent are multiplied together to give the resulting monomial. The yi correspond to 1/ei.

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

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

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$.

prettyVariable: Integer -> (Integer, Integer) -> OutputForm

prettyVariable(fmt) where fmt is a sum of any of formatWithQFactor(), formatAsExpression(), formatWithSubscript() returns a function f such that f(d,g) returns an OutputForm of the variable corresponding to the eta-function $eta(dtau)$ if g=-1 and to the generalized eta-function $eta_{d,g}(tau)$, otherwise. If formatWithQFactor() is given, then the functions varPochhammer, varsub(‘u), or var(‘u) from QEtaSpecification are chosen if additionally formatAsExpression(), formatWithSubscript() or nothing is given, respectively. If formatWitQFactor() is not given then the respective functions varEta, varsub(‘E) or var(‘E) will be selected.

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 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].

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-quatient comes multiplied with a q power with exponent e.

quotient: % -> Fraction Polynomial Integer

quotient(s) returns quotient(s,”E”)

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

quotient(s,v) translates the specification of a (generalized) eta-quotient to a fraction of monomials. The indices i are translated into a variable via indexedSymbol(e,i) and raised to the respective power given by the specification.

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

smaller?: (%, %) -> Boolean

from Comparable

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.

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

var(v)(d,g) generates vd_g as an OutputForm. If g=-1 it becomes just vd.

varEta: (Integer, Integer) -> OutputForm

varEta(d,g) generates $eta_{d,g}(tau)$ as an OutputForm. If g=-1 it becomes just $eta(dtau)$

varPochhammer: (Integer, Integer) -> OutputForm

varPochhammer(d,g) generates $(q^g,q^{d-g};q^d)_infty$ as an OutputForm. If g=-1 it becomes $(q^d;q^d)_infty$.

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. If g=-1 it becomes just subscript(v,[d]).

weaklyModularGamma0?: % -> Boolean

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

weaklyModularGamma0: % -> 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(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(level(r))*v is 0 (except for the first row where an integer weight is checked).

weaklyModularGamma1?: % -> Boolean

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

weaklyModularGamma1: % -> Integer

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

withQFactor?: Integer -> Boolean

withQFactor?(fmt) is true if the respective bit in fmt corresponding to formatWithQFactor() is set.

withSubscript?: Integer -> Boolean

withSubscript?(fmt) is true if the respective bit in fmt corresponding to formatWithSubscript() is set.

BasicType

CoercibleTo OutputForm

CommutativeStar

Comparable

Group

Hashable

Magma

MagmaWithUnit

Monoid

SemiGroup

SetCategory

TwoSidedRecip

unitsKnown