Fixed a bug introduced when trying to reduce the calls to word_rep.

Author: mmasdeu

README.rst

@@ -79,18 +79,6 @@ This returns something like::
 
 3) A curve over a cubic field of mixed signature::
 
-     sage: F.<r> = NumberField(x^3-x^2-x+2)
-     sage: N = F.ideal(r^2 + 2)
-     sage: P = N.factor()[0][0]
-     sage: D = N/P
-     sage: find_curve(P,D,N,20)
-
-which returns::
-
-  y^2 + x*y + y = x^3 + (r^2-2)*x^2 + (r^2-2)*x + (-r^2-r)
-
-4) Another (more spectacular) curve over a cubic field of mixed signature::
-
      sage: F.<r> = NumberField(x^3 -3)
      sage: P = F.ideal(r-2)
      sage: D = F.ideal(r-1)

arithgroup.py

@@ -109,10 +109,14 @@ def one(self):
     def _element_constructor_(self,x):
         if isinstance(x,list):
             return self.element_class(self, word_rep = x,check = False)
-        elif x.parent() is self.quaternion_algebra():
-            return self.element_class(self, quaternion_rep = x,check = False)
         elif isinstance(x, self.element_class):
-            if not x.has_word_rep:
+            if x.parent() is self:
+                if x.has_word_rep:
+                    word_rep = x.word_rep
+                else:
+                    word_rep = None
+                return self.element_class(self, quaternion_rep = x.quaternion_rep, word_rep = word_rep, check = False)
+            elif not x.has_word_rep:
                 return self.element_class(self, quaternion_rep = x.quaternion_rep, word_rep = None, check = False)
             else:
                 word_rep = []
@@ -121,7 +125,7 @@ def _element_constructor_(self,x):
                     if a > 0:
                         word_rep += self.get_word_rep(Gx.gen(i).quaternion_rep) * a
                     else:
-                        word_rep += self.get_word_rep(Gx.gen(i).quaternion_rep**-1) * (-a)
+                        word_rep += [(i,-b) for i,b in reversed(self.get_word_rep(Gx.gen(i).quaternion_rep))] * (-a)
                 ans = self.element_class(self, quaternion_rep = x.quaternion_rep, word_rep = word_rep, check = False)
                 return ans
         elif isinstance(x.parent(),FreeModule_generic):
@@ -272,14 +276,13 @@ def get_hecke_ti(self,gk1,gamma,l,use_magma):
         - t_{gk1}(gamma)
 
         """
-        elt = gk1**-1 * gamma
+        elt = gk1**-1 * gamma.quaternion_rep
         reps = self.get_hecke_reps(l,use_magma = use_magma)
         for gk2 in reps:
             ti = elt * gk2
             is_in_order = self._is_in_order(ti)
             if self._is_in_order(ti):
-                ans = self(ti)
-                return ans
+                return self(ti)
         verbose("ti not found. gk1 = %s, gamma = %s, l = %s"%(gk1,gamma,l))
         raise RuntimeError("ti not found. gk1 = %s, gamma = %s, l = %s"%(gk1,gamma,l))
 
@@ -297,7 +300,7 @@ def get_Up_ti(self,gk1,gamma):
         - t_{gk1}(gamma)
 
         """
-        elt = gk1**-1 * gamma
+        elt = gk1**-1 * gamma.quaternion_rep
         reps = self.get_Up_reps()
         for gk2 in reps:
             ti = elt * gk2
@@ -321,7 +324,7 @@ def hecke_matrix(self,l,use_magma = True,g0 = None):
         V = QQ**len(gens)
         for j,g in enumerate(gens):
             # Construct column j of the matrix
-            newcol = sum([V(list(Gab.G_to_ab(self.get_hecke_ti(gk1,Gab.ab_to_G(g).quaternion_rep,l,use_magma)))) for gk1 in hecke_reps],V(0))
+            newcol = sum([V(list(Gab.G_to_ab(self.get_hecke_ti(gk1,Gab.ab_to_G(g),l,use_magma)))) for gk1 in hecke_reps],V(0))
             M.set_column(j,list(newcol))
         return M
 
@@ -335,7 +338,7 @@ def hecke_matrix_freepart(self,l,use_magma = True,g0 = None):
         V = QQ**len(freegens)
         for j,g in enumerate(freegens):
             # Construct column j of the matrix
