The module modular.modsym.relation_matrix defines the following functions:
syms, mod, field, weight) |
Compute a matrix whose echelon form gives the quotient by 3-term T relations.
INPUT: syms -- ManinSymbols mod -- list that gives quotient modulo some two-term relations, i.e., the S relations, and if sign is nonzero, the I relations. field -- base_field weight -- int OUTPUT: A sparse matrix whose rows correspond to the reduction of the T relations modulo the S and I relations.
syms, sign, field, weight) |
Compute the presentation for self, as a quotient of Manin symbols modulo relations.
INPUT: syms -- manin_symbols.ManinSymbols sign -- integer (-1, 0, 1) field -- a field weight -- integer weight OUTPUT: -- sparse matrix whose rows give each generator in terms of a basis for the quotient -- list of integers that give the basis for the quotient -- mod: list where mod[i]=(j,s) means that x_i = s*x_j modulo the 2-term S (and I) relations.
ALGORITHM: 1. Let S = [0,-1; 1,0], T = [0,-1; 1,-1], and I = [-1,0; 0,1].
2. Let x_0, ..., x_n-1 by a list of all non-equivalent Manin symbols.
3. Form quotient by 2-term S and (possibly) I relations.
4. Create a sparse matrix A with m columns, whose rows encode the relations
There are about n such rows. The number of nonzero entries per row is at most 3*(k-1). Note that we must include rows for *all* i, since even if
5. Compute the reduced row echelon form of A using sparse Gaussian elimination.
6. Use what we've done above to read off a sparse matrix R that uniquely expresses each of the n Manin symbols in terms of a subset of Manin symbols, modulo the relations. This subset of Manin symbols is a basis for the quotient by the relations.
syms, relation_matrix, mod, field) |
Compute echelon form of 3-term relation matrix, and read off each generator in terms of basis.
INPUT: syms -- manin_symbols.ManinSymbols relation_matrix -- as output by __compute_T_relation_matrix(self, mod) mod -- quotient mod S (and I) relations field -- base field OUTPUT: Matrix -- a matrix whose ith row expresses the Manin symbol generators in terms of a basis of Manin symbols (modulo the S,I, and T rels) Note that the entries of Matrix need not be integers.
list - integers i, such that the Manin symbols x_i are a basis.
syms, sign) |
Compute quotient of Manin symbols by the I relations.
INPUT: syms -- ManinSymbols sign -- int (either -1, 0, or 1) OUTPUT: rels -- set of pairs of pairs (j, s), where if mod[i] = (j,s), then x_i = s*x_j (mod S relations)
WARNING: We quotient by the involution eta((u,v)) = (-u,v), which has the opposite sign as the involution in Merel's Springer LNM 1585 paper! Thus our +1 eigenspace is his -1 eigenspace, etc. We do this for consistency with MAGMA.
syms) |
Compute quotient of Manin symbols by the S relations.
Here S is the 2x2 matrix [0, -1; 1, 0].
INPUT: syms -- manin_symbols.ManinSymbols OUTPUT: rels -- set of pairs of pairs (j, s), where if mod[i] = (j,s), then x_i = s*x_j (mod S relations)
sage: from manin_symbols import ManinSymbolList_gamma0 sage: syms = ManinSymbolList_gamma0(2, 4); syms Manin Symbol List of weight 4 for Gamma0(2) sage: modS_relations(syms) set([((3, -1), (4, 1)), ((5, -1), (5, 1)), ((1, 1), (6, 1)), ((0, 1), (7, 1)), ((3, 1), (4, -1)), ((2, 1), (8, 1))])
sage: syms = ManinSymbolList_gamma0(7, 2); syms Manin Symbol List of weight 2 for Gamma0(7) sage: modS_relations(syms) set([((3, 1), (4, 1)), ((2, 1), (7, 1)), ((5, 1), (6, 1)), ((0, 1), (1, 1))])
Next we do an example with Gamma1:
sage: from manin_symbols import ManinSymbolList_gamma1 sage: syms = ManinSymbolList_gamma1(3,2); syms Manin Symbol List of weight 2 for Gamma1(3) sage: modS_relations(syms) set([((3, 1), (6, 1)), ((0, 1), (5, 1)), ((0, 1), (2, 1)), ((3, 1), (4, 1)), ((6, 1), (7, 1)), ((1, 1), (2, 1)), ((1, 1), (5, 1)), ((4, 1), (7, 1))])
rels, n, F) |
Performs Sparse Gauss elimination on a matrix all of whose columns have at most 2 nonzero entries. We use an obvious algorithm, whichs runs fast enough. (Typically making the list of relations takes more time than computing this quotient.) This algorithm is more subtle than just ``identify symbols in pairs'', since complicated relations can cause generators to surprisingly equal 0.
INPUT: rels -- set of pairs ((i,s), (j,t)). The pair represents the relation s*x_i + t*x_j = 0. n -- int, the x_i are x_0, ..., x_{n-1}. F -- base field OUTPUT: mod -- list such that mod[i] = (j,s), which means that x_i is equivalent to s*x_j, where the x_j are a basis for the quotient.
EXAMPLE: We quotient out by the relations
to get
sage: Q = rings.RationalField() sage: rels = set([((0,3), (1,-1)), ((1,1), (3,1)), ((2,1),(3,1)), ((4,1),(5,-1))]) sage: n = 6 sage: sparse_2term_quotient(rels, n, Q) [(3, -1/3), (3, -1), (3, -1), (3, 1), (5, 1), (5, 1)]
list, field, [sign=0]) |
Create the sparse relation matrix over
for Manin symbols of
weight 2 on
, with given sign.
INPUT: list -- sage.modular.modsym.p1list.List OUTPUT: A -- a sage.linalg.sparse_matrix.SparseMatrix that gives the 2-term and 3-term relations between Manin symbols.
MORE DETAILS: 1. Create an empty sparse matrix.
2. Let S = [0,-1; 1,0], T = [0,-1; 1,-1], I = [-1,0; 0,1]
3. Enter the T relations:
Remove x and x*T from reps to consider.
4. If sign =/= 0, enter the I relations:
5. Enter the S relations in the matrix:
by putting 1s at cols corresponding to
M, field, [sign=0]) |
Create the sparse relation matrix over
for Manin symbols of
given weight on
, with given sign.
INPUT: M -- manin_symbols.ManinSymbolList field -- base field weight -- the weight, an integer > 2 sign -- element of [-1,0,1] OUTPUT: A -- a SparseMatrix that gives the 2-term and 3-term relations between Manin symbols.
MORE DETAILS: 1. Create an empty sparse matrix.
2. Let S = [0,-1; 1,0], T = [0,-1; 1,-1], I = [-1,0; 0,1]
3. Enter the T relations: x + x*T = 0 Remove x and x*T from reps to consider.
4. If sign =/= 0, enter the I relations: x + sign*x*I = 0.
5. Enter the S relations in the matrix:
by putting 1s at cols corresponding to
See About this document... for information on suggesting changes.