QEtaSpecificationRing C

qetaspecring.spad line 91 [edit on github]

QEtaSpecificationRing is the domain of integer linear combinations of eta-quotients.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, C) -> %

from RightModule C

*: (C, %) -> %

from LeftModule C

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

=: (%, %) -> Boolean

from BasicType

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

associator: (%, %, %) -> %

from NonAssociativeRng

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

charthRoot: % -> Union(%, failed) if C has CharacteristicNonZero

from CharacteristicNonZero

coefficient: (%, QEtaSpecification) -> C

from FreeModuleCategory(C, QEtaSpecification)

coefficients: % -> List C

from FreeModuleCategory(C, QEtaSpecification)

coerce: % -> %

from Algebra %

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: C -> %

from Algebra C

coerce: Fraction Polynomial C -> % if C has IntegralDomain

coerce(p) returns specificationPolynomial(p,e) where e is the first letter of the first variable of p. This, of course, assumes that all variables of p are of the form ed or ed_g where d is a positive integer and 0<g<=d/2

coerce: Integer -> %

from NonAssociativeRing

coerce: List Record(k: QEtaSpecification, c: C) -> %

from MonoidRingCategory(C, QEtaSpecification)

coerce: Polynomial C -> %

coerce(p) returns specificationPolynomial(p,e) where e is the first letter of the first variable of p. This, of course, assumes that all variables of p are of the form ed or ed_g where d is a positive integer and 0<g<=d/2

coerce: QEtaSpecification -> %

from CoercibleFrom QEtaSpecification

commutator: (%, %) -> %

from NonAssociativeRng

construct: List Record(k: QEtaSpecification, c: C) -> %

from IndexedProductCategory(C, QEtaSpecification)

constructOrdered: List Record(k: QEtaSpecification, c: C) -> %

from IndexedProductCategory(C, QEtaSpecification)

convert: % -> InputForm if C has Finite and QEtaSpecification has Finite

from ConvertibleTo InputForm

enumerate: () -> List % if C has Finite and QEtaSpecification has Finite

from Finite

etaPolynomial: % -> Polynomial C

etaPolynomial(x) returns etaPolynomial(x,”E”,"Y").

etaPolynomial: (%, String, String) -> Polynomial C

etaPolynomial(x,e,y) replaces in each term of x the specification spec by monomial(spec,e,y).

etaRationalFunction: % -> Fraction Polynomial C if C has IntegralDomain

etaRationalFunction(x) returns etaRationalFunction(x,”E”).

etaRationalFunction: (%, String) -> Fraction Polynomial C if C has IntegralDomain

etaRationalFunction(x,e) replaces in each term of x the specification spec by quotient(spec,e).

hash: % -> SingleInteger if C has Finite and QEtaSpecification has Finite

from Hashable

hashUpdate!: (HashState, %) -> HashState if C has Finite and QEtaSpecification has Finite

from Hashable

index: PositiveInteger -> % if C has Finite and QEtaSpecification has Finite

from Finite

latex: % -> String

from SetCategory

leadingCoefficient: % -> C

from IndexedProductCategory(C, QEtaSpecification)

leadingMonomial: % -> %

from IndexedProductCategory(C, QEtaSpecification)

leadingSupport: % -> QEtaSpecification

from IndexedProductCategory(C, QEtaSpecification)

leadingTerm: % -> Record(k: QEtaSpecification, c: C)

from IndexedProductCategory(C, QEtaSpecification)

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

level: % -> PositiveInteger

level(x) returns the least common multiple of the levels of all terms.

linearExtend: (QEtaSpecification -> C, %) -> C

from FreeModuleCategory(C, QEtaSpecification)

listOfTerms: % -> List Record(k: QEtaSpecification, c: C)

from IndexedDirectProductCategory(C, QEtaSpecification)

lookup: % -> PositiveInteger if C has Finite and QEtaSpecification has Finite

from Finite

map: (C -> C, %) -> %

from IndexedProductCategory(C, QEtaSpecification)

modularGamma0?: % -> Boolean

modularGamma0?(x) returns true if the specification in each term of x is modular with respect to $Gamma_0(N)$ where $N$ is the lcm of all levels of the specifications of the terms of x.

modularGamma1?: % -> Boolean

modularGamma1?(x) returns true if the specification in each term of x is modular with respect to $Gamma_0(N)$ where $N$ is the lcm of all levels of the specifications of the terms of x.