-            glift = Gab.ab_to_G(g).quaternion_rep
+            glift = Gab.ab_to_G(g)
             newcol = list(Gab.G_to_ab_free(prod([self.get_hecke_ti(gk1,glift,l,use_magma) for gk1 in hecke_reps],self.one())))
             M.set_column(j,newcol)
         return M
@@ -350,8 +353,7 @@ def involution_at_infinity_matrix_freepart(self,use_magma = True):
         V = QQ**len(freegens)
         for j,g in enumerate(freegens):
             # Construct column j of the matrix
-            glift = Gab.ab_to_G(g).quaternion_rep
-            newg = self(x**-1 * glift * x)
+            newg = Gab.ab_to_G(g).conjugate_by(x)
             M.set_column(j,list(Gab.G_to_ab_free(newg)))
         return M
 
@@ -959,7 +961,7 @@ def get_word_rep(self,delta):
         ans = list(self._Gamma0_farey.word_problem(SL2Z(delta.list()),output = 'standard'))
         tmp = self.B(1)
         for i,a in shorten_word(ans):
-            tmp = tmp * self.gen(i).quaternion_rep**a
+            tmp *= self.gen(i).quaternion_rep**a
         delta = SL2Z(delta.list())
         err = SL2Z(delta * SL2Z(tmp**-1))
         I = SL2Z([1,0,0,1])

arithgroup_element.py

