Module: sage.modular.modsym.ambient
Ambient spaces of modular symbols.
We compute a space of modular symbols modulo 2. The dimension is different than that of the corresponding space in characteristic 0:
sage: M = ModularSymbols(11,4,base_ring=GF(2)); M Modular Symbols space of dimension 7 for Gamma_0(11) of weight 4 with sign 0 over Finite Field of size 2 sage: M.basis() ([X*Y,(1,0)], [X*Y,(1,8)], [X*Y,(1,9)], [X^2,(0,1)], [X^2,(1,8)], [X^2,(1,9)], [X^2,(1,10)]) sage: M0 = ModularSymbols(11,4,base_ring=QQ); M0 Modular Symbols space of dimension 6 for Gamma_0(11) of weight 4 with sign 0 over Rational Field sage: M0.basis() ([X^2,(0,1)], [X^2,(1,6)], [X^2,(1,7)], [X^2,(1,8)], [X^2,(1,9)], [X^2,(1,10)])
The charpoly of the Hecke operator
has an extra factor
.
sage: M.T(2).matrix().fcp('x') (x + 1)^2 * x^5 sage: M0.T(2).matrix().fcp('x') (x - 9)^2 * (x^2 - 2*x - 2)^2
Class: ModularSymbolsAmbient
This class is an abstract base class, so only derived classes should be instantiated. Input:
self, group, weight, sign, base_ring, [character=None]) |
Initialize a space of modular symbols.
Functions: boundary_map,
boundary_space,
compute_presentation,
cuspidal_submodule,
cusps,
dual_star_involution_matrix,
eisenstein_submodule,
element,
factor,
factorization,
integral_structure,
is_cuspidal,
is_eisenstein,
manin_basis,
manin_generators,
manin_gens_to_basis,
manin_symbol,
manin_symbols,
manin_symbols_basis,
modular_symbol,
modular_symbol_sum,
modular_symbols_of_sign,
modular_symbols_of_weight,
new_submodule,
p1list,
rank,
relation_matrix,
star_involution,
submodule,
twisted_winding_element
self) |
The boundary map to the corresponding space of boundary modular symbols.
self) |
The cuspidal submodule of self.
sage: M = ModularSymbols(12,2,0,GF(5)) ; M Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Finite Field of size 5 sage: M.cuspidal_submodule() Modular Symbols subspace of dimension 0 of Modular Symbols space of dimension 5 for Gamma_0(12) of weight 2 with sign 0 over Finite Field of size 5 sage: ModularSymbols(1,24,-1).cuspidal_submodule() Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 24 with sign -1 over Rational Field
The cuspidal submodule of the cuspidal submodule is itself:
sage: M = ModularSymbols(389) sage: S = M.cuspidal_submodule() sage: S.cuspidal_submodule() is S True
self) |
Return the matrix of the dual star involution, which is induced by complex conjugation on the linear dual of modular symbols.
self) |
Return the Eisenstein submodule of this space of modular symbols.
self, x) |
Creates and returns an element of self from a modular symbol, if possible.
Input:
ModularSymbol - a modular symbol with parent self.
self) |
Synonym for self.factorization().
self) |
Returns a list of pairs
where
is spaces of modular
symbols and self is isomorphic to the direct sum of the
as a module over the anemic Hecke algebra adjoin the
star involution. The cuspidal
are all simple, but the
Eisenstein factors need not be simple.
sage: ModularSymbols(Gamma0(22), 2).factorization() (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 * (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field)^2 * (Modular Symbols subspace of dimension 3 of Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field)
sage: ModularSymbols(1,6,0,GF(2)).factorization() (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2) * (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2 for Gamma_0(1) of weight 6 with sign 0 over Finite Field of size 2)
sage: ModularSymbols(18,2).factorization() (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field) * (Modular Symbols subspace of dimension 5 of Modular Symbols space of dimension 7 for Gamma_0(18) of weight 2 with sign 0 over Rational Field)
sage: M = ModularSymbols(DirichletGroup(38,CyclotomicField(3)).1^2, 2, +1); M Modular Symbols space of dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2 sage: M.factorization() # long time (about 8 seconds) (Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) * (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) * (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2) * (Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 7 and level 38, weight 2, character [1, zeta3], sign 1, over Cyclotomic Field of order 3 and degree 2)
self, [algorithm=default]) |
Return the
-structure of this modular symbols spaces
generated by all integral modular symbols.
Input:
ALGORITHM:
It suffices to consider lattice generated by the free
generating symbols
after quotienting
out by the
(and
) relations, since the
quotient by these relations is the same over any ring.
In weight 2 the rational basis is often integral.
sage: M = ModularSymbols(11,2) sage: M.integral_structure() Free module of degree 3 and rank 3 over Integer Ring Echelon basis matrix: [1 0 0] [0 1 0] [0 0 1]
This is rarely the case in higher weight:
sage: M = ModularSymbols(6,4) sage: M.integral_structure() Free module of degree 6 and rank 6 over Integer Ring Echelon basis matrix: [ 1 0 0 0 0 0] [ 0 1 0 0 0 0] [ 0 0 1/2 1/2 1/2 1/2] [ 0 0 0 1 0 0] [ 0 0 0 0 1 0] [ 0 0 0 0 0 1]
Here is an example involving
.
sage: M = ModularSymbols(Gamma1(5),6) sage: M.integral_structure() Free module of degree 10 and rank 10 over Integer Ring Echelon basis matrix: [ 1 0 0 0 0 0 0 0 0 0] [ 0 1 0 0 0 0 0 0 0 0] [ 0 0 1/102 0 5/204 1/136 23/24 3/17 43/136 69/136] [ 0 0 0 1/48 0 1/48 23/24 1/6 1/8 17/24] [ 0 0 0 0 1/24 0 23/24 1/3 1/6 1/2] [ 0 0 0 0 0 1/24 23/24 1/3 11/24 5/24] [ 0 0 0 0 0 0 1 0 0 0] [ 0 0 0 0 0 0 0 1/2 0 1/2] [ 0 0 0 0 0 0 0 0 1/2 1/2] [ 0 0 0 0 0 0 0 0 0 1]
self) |
Return a list of indices into the list of Manin generators
(see self.manin_generators()
) such that those symbols
form a basis for the quotient of the
-vector space spanned
by Manin symbols modulo the relations.
sage: M = ModularSymbols(2,2) sage: M.manin_basis() [1] sage: [M.manin_generators()[i] for i in M.manin_basis()] [(1,0)] sage: M = ModularSymbols(6,2) sage: M.manin_basis() [1, 10, 11] sage: [M.manin_generators()[i] for i in M.manin_basis()] [(1,0), (3,1), (3,2)]
self) |
Return list of all Manin symbols for this space. These are the generators in the presentation of this space by Manin symbols.
sage: M = ModularSymbols(2,2) sage: M.manin_generators() [(0,1), (1,0), (1,1)]
sage: M = ModularSymbols(1,6) sage: M.manin_generators() [[Y^4,(0,0)], [X*Y^3,(0,0)], [X^2*Y^2,(0,0)], [X^3*Y,(0,0)], [X^4,(0,0)]]
self) |
A list of Manin symbols that form a basis for the ambient space self. Input:
sage: m = ModularSymbols(23) sage: m.manin_symbols_basis() [(1,0), (1,17), (1,19), (1,20), (1,21)] sage: m = ModularSymbols(6, weight=4, sign=-1) sage: m.manin_symbols_basis() [[X^2,(2,1)]]
self, x, [check=True]) |
Create a modular symbol in this space.
Input:
sage: set_modsym_print_mode('modular') sage: M = ModularSymbols(11) sage: M.modular_symbol([2/11, oo]) -{8/9,1} sage: M.1 {7/8,1} sage: M.modular_symbol([-1/8, 0]) {7/8,1} sage: M.modular_symbol([0, -1/8, 0]) {7/8,1} sage: M.modular_symbol([10, -1/8, 0]) Traceback (most recent call last): ... ValueError: The first entry of the tuple (=[10, -1/8, 0]) must be an integer between 0 and k-2 (=0).
sage: N = ModularSymbols(6,4) sage: set_modsym_print_mode('manin') sage: N([1,Cusp(-1/4),Cusp(0)]) 17/2*[X^2,(2,3)] - 9/2*[X^2,(2,5)] + 15/2*[X^2,(3,1)] - 15/2*[X^2,(3,2)] sage: N([1,Cusp(-1/2),Cusp(0)]) 1/2*[X^2,(2,3)] + 3/2*[X^2,(2,5)] + 3/2*[X^2,(3,1)] - 3/2*[X^2,(3,2)]
Use check=False for efficiency if the input x is a list of length 3 whose first entry is an Integer, and whose second and third entries are cusps:
sage: M.modular_symbol([0, Cusp(2/11), Cusp(oo)], check=False) -(1,9)
sage: set_modsym_print_mode() # return to default.
self, x, [check=True]) |
Take a 3-element list consisting of a homogeneous
polynomial in degree self.weight()-2 over ZZ, and
return the corresponding sum of modular symbols as an
element of self. That is, if x is
[f, alpha, beta]
, where
, return
.
self, sign) |
Returns a space of modular symbols with the same defining properties (weight, level, etc.) as this space except with given sign.
sage: M = ModularSymbols(Gamma0(11),2,sign=0) sage: M Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field sage: M.modular_symbols_of_sign(-1) Modular Symbols space of dimension 1 for Gamma_0(11) of weight 2 with sign -1 over Rational Field sage: M = ModularSymbols(Gamma1(11),2,sign=0) sage: M.modular_symbols_of_sign(-1) Modular Symbols space of dimension 1 for Gamma_1(11) of weight 2 with sign -1 and over Rational Field
self, k) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight k.
sage: M = ModularSymbols(Gamma1(6),2,sign=0) sage: M.modular_symbols_of_weight(3) Modular Symbols space of dimension 4 for Gamma_1(6) of weight 3 with sign 0 and over Rational Field
self, [p=None]) |
Returns the new or p-new submodule of self.
Input:
sage: ModularSymbols(100).new_submodule() Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 31 for Gamma_0(100) of weight 2 with sign 0 over Rational Field sage: ModularSymbols(389).new_submodule() Modular Symbols space of dimension 65 for Gamma_0(389) of weight 2 with sign 0 over Rational Field
self) |
Returns the rank of self.
Input:
sage: M = ModularSymbols(389) sage: M.rank() 65
sage: ModularSymbols(11,sign=0).rank() 3 sage: ModularSymbols(100,sign=0).rank() 31 sage: ModularSymbols(22,sign=1).rank() 5 sage: ModularSymbols(1,12).rank() 3 sage: ModularSymbols(3,4).rank() 2 sage: ModularSymbols(8,6,sign=-1).rank() 3
self) |
Return the star involution on self, which is induced by complex conjugation on modular symbols.
self, M, [dual_free_module=None], [check=True]) |
Return the submdoule of self with given generators or free module M.
Input:
sage: M = ModularSymbols(11) sage: M.submodule([M.0]) Traceback (most recent call last): ... ValueError: The submodule must be invariant under all Hecke operators. sage: M.eisenstein_submodule().basis() ((1,0) - 1/5*(1,9),) sage: M.basis() ((1,0), (1,8), (1,9)) sage: M.submodule([M.0 - 1/5*M.2]) Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 0 over Rational Field
NOTE: It would make more sense to only check that M is invariant under the Hecke operators with index coprime to the level. Unfortunately, I do not know a reasonable algorithm for determining whether a module is invariant under just the anemic Hecke algebra, since I do not know an analogue of the Sturm bound for the anemic Hecke algebra. - William Stein, 2007-07-27
self, i, eps) |
Given a space of modular symbols, an integer 0 <= i <= k-2, and a Dirichlet character eps, return the so-called 'twisted winding element':
Special Functions: __call__,
__cmp__,
__init__,
_action_on_modular_symbols,
_compute_atkin_lehner_matrix,
_compute_dual_hecke_matrix,
_compute_hecke_matrix_prime,
_compute_sign_submodule,
_degeneracy_lowering_matrix,
_degeneracy_raising_matrix,
_latex_,
_matrix_of_operator_on_modular_symbols,
_modular_symbol_0_to_alpha,
_ModularSymbolsAmbient__heilbronn_operator,
_repr_
self, x, [computed_with_hecke=False]) |
Coerce x into this modular symbols space (self). The result is either an element of self or a subspace of self.
The allowed inputs for x are as follows:
[alpha, beta]
, where
[i, alpha, beta]
,
where
If our list is [f, alpha, beta]
, where
is a homogeneous polynomial in two variables
of degree k-2 with integer coefficients, and alpha
and beta are cusps, return the corresponding sum of
modular symbols as an element of self. So if
, return
.
self, g) |
Compute the matrix of the action of the 2x2 integer matrix g=[a,b,c,d] (which must be specified as an integer list) on self with respect to the standard basis.
Use _matrix_of_operator_on_modular_symbols for more general operators.
self, d) |
Input:
An example at level 29:
sage: M = ModularSymbols((DirichletGroup(29,QQ).0), 2,1); M Modular Symbols space of dimension 4 and level 29, weight 2, character [-1], sign 1, over Rational Field sage: w = M._compute_atkin_lehner_matrix(29) sage: w^2 == 1 True sage: w.fcp() (x - 1)^2 * (x + 1)^2
This doesn't work since the character has order > 2:
sage: M = ModularSymbols((DirichletGroup(13).0), 2,1); M Modular Symbols space of dimension 0 and level 13, weight 2, character [zeta12], sign 1, over Cyclotomic Field of order 12 and degree 4 sage: M._compute_atkin_lehner_matrix(13) Traceback (most recent call last): ... ValueError: Atkin-Lehner only leaves space invariant when character is trivial or quadratic. In general it sends M_k(chi) to M_k(1/chi)
Note that Atkin-Lehner does make sense on
, but
doesn't commute with the Hecke operators:
sage: M = ModularSymbols(Gamma1(13),2) sage: w = M.atkin_lehner_operator(13).matrix() sage: t = M.T(2).matrix() sage: t*w == w*t False sage: w^2 == 1 True
self, p, [rows=None]) |
Compute and return the matrix of the p-th Hecke operator.
We first compute some examples for Gamma0(N):
sage: m = ModularSymbols(2, weight=4) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^2 - 9*x + 8
sage: m = ModularSymbols(1,weight=12) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^3 - 2001*x^2 - 97776*x - 1180224 sage: m._compute_hecke_matrix_prime(13).charpoly('x') x^3 - 1792159238562*x^2 - 2070797989680255444*x - 598189440899986203208472
sage: m = ModularSymbols(1,weight=12, sign=-1) sage: m._compute_hecke_matrix_prime(5) [4830] sage: m._compute_hecke_matrix_prime(23) [18643272]
sage: m = ModularSymbols(3,4) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^2 - 18*x + 81
sage: m = ModularSymbols(6,4) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^6 - 14*x^5 + 29*x^4 + 172*x^3 - 124*x^2 - 320*x + 256 sage: m._compute_hecke_matrix_prime(3).charpoly('x') x^6 - 50*x^5 + 511*x^4 + 3012*x^3 - 801*x^2 - 9234*x + 6561
sage: m = ModularSymbols(15,4, sign=-1) sage: m._compute_hecke_matrix_prime(3).charpoly('x') x^4 - 2*x^3 + 18*x^2 + 18*x - 243
sage: m = ModularSymbols(6,4) sage: m._compute_hecke_matrix_prime(7).charpoly('x') x^6 - 1344*x^5 + 666240*x^4 - 140462080*x^3 + 8974602240*x^2 + 406424518656*x + 3584872677376
sage: m = ModularSymbols(4,4) sage: m._compute_hecke_matrix_prime(3).charpoly('x') x^3 - 84*x^2 + 2352*x - 21952
We now compute some examples for modular symbols on Gamma1(N):
sage: m = ModularSymbols(Gamma1(13),2, sign=-1) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^2 + 3*x + 3
The following is an example with odd weight:
sage: m = ModularSymbols(Gamma1(5),3) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^4 - 10*x^3 + 50*x^2 - 170*x + 289
This example has composite conductor and weight>2 dividing the conductor and nontrivial sign:
sage: m = ModularSymbols(Gamma1(9),3, sign=1) sage: m._compute_hecke_matrix_prime(3).charpoly('x') x^6 + 3*x^4 - 19*x^3 + 24*x^2 - 9*x
self, sign, [compute_dual=True]) |
Return the subspace of self that is fixed under the star involution.
Input:
sage: ModularSymbols(1,12,0,GF(5)).minus_submodule() ## indirect doctest Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 3 for Gamma_0(1) of weight 12 with sign 0 over Finite Field of size 5
self, codomain, R) |
Input:
where g.x is the formal linear fractional transformation on modular symbols.
self, M, H, [t=1]) |
Returns the matrix function from self to M defined by the pair (H, t), where H is a list of matrices and t is an integer.
Input:
Class: ModularSymbolsAmbient_wt2_g0
self, N, sign, F) |
Initialize a space of modular symbols. Input:
sage: M = ModularSymbols(Gamma0(12),2)
Functions: boundary_space
Special Functions: __init__,
_compute_hecke_matrix_prime,
_cuspidal_new_submodule_dimension_formula,
_cuspidal_submodule_dimension_formula,
_dimension_formula
self, p, [rows=None]) |
Compute and return the matrix of the p-th Hecke operator.
sage: m = ModularSymbols(37,2) sage: m._compute_hecke_matrix_prime(2).charpoly('x') x^5 + x^4 - 8*x^3 - 12*x^2
Class: ModularSymbolsAmbient_wtk_eps
self, eps, weight, [sign=0]) |
Space of modular symbols with given weight, character, and sign.
Input:
sage: eps = DirichletGroup(4).gen(0) sage: eps.order() 2 sage: ModularSymbols(eps, 2) Modular Symbols space of dimension 0 and level 4, weight 2, character [-1], sign 0, over Rational Field sage: ModularSymbols(eps, 3) Modular Symbols space of dimension 2 and level 4, weight 3, character [-1], sign 0, over Rational Field
We next create a space with character of order bigger than 2.
sage: eps = DirichletGroup(5).gen(0) sage: eps # has order 4 [zeta4] sage: ModularSymbols(eps, 2).dimension() 0 sage: ModularSymbols(eps, 3).dimension() 2
Here is another example:
sage: G, e = DirichletGroup(5).objgen() sage: M = ModularSymbols(e,3) sage: loads(M.dumps()) == M True
Functions: boundary_space,
manin_symbols,
modular_symbols_of_level,
modular_symbols_of_sign,
modular_symbols_of_weight
self, N) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.
For example, if self is the space of modular symbols of weight 2 for Gamma_0(22), and level is 11, then this function returns modular symbols of weight 2 for Gamma_0(11).
self, sign) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with given sign.
self, k) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with weight k.
Special Functions: __init__,
_cuspidal_new_submodule_dimension_formula,
_cuspidal_submodule_dimension_formula,
_degeneracy_raising_matrix,
_dimension_formula,
_matrix_of_operator_on_modular_symbols,
_repr_
self, codomain, R, [character_twist=False]) |
Input:
where g.x is the formal linear fractional transformation on modular symbols.
Class: ModularSymbolsAmbient_wtk_g0
self, N, k, sign, F) |
Initialize a space of modular symbols of weight
for
, over
.
For weight
, it is faster to use
ModularSymbols_wt2_g0
.
Input:
sage: ModularSymbols(1,12) Modular Symbols space of dimension 3 for Gamma_0(1) of weight 12 with sign 0 over Rational Field sage: ModularSymbols(1,12, sign=1).dimension() 2 sage: ModularSymbols(15,4, sign=-1).dimension() 4 sage: ModularSymbols(6,6).dimension() 10 sage: ModularSymbols(36,4).dimension() 36
Functions: boundary_space,
manin_symbols,
modular_symbols_of_level
self, N) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.
For example, if self is the space of modular symbols of weight 2 for Gamma_0(22), and level is 11, then this function returns modular symbols of weight 2 for Gamma_0(11).
sage: M = ModularSymbols(11) sage: M.modular_symbols_of_level(22) Modular Symbols space of dimension 7 for Gamma_0(22) of weight 2 with sign 0 over Rational Field sage: M = ModularSymbols(Gamma1(6)) sage: M.modular_symbols_of_level(12) Modular Symbols space of dimension 9 for Gamma_1(12) of weight 2 with sign 0 and over Rational Field
Special Functions: __init__,
_cuspidal_new_submodule_dimension_formula,
_cuspidal_submodule_dimension_formula,
_degeneracy_raising_matrix,
_dimension_formula,
_repr_
Class: ModularSymbolsAmbient_wtk_g1
self, level, weight, sign, F) |
Initialize a space of modular symbols for Gamma1(N).
Input:
sage: ModularSymbols(Gamma1(17),2) Modular Symbols space of dimension 25 for Gamma_1(17) of weight 2 with sign 0 and over Rational Field sage: [ModularSymbols(Gamma1(7),k).dimension() for k in [2,3,4,5]] [5, 8, 12, 16]
sage: M = ModularSymbols(Gamma1(7),3)
Functions: boundary_space,
manin_symbols,
modular_symbols_of_level
self, N) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.
Special Functions: __init__,
_compute_hecke_matrix_prime_power,
_cuspidal_new_submodule_dimension_formula,
_cuspidal_submodule_dimension_formula,
_degeneracy_raising_matrix,
_dimension_formula,
_repr_
Class: ModularSymbolsAmbient_wtk_gamma_h
self, group, weight, sign, F) |
Initialize a space of modular symbols for
.
Input:
sage: ModularSymbols(GammaH(15,[4]),2) Modular Symbols space of dimension 9 for Congruence Subgroup Gamma_H(15) with H generated by [4] of weight 2 with sign 0 and over Rational Field
Functions: boundary_space,
manin_symbols,
modular_symbols_of_level
self, N) |
Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.
Special Functions: __init__,
_compute_hecke_matrix_prime_power,
_cuspidal_new_submodule_dimension_formula,
_cuspidal_submodule_dimension_formula,
_degeneracy_raising_matrix,
_dimension_formula,
_repr_