Ticket #6635: trac_6635.patch

sage/modular/hecke/algebra.py

@@ -493 +493 @@
         return self.__M.hecke_matrix(n)
 
 
+    def _basis_over_QQ(self, ops, r, integral=False, bound=10):
+        """
+        
+        """
+        assert len(ops) >= r, "len of ops must be at least r"
+
+        from sage.rings.all import ZZ, QQ
+        from random import randrange
+        from sage.modules.all import span, vector
+        from sage.matrix.all import matrix
+
+        
+        if r == 0:
+            return [], matrix(QQ,0,0), vector(QQ,0)
+
+        tm = verbose("Computing Hecke matrices...")
+        M = self.module()
+        if integral:
+            T = [M.integral_hecke_matrix(k) for k in ops]
+        else:
+            T = [self.hecke_operator(k).matrix() for k in ops]            
+        verbose("Done computing all Hecke matrices", tm)
+        n = M.rank()
+        v = vector(QQ, [ZZ.random_element(-bound,bound) for _ in range(n)])
+        while True:
+            tm = verbose("Computing images of random vector...")
+            # Apply Hecke operators to v
+            Z  = matrix([v*t for t in T])
+            tm = verbose("Done computing the images", tm)
+            
+            p    = ZZ(randrange(1000,20000)).next_prime()
+            Z, d = Z._clear_denom()
+            Zmod = Z._reduce(p)
+            rr   = Zmod.rank()
+            verbose("Got rank (mod %s) = %s"%(p,rr),tm)
+            
+            assert rr <= r, "bug in _basis_over_QQ, since we must have rr <= r"
+            if rr >= r: break
+            
+            # Change 1 random entry, and try again
+            v[randrange(n)] += ZZ.random_element()
+        # end while
+        
+        return Zmod.transpose().pivots(), Z, d*v
+
+    def _discriminant(self, ops, r):
+        r"""
+        Return the discriminant of this Hecke algebra, assuming it is
+        generated over ZZ by the Hecke operators `T_n` with `n` in ops
+        and that the rank of this Hecke algebra is `r` as a
+        `\ZZ`-module.
+
+        INPUT:
+
+            - ``ops`` -- list of positive integers
+
+            - ``r`` -- nonnegative integer (the rank)
+        """
+        from sage.rings.all import ZZ, QQ
+        from sage.matrix.all import matrix
+        from random import randrange
+
+        F, A, _ = self._basis_over_QQ(ops, r)
+        tm = verbose("start computing ZZ module...")
+        d1 = A.row_module(ZZ).basis_matrix().determinant()
+        verbose('done!', tm)
+        d2 = A.matrix_from_rows(F).determinant()
+        T = [self.hecke_matrix(ops[n]) for n in F]
+
+        m = len(F)
+        B = matrix(QQ, m)
+        for i in range(m):
+            for j in range(i,m):
+                tr = (T[i]*T[j]).trace()
+                B[i,j] = tr
+                if i != j:
+                    B[j,i] = tr
+        d3 = B.determinant()
+
+        return ZZ(d3 / (d2/d1)**2)
+
+    def _index_in_saturation_naive(self, ops, r):
+        from sage.rings.all import ZZ
+        from sage.modules.all import span
+
+        M = self.module()
+        V = ZZ**(M.rank()**2)
+        T = [V(M.integral_hecke_matrix(n).list()) for n in ops]
+        S = span(T,ZZ)
+        return S.index_in_saturation()
+
+    def _index_in_saturation(self, ops, r, bound=10):
+        from sage.rings.all import ZZ, QQ
+        from sage.matrix.all import matrix
+        from sage.modules.all import span
+        from random import randrange
+
+        M = self.module()
+        T = [M.integral_hecke_matrix(k) for k in ops]
+        W = None
+        F = None
+        while True:
+            F0, A, v = self._basis_over_QQ(ops, r, integral=True, bound=bound)
+            if F is not None and F0 != F:
+                continue
+            F = F0
+            tm = verbose("start computing ZZ module...")
+            B = A.row_module(ZZ)
+            X = B.span_of_basis(A.matrix_from_rows(F).rows())
+            C = B.saturation()
+            Q = C/B
+            if len(Q.gens()) == 0:
+                # easy special case
+                return (ZZ**len(F))/(ZZ**len(F))
+            fail = False
+            W0 = span([X.coordinate_vector(g.lift()) for g in Q.gens()], ZZ) + ZZ**r
+            if W is None:
+                W = W0
+            else:
+                W = W.intersection(W0)
+            Z = []
+            for z in W.basis():
+                a = sum([z[i]*T[F[i]] for i in range(len(z))])
+                if a.denominator() != 1:
+                    fail = True
+                    break
+                Z.append(a)
+            if not fail:
+                S = span([v*a for a in Z], ZZ)
+                return (S+B) / B
+
+
 class HeckeAlgebra_full(HeckeAlgebra_base):
     r"""
     A full Hecke algebra (including the operators `T_n` where `n` is not

sage/modular/modsym/space.py

@@ -1598 +1598 @@
             self.__integral_hecke_matrix = {}
         except KeyError:
             pass
-        #raise NotImplementedError, "code past this point is broken / not done"  # todo
-        A = self.ambient_hecke_module()
-        T = A.hecke_matrix(n)
-        S = T.restrict(self.integral_structure()).change_ring(ZZ)
+        
+        # The following is a very common special case:
+        if self.module().basis_matrix() == self.integral_structure().basis_matrix():
+            S = self.hecke_matrix(n)
+        else:
+            A = self.ambient_hecke_module()
+            T = A.hecke_matrix(n)
+            S = T.restrict(self.integral_structure()).change_ring(ZZ)
         self.__integral_hecke_matrix[n] = S
         return S