Ticket #6911: 6911-hecke-basis-disc.patch

sage/matrix/matrix2.pyx

@@ -1325 +1325 @@
         for i from 0 <= i < self._nrows:
             s = s + self.get_unsafe(i,i)
         return s
+    
+    def trace_of_product(self, Matrix other):
+        """
+        Returns the trace of self * other without computing the entire product.
+        
+        EXAMPLES::
+            
+            sage: M = random_matrix(ZZ, 10, 20)
+            sage: N = random_matrix(ZZ, 20, 10)
+            sage: M.trace_of_product(N)
+            -1629
+            sage: (M*N).trace()
+            -1629
+        """
+        if self._nrows != other._ncols or other._nrows != self._ncols:
+            raise ArithmeticError, "incompatible dimensions"
+        s = self._base_ring(0)
+        for i from 0 <= i < self._nrows:
+            for j from 0 <= j < self._ncols:
+                s += self.get_unsafe(i, j) * other.get_unsafe(j, i)
+        return s
 
     #####################################################################################
     # Generic Hessenberg Form and charpoly algorithm

sage/modular/hecke/algebra.py

@@ -31 +31 @@
 import math
 import weakref
 
-import sage.rings.all as rings
 import sage.rings.arith as arith
 import sage.rings.infinity
 import sage.misc.latex as latex
@@ -43 +42 @@
 from sage.matrix.constructor import matrix
 from sage.rings.arith import lcm
 from sage.matrix.matrix_space import MatrixSpace
+from sage.rings.all import ZZ, QQ
 
 def is_HeckeAlgebra(x):
     r"""
@@ -168 +168 @@
         [0 1]
         [0 5]]
     """
-    QQ = rings.QQ
-    ZZ = rings.ZZ
     d = M.rank()
     VV = QQ**(d**2)
     WW = ZZ**(d**2)
@@ -217 +215 @@
         [0 1]
         [0 5]]
     """
-    QQ = rings.QQ
-    ZZ = rings.ZZ
     d = M.rank()
     VV = QQ**(d**2)
     WW = ZZ**(d**2)
@@ -520 +516 @@
         try:
             return self.__basis_cache
         except AttributeError:
-            self.__basis_cache=_heckebasis(self.__M)
+            pass
+        level = self.level()
+        bound = self.__M.hecke_bound()
+        dim = self.__M.rank()
+        span = [self.hecke_operator(n) for n in range(2, bound+1) if not self.is_anemic() or gcd(n, level) == 1]
+        rand_max = 5
+        while True:
+            # Project the full Hecke module to a random submodule to ease the HNF reduction.
+            v = (ZZ**dim).random_element(x=rand_max)
+            proj_span = matrix([T.matrix()*v for T in span])._clear_denom()[0]
+            proj_basis = proj_span.hermite_form()
+            if proj_basis[dim-1] == 0:
+                # We got unlucky, choose another projection.
+                rand_max *= 2
+                continue
+            # Lift the projected basis to a basis in the Hecke algebra.
+            trans = proj_span.solve_left(proj_basis)
+            self.__basis_cache = [sum(c*T for c,T in zip(row,span) if c != 0) for row in trans[:dim]]
             return self.__basis_cache
 
     def discriminant(self):
@@ -535 +548 @@
         *Conjectures about discriminants of Hecke algebras of prime
         level*, Springer LNCS 3076.
         
-        Not implemented at present.
-        
         EXAMPLE::
 
             sage: BrandtModule(3, 4).hecke_algebra().discriminant()
-            Traceback (most recent call last):
-            ...
-            NotImplementedError
+            1
+            sage: ModularSymbols(65, sign=1).cuspidal_submodule().hecke_algebra().discriminant()
+            6144
         """
-        raise NotImplementedError
+        try:
+            return self.__disc
+        except AttributeError:
+            pass
+        basis = self.basis()
+        d = len(self.basis())
+        trace_matrix = matrix(ZZ, d)
+        for i in range(d):
+            for j in range(i+1):
+                trace_matrix[i,j] = trace_matrix[j,i] = basis[i].matrix().trace_of_product(basis[j].matrix())
+        self.__disc = trace_matrix.det()
+        return self.__disc
 
     def gens(self):
         r"""

sage/modular/hecke/ambient_module.py

@@ -477 +477 @@
         generate the full Hecke algebra as a module over the base ring. Note
         that we include the `n` with `n` not coprime to the level.
 
-        At present this returns an unproven guess which appears to be valid for
-        `M_k(\Gamma_0(N))`, where k and N are the weight and level of self. (It
-        is clearly valid for *cuspidal* spaces of any fixed character, as a
-        consequence of the Sturm bound theorem.) It returns a hopelessly wrong
-        answer for spaces of full level `\Gamma_1`.
+        At present this returns an unproven guess for non-cuspidal spaces which
+        appears to be valid for `M_k(\Gamma_0(N))`, where k and N are the
+        weight and level of self. (It is clearly valid for *cuspidal* spaces
+        of any fixed character, as a consequence of the Sturm bound theorem.)
+        It returns a hopelessly wrong answer for spaces of full level
+        `\Gamma_1`.
 
         TODO: Get rid of this dreadful bit of code.
 
@@ -492 +493 @@
             sage: ModularSymbols(Gamma1(17), 4).hecke_bound() # wrong!
             15
         """
-        misc.verbose("WARNING: ambient.py -- hecke_bound; returning unproven guess.")
-        return Gamma0(self.level()).sturm_bound(self.weight()) + 2*Gamma0(self.level()).dimension_eis(self.weight()) + 5
+        if self.is_cuspidal():
+            return Gamma0(self.level()).sturm_bound(self.weight())
+        else:
+            misc.verbose("WARNING: ambient.py -- hecke_bound; returning unproven guess.")
+            return Gamma0(self.level()).sturm_bound(self.weight()) + 2*Gamma0(self.level()).dimension_eis(self.weight()) + 5
 
     def hecke_module_of_level(self, level):
         r"""

sage/modular/quatalg/brandt.py

@@ -1176 +1176 @@
             V = A.kernel()
         self.__eisenstein_subspace = V
         return V
+    
+    def is_cuspidal(self):
+        r"""
+        Returns whether self is cuspidal, i.e. has no eisenstein part.
+        
+        EXAMPLES:
+            sage: B = BrandtModule(3, 4)
+            sage: B.is_cuspidal()
+            False
+            sage: B.eisenstein_subspace()
+            Brandt module of dimension 1 of level 3*4 of weight 2 over Rational Field
+        """
+        return self.eisenstein_subspace().dimension() == 0
 
     def monodromy_weights(self):
         r"""