monomial?: % -> Boolean

from IndexedProductCategory(C, QEtaSpecification)

monomial: (C, QEtaSpecification) -> %

from IndexedProductCategory(C, QEtaSpecification)

monomials: % -> List %

from FreeModuleCategory(C, QEtaSpecification)

numberOfMonomials: % -> NonNegativeInteger

from IndexedDirectProductCategory(C, QEtaSpecification)

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra C

pretty: (%, Integer) -> OutputForm

pretty(x,fmt) returns pretty(x,fmt,0).

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

pretty(x,fmt,v,e) multiplies x by q^e and transforms the relation into a nicely looking output form using the variable function v deciding via format whether it must print a factor of q.

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

pretty(x,fmt,e) chooses an appropriate variable function v according to fmt and returns pretty(x,fmt,v,e).

purify: % -> %

purify(x) applies purify(spec) to each term c*spec of x.

random: () -> % if C has Finite and QEtaSpecification has Finite

from Finite

recip: % -> Union(%, failed)

from MagmaWithUnit

reductum: % -> %

from IndexedProductCategory(C, QEtaSpecification)

retract: % -> C

from RetractableTo C

retract: % -> QEtaSpecification

from RetractableTo QEtaSpecification

retractIfCan: % -> Union(C, failed)

from RetractableTo C

retractIfCan: % -> Union(QEtaSpecification, failed)

from RetractableTo QEtaSpecification

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

size: () -> NonNegativeInteger if C has Finite and QEtaSpecification has Finite

from Finite

smaller?: (%, %) -> Boolean if C has Comparable

from Comparable

specificationPolynomial: (Fraction Polynomial C, String) -> % if C has IntegralDomain

specificationPolynomial(p,e) replaces each variable ei by the respective eta-specification and thus turns p into an element of this domain. Note that the specifications of each monomial may live in different levels. This function can be seen as a coercion.

specificationPolynomial: (Polynomial C, String) -> %

specificationPolynomial(p,e) replaces each variable ei by the respective eta-specification and thus turns p into an element of this domain. Note that the specifications of each monomial may live in different levels. This function can be seen as a coercion.

specificationPolynomial: (Polynomial C, String, List QEtaSpecification) -> %

specificationPolynomial(p,m,specs) replaces each of the variables mi in p by the respective element specs.i and thus creates a formal linear combination of eta-quotients.

specificationPolynomial: (PositiveInteger, Fraction Polynomial C, String) -> % if C has IntegralDomain

specificationPolynomial(nn,p,e) replaces each variable ei by the respective eta-specification (of level nn) and thus turns p into an element of this domain. It can be seen as a coercion function.

specificationPolynomial: (PositiveInteger, Polynomial C, String) -> %

specificationPolynomial(nn,p,e) replaces each variable ei by the respective eta-specification (of level nn) and thus turns p into an element of this domain. It can be seen as a coercion function.

subtractIfCan: (%, %) -> Union(%, failed)

from CancellationAbelianMonoid

support: % -> List QEtaSpecification

from FreeModuleCategory(C, QEtaSpecification)

terms: % -> List Record(k: QEtaSpecification, c: C)

from MonoidRingCategory(C, QEtaSpecification)

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianProductCategory C

AbelianSemiGroup

Algebra %

Algebra C

BasicType

BiModule(%, %)

BiModule(C, C)

CancellationAbelianMonoid

CharacteristicNonZero if C has CharacteristicNonZero

CharacteristicZero if C has CharacteristicZero

CoercibleFrom C

CoercibleFrom QEtaSpecification

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable if C has Comparable

ConvertibleTo InputForm if C has Finite and QEtaSpecification has Finite

Finite if C has Finite and QEtaSpecification has Finite

FreeModuleCategory(C, QEtaSpecification)

Hashable if C has Finite and QEtaSpecification has Finite

IndexedDirectProductCategory(C, QEtaSpecification)

IndexedProductCategory(C, QEtaSpecification)

LeftModule %

LeftModule C

Magma

MagmaWithUnit

Module %

Module C

Monoid

MonoidRingCategory(C, QEtaSpecification)

NonAssociativeAlgebra %

NonAssociativeAlgebra C

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

RetractableTo C

RetractableTo QEtaSpecification

RightModule %

RightModule C

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

unitsKnown