@@ -38,7 +38,6 @@ def __init__(self,parent, word_rep = None, quaternion_rep = None, check = False)
             an element of the quaternion algebra ``self.parent().quaternion_algebra()``
         '''
         MultiplicativeGroupElement.__init__(self, parent)
-        # check = True #DEBUG
         init_data = False
         self.has_word_rep = False
         self.has_quaternion_rep = False
@@ -68,14 +67,11 @@ def __init__(self,parent, word_rep = None, quaternion_rep = None, check = False)
             init_data = True
         if init_data is False:
             raise ValueError('Must pass either quaternion_rep or word_rep')
-        # assert self.has_quaternion_rep
-        # if not self.has_word_rep:
-        #     self.word_rep = self._word_rep()
         self._reduce_word()
 
     @cached_method
     def __hash__(self):
-        return self.quaternion_rep.__hash__()
+        return hash((hash(self.parent()), hash(self.quaternion_rep)))
 
     def _repr_(self):
         return str(self.quaternion_rep)
@@ -181,6 +177,7 @@ def __getitem__(self,n):
 
     @cached_method
     def embed(self,prec):
+        assert self.has_quaternion_rep
         return self.parent().embed(self.quaternion_rep,prec)
 
     def conjugate_by(self, wp):

cohomology.py

@@ -243,20 +243,18 @@ def _evaluate_syllable(self,g,a):
         V = self.parent().coefficient_module()
         prec = V.precision_cap()
         Sigma0 = self.parent().Sigma0()
-        #G._evaluate_stats[ZZ(a).abs()] += 1
         if a == 1:
             return self._val[g]
         elif a == 0:
             return V(0)
         elif a == -1:
-            # gmat_inv = G.embed(G.gen(g).quaternion_rep**-1,prec)
             gmat_inv = G.gen(g).embed(prec).adjoint() # G.gen(g).embed(prec)**-1
             if self.parent()._use_ps_dists:
                 return -(Sigma0(gmat_inv) * self._val[g])
             else:
                 return  -self._val[g].l_act_by(gmat_inv)
         elif a < 0:
-            gmat = G.gen(g).embed(prec) # G.embed(G.gen(g).quaternion_rep,prec)
+            gmat = G.gen(g).embed(prec)
             gmat_inv = gmat.adjoint() #gmat**-1
             phig = self._val[g]
             tmp = V(phig)
@@ -269,7 +267,7 @@ def _evaluate_syllable(self,g,a):
                     tmp = phig + tmp.l_act_by(gmat)
                 return -(tmp.l_act_by(gmat_inv**-a))
         else:
-            gmat = G.gen(g).embed(prec) #G.embed(G.gen(g).quaternion_rep,prec)
+            gmat = G.gen(g).embed(prec)
             phig = self._val[g]
             tmp = V(phig)
             if self.parent()._use_ps_dists:
@@ -590,7 +588,7 @@ def involution_at_infinity_matrix(self):
         assert len(self.gens()) == len(Gab.free_gens())
         for j,g0 in enumerate(Gab.free_gens()):
             # Construct column j of the matrix
-            g = Gpn(x**-1 * Gab.ab_to_G(g0).quaternion_rep * x)
+            g = Gab.ab_to_G(g0).conjugate_by(x)
             M.set_column(j,list(Gab.G_to_ab_free(g)))
         return M.transpose()
 
@@ -942,7 +940,7 @@ def apply_hecke_operator(self,c,l, hecke_reps = None,group = None,scale = 1,use_
         input_vector = []
         # verbose('Calculating action')
         for j,gamma in enumerate(gammas):
-            input_vector.extend([(group,g,gamma.quaternion_rep,c,l,hecke_reps,padic,S0(Gpn.embed(g,prec)),self._use_ps_dists,use_magma,j) for g in hecke_reps])
+            input_vector.extend([(group,g,gamma,c,l,hecke_reps,padic,S0(Gpn.embed(g,prec)),self._use_ps_dists,use_magma,j) for g in hecke_reps])
         if parallelize:
             f = parallel(_calculate_hecke_contribution)
             for inp,outp in f(input_vector):
@@ -1000,7 +998,7 @@ def apply_Up(self,c,group = None,scale = 1,parallelize = False,times = 0,progres
             vals = [V(0) for gamma in gammas]
             input_vector = []
             for j,gamma in enumerate(gammas):
-                input_vector.extend([(group,g,gamma.quaternion_rep,c,repslocal[k],self._use_ps_dists,j) for k,g in enumerate(Up_reps)])
+                input_vector.extend([(group,g,gamma,c,repslocal[k],self._use_ps_dists,j) for k,g in enumerate(Up_reps)])
             if parallelize:
                 f = parallel(_calculate_Up_contribution)
                 for inp,outp in f(input_vector):
@@ -1028,8 +1026,7 @@ def apply_Up(self,c,group = None,scale = 1,parallelize = False,times = 0,progres
             counter = 0
             iS = 0
             for i,gi in enumerate(self.group().gens()):
-                giquat = gi.quaternion_rep
-                ti = [tuple(self.group().get_Up_ti(sk,giquat).word_rep) for sk in Up_reps]
+                ti = [tuple(self.group().get_Up_ti(sk,gi).word_rep) for sk in Up_reps]
                 jS = 0
                 for ans in find_newans(self,repslocal,ti):
                     A.set_block(iS,jS,ans)

findcurve.sage

@@ -21,17 +21,8 @@ def find_curve(P, DB, NE, prec, sign_ap = 1, magma = None, return_all = False, i
     sage: D = F.ideal(3)
     sage: find_curve(P,D,P*D,30,ramification_at_infinity = F.real_places()[:1])
 
-
     Now over a cubic of mixed signature::
 
-    sage: F.<r> = NumberField(x^3-x^2-x+2)
-    sage: N = F.ideal(r^2 + 2)
-    sage: P = N.factor()[0][0]
-    sage: D = N/P
-    sage: find_curve(P,D,N,20)
-
-    And another one::
-
     sage: F.<r> = NumberField(x^3 -3)
     sage: P = F.ideal(r-2)
     sage: D = F.ideal(r-1)

homology.py

@@ -326,7 +326,7 @@ def _call_(self,g,v):
                 return v.parent()(v)
         prec = K.precision_cap()
         G = g.parent()
-        a,b,c,d = [K(o) for o in G.embed(g.quaternion_rep,prec).list()] #G.embed(g.quaternion_rep,prec).change_ring(K).list()
+        a,b,c,d = [K(o) for o in G.embed(g.quaternion_rep,prec).list()]
         newdict = defaultdict(ZZ)
         newpts = {}
         for P,n in v:
@@ -494,17 +494,16 @@ def factor_into_generators(self,prec):
             newv = v
             for i,a in gword:
                 g = G.gen(i)
-                gq = g.quaternion_rep
                 oldv = newv
-                newv = oldv.left_act_by_matrix(G.embed(gq**-a,prec))
+                newv = g**-a * oldv
                 sign = 1
                 if a < 0:
                     a = -a
-                    oldv = oldv.left_act_by_matrix(G.embed(gq**a,prec))
+                    oldv = g**a * oldv
                     sign = -1
                 for j in range(a):
                     newdict[g] += sign * oldv
-                    oldv = oldv.left_act_by_matrix(G.embed(gq**-1,prec))
+                    oldv = g**-1 * oldv
                 if a > 0:
                     assert oldv == newv
         return HomologyClass(self.parent(),newdict)
@@ -537,7 +536,7 @@ def act_by_hecke(self,l,prec,g0 = None):
         hecke_reps = G.get_hecke_reps(l,g0 = g0)
         for gk1 in hecke_reps:
             for g,v in self._data.iteritems():
-                ti = G.get_hecke_ti(gk1,g.quaternion_rep,l,True)
+                ti = G.get_hecke_ti(gk1,g,l,True)
                 gk1inv = gk1**-1
                 set_immutable(gk1inv)
                 newv = v.left_act_by_matrix(G.embed(gk1inv,prec))

homology_abstract.py

@@ -100,7 +100,7 @@ def act_by_hecke(self,l,prec):
         hecke_reps = G.get_hecke_reps(l)
         for gk1 in hecke_reps:
             for g,v in self._data.iteritems():
-                ti = G.get_hecke_ti(gk1,g.quaternion_rep,l,hecke_reps)
+                ti = G.get_hecke_ti(gk1,g,l,hecke_reps)
                 newv = v.left_act_by_matrix(G.embed(gk1**-1,prec))
                 try:
                     newdict[ti] += newv

integrals.py

@@ -161,15 +161,12 @@ def integrate_H1(G,cycle,cocycle,depth = 1,method = 'moments',prec = None,parall
     resadd = Cp(0)
     for g,divisor in cycle.get_data():
         jj += 1
-        gq = g.quaternion_rep
         if divisor.degree() != 0:
-            verbose('Divisor must be of degree 0. Now it is of degree %s. And g = %s.'%(divisor.degree(),gq))
-            continue
-            raise ValueError('Divisor must be of degree 0. Now it is of degree %s. And g = %s.'%(divisor.degree(),gq))
+            raise ValueError('Divisor must be of degree 0. Now it is of degree %s. And g = %s.'%(divisor.degree(),g.quaternion_rep))
         if twist:
             divisor = divisor.left_act_by_matrix(G.embed(G.wp(),prec).change_ring(Cp))
-            gq = G.wp() * gq * G.wp()**-1
-        newres,newresadd = integrate_H0(G,divisor,cocycle,depth,gq,prec,jj,total_integrals,progress_bar,parallelize,multiplicative)
+            g = g.conjugate_by(G.wp()**-1)
+        newres,newresadd = integrate_H0(G,divisor,cocycle,depth,g,prec,jj,total_integrals,progress_bar,parallelize,multiplicative)
         res *= newres
         resadd += newresadd
     if not multiplicative:
@@ -262,7 +259,7 @@ def integrate_H0_riemann(G,divisor,hc,depth,gamma,prec,counter,total_counter,pro
     R = PolynomialRing(K,names = 't').fraction_field()
     t = R.gen()
     phi = prod([(t - P)**ZZ(n) for P,n in divisor],R(1))
-    return riemann_sum(G,phi,hc.shapiro_image(G)(gamma),depth,mult = multiplicative)
+    return riemann_sum(G,phi,hc.shapiro_image(G)(gamma.quaternion_rep),depth,mult = multiplicative)
 
 def integrate_H0_moments(G,divisor,hc,depth,gamma,prec,counter,total_counter,progress_bar,parallelize,multiplicative):
     # verbose('Integral %s/%s...'%(counter,total_counter))
@@ -310,13 +307,9 @@ def integrate_H0_moments(G,divisor,hc,depth,gamma,prec,counter,total_counter,pro
                 newedgelist.extend([(parity,o,wt/QQ(p**2)) for o in G.subdivide([edge],parity,2)])
                 continue
             if not rev:
-                newgamma = G.reduce_in_amalgam(h * gamma)
+                newgamma = G.reduce_in_amalgam(h * gamma.quaternion_rep)
             else:
-                newgamma = G.wp()**-1 * G.reduce_in_amalgam(h * gamma) * G.wp()
-            try:
-                newgamma.set_immutable()
-            except AttributeError:
-                pass
+                newgamma = G.reduce_in_amalgam(h * gamma.quaternion_rep).conjugate_by(G.wp())
             if HOC._use_ps_dists:
                 mu_e = hc.evaluate(newgamma,parallelize)
                 resadd += sum(a*mu_e.moment(i) for a,i in izip(pol.coefficients(),pol.exponents()) if i < len(mu_e._moments))