def __call__(self, Q, P): from sage.rings.all import ZZ, QQ from sage.misc.all import sage_eval s, Q, P = self.raw(Q, P) raw = s if 'the prime to 2 part of the conductor' in s: prime_to_2_conductor_only = True else: prime_to_2_conductor_only = False x = QQ['x'].gen(0) i = s.find('y^2 = ') + len('y^2 = ') j = i + s[i:].find('\n') minimal_equation = sage_eval(s[i:j], locals={'x': x}) s = s[j + 1:] i = s.find('[') j = s.find(']') minimal_disc = ZZ(eval(s[i + 1:j].replace(',', '**').replace(';', '*'))) phrase = 'the conductor is ' j = s.find(phrase) assert j != -1 k = s[j:].find('\n') prime_to_2_conductor = ZZ(s[j + len(phrase):j + k]) local_data = {} while True: i = s.find('p=') if i == -1: break j = s[i + 2:].find('p=') if j == -1: j = s.find('\n \n') assert j != -1 else: j = j + (i + 2) k = i + s[i:].find('\n') p = ZZ(s[i + 2:k]) data = s[k + 1:j].strip().replace(' : ', ': ') local_data[p] = data s = s[j:] return ReductionData(raw, P, Q, minimal_equation, minimal_disc, local_data, prime_to_2_conductor, prime_to_2_conductor_only)
def __call__(self, Q, P): from sage.rings.all import ZZ, QQ from sage.misc.all import sage_eval s, Q, P = self.raw(Q, P) raw = s if 'the prime to 2 part of the conductor' in s: prime_to_2_conductor_only = True else: prime_to_2_conductor_only = False x = QQ['x'].gen(0) i = s.find('y^2 = ') + len('y^2 = ') j = i + s[i:].find('\n') minimal_equation = sage_eval(s[i:j], locals={'x':x}) s = s[j+1:] i = s.find('[') j = s.find(']') minimal_disc = ZZ(eval(s[i+1:j].replace(',','**').replace(';','*'))) phrase = 'the conductor is ' j = s.find(phrase) assert j != -1 k = s[j:].find('\n') prime_to_2_conductor = ZZ(s[j+len(phrase):j+k]) local_data = {} while True: i = s.find('p=') if i == -1: break j = s[i+2:].find('p=') if j == -1: j = s.find('\n \n') assert j != -1 else: j = j + (i+2) k = i + s[i:].find('\n') p = ZZ(s[i+2:k]) data = s[k+1:j].strip().replace(' : ',': ') local_data[p] = data s = s[j:] return ReductionData(raw, P, Q, minimal_equation, minimal_disc, local_data, prime_to_2_conductor, prime_to_2_conductor_only)
def __call__(self, Q, P): from sage.rings.all import ZZ, QQ from sage.misc.all import sage_eval s, Q, P = self.raw(Q, P) raw = s if "the prime to 2 part of the conductor" in s: prime_to_2_conductor_only = True else: prime_to_2_conductor_only = False x = QQ["x"].gen(0) i = s.find("y^2 = ") + len("y^2 = ") j = i + s[i:].find("\n") minimal_equation = sage_eval(s[i:j], locals={"x": x}) s = s[j + 1 :] i = s.find("[") j = s.find("]") minimal_disc = ZZ(eval(s[i + 1 : j].replace(",", "**").replace(";", "*"))) phrase = "the conductor is " j = s.find(phrase) assert j != -1 k = s[j:].find("\n") prime_to_2_conductor = ZZ(s[j + len(phrase) : j + k]) local_data = {} while True: i = s.find("p=") if i == -1: break j = s[i + 2 :].find("p=") if j == -1: j = s.find("\n \n") assert j != -1 else: j = j + (i + 2) k = i + s[i:].find("\n") p = ZZ(s[i + 2 : k]) data = s[k + 1 : j].strip().replace(" : ", ": ") local_data[p] = data s = s[j:] return ReductionData( raw, P, Q, minimal_equation, minimal_disc, local_data, prime_to_2_conductor, prime_to_2_conductor_only )
def buzzard_tpslopes(p, N, kmax): """ Returns a vector of length kmax, whose `k`'th entry (`0 \leq k \leq k_{max}`) is the conjectural sequence of valuations of eigenvalues of `T_p` on forms of level `N`, weight `k`, and trivial character. This conjecture is due to Kevin Buzzard, and is only made assuming that `p` does not divide `N` and if `p` is `\Gamma_0(N)`-regular. EXAMPLES:: sage: c = buzzard_tpslopes(2,1,50) sage: c[50] [4, 8, 13] Hence Buzzard would conjecture that the `2`-adic valuations of the eigenvalues of `T_2` on cusp forms of level 1 and weight `50` are `[4,8,13]`, which indeed they are, as one can verify by an explicit computation using, e.g., modular symbols:: sage: M = ModularSymbols(1,50, sign=1).cuspidal_submodule() sage: T = M.hecke_operator(2) sage: f = T.charpoly('x') sage: f.newton_slopes(2) [13, 8, 4] AUTHORS: - Kevin Buzzard: several PARI/GP scripts - William Stein (2006-03-17): small Sage wrapper of Buzzard's scripts """ v = gp().eval('tpslopes(%s, %s, %s)' % (p, N, kmax)) v = sage_eval(v) v.insert(0, []) # so v[k] = info about weight k (since python is 0-based) return v
def buzzard_tpslopes(p, N, kmax): """ Returns a vector of length kmax, whose `k`'th entry (`0 \leq k \leq k_{max}`) is the conjectural sequence of valuations of eigenvalues of `T_p` on forms of level `N`, weight `k`, and trivial character. This conjecture is due to Kevin Buzzard, and is only made assuming that `p` does not divide `N` and if `p` is `\Gamma_0(N)`-regular. EXAMPLES:: sage: c = buzzard_tpslopes(2,1,50) sage: c[50] [4, 8, 13] Hence Buzzard would conjecture that the `2`-adic valuations of the eigenvalues of `T_2` on cusp forms of level 1 and weight `50` are `[4,8,13]`, which indeed they are, as one can verify by an explicit computation using, e.g., modular symbols:: sage: M = ModularSymbols(1,50, sign=1).cuspidal_submodule() sage: T = M.hecke_operator(2) sage: f = T.charpoly('x') sage: f.newton_slopes(2) [13, 8, 4] AUTHORS: - Kevin Buzzard: several PARI/GP scripts - William Stein (2006-03-17): small Sage wrapper of Buzzard's scripts """ v = gp().eval('tpslopes(%s, %s, %s)'%(p,N,kmax)) v = sage_eval(v) v.insert(0, []) # so v[k] = info about weight k (since python is 0-based) return v
def guess(self, sequence, algorithm='sage'): """ Return the minimal CFiniteSequence that generates the sequence. Assume the first value has index 0. INPUT: - ``sequence`` -- list of integers - ``algorithm`` -- string - 'sage' - the default is to use Sage's matrix kernel function - 'pari' - use Pari's implementation of LLL - 'bm' - use Sage's Berlekamp-Massey algorithm OUTPUT: - a CFiniteSequence, or 0 if none could be found With the default kernel method, trailing zeroes are chopped off before a guessing attempt. This may reduce the data below the accepted length of six values. EXAMPLES:: sage: C.<x> = CFiniteSequences(QQ) sage: C.guess([1,2,4,8,16,32]) C-finite sequence, generated by -1/2/(x - 1/2) sage: r = C.guess([1,2,3,4,5]) Traceback (most recent call last): ... ValueError: Sequence too short for guessing. With Berlekamp-Massey, if an odd number of values is given, the last one is dropped. So with an odd number of values the result may not generate the last value:: sage: r = C.guess([1,2,4,8,9], algorithm='bm'); r C-finite sequence, generated by -1/2/(x - 1/2) sage: r[0:5] [1, 2, 4, 8, 16] """ S = self.polynomial_ring() if algorithm == 'bm': from sage.matrix.berlekamp_massey import berlekamp_massey if len(sequence) < 2: raise ValueError('Sequence too short for guessing.') R = PowerSeriesRing(QQ, 'x') if len(sequence) % 2: sequence.pop() l = len(sequence) - 1 denominator = S(berlekamp_massey(sequence).reverse()) numerator = R(S(sequence) * denominator, prec=l).truncate() return CFiniteSequence(numerator / denominator) elif algorithm == 'pari': global _gp if len(sequence) < 6: raise ValueError('Sequence too short for guessing.') if _gp is None: _gp = Gp() _gp("ggf(v)=local(l,m,p,q,B);l=length(v);B=floor(l/2);\ if(B<3,return(0));m=matrix(B,B,x,y,v[x-y+B+1]);\ q=qflll(m,4)[1];if(length(q)==0,return(0));\ p=sum(k=1,B,x^(k-1)*q[k,1]);\ q=Pol(Pol(vector(l,n,v[l-n+1]))*p+O(x^(B+1)));\ if(polcoeff(p,0)<0,q=-q;p=-p);q=q/p;p=Ser(q+O(x^(l+1)));\ for(m=1,l,if(polcoeff(p,m-1)!=v[m],return(0)));q") _gp.set('gf', sequence) _gp("gf=ggf(gf)") num = S(sage_eval(_gp.eval("Vec(numerator(gf))"))[::-1]) den = S(sage_eval(_gp.eval("Vec(denominator(gf))"))[::-1]) if num == 0: return 0 else: return CFiniteSequence(num / den) else: from sage.matrix.constructor import matrix from sage.functions.other import ceil from numpy import trim_zeros seq = sequence[:] while seq and sequence[-1] == 0: seq.pop() l = len(seq) if l == 0: return 0 if l < 6: raise ValueError('Sequence too short for guessing.') hl = ceil(ZZ(l) / 2) A = matrix([sequence[k:k + hl] for k in range(hl)]) K = A.kernel() if K.dimension() == 0: return 0 R = PolynomialRing(QQ, 'x') den = R(trim_zeros(K.basis()[-1].list()[::-1])) if den == 1: return 0 offset = next((i for i, x in enumerate(sequence) if x), None) S = PowerSeriesRing(QQ, 'x', default_prec=l - offset) num = S(R(sequence) * den).truncate(ZZ(l) // 2 + 1) if num == 0 or sequence != S(num / den).list(): return 0 else: return CFiniteSequence(num / den)
def guess(self, sequence, algorithm="sage"): """ Return the minimal CFiniteSequence that generates the sequence. Assume the first value has index 0. INPUT: - ``sequence`` -- list of integers - ``algorithm`` -- string - 'sage' - the default is to use Sage's matrix kernel function - 'pari' - use Pari's implementation of LLL - 'bm' - use Sage's Berlekamp-Massey algorithm OUTPUT: - a CFiniteSequence, or 0 if none could be found With the default kernel method, trailing zeroes are chopped off before a guessing attempt. This may reduce the data below the accepted length of six values. EXAMPLES:: sage: C.<x> = CFiniteSequences(QQ) sage: C.guess([1,2,4,8,16,32]) C-finite sequence, generated by 1/(-2*x + 1) sage: r = C.guess([1,2,3,4,5]) Traceback (most recent call last): ... ValueError: Sequence too short for guessing. With Berlekamp-Massey, if an odd number of values is given, the last one is dropped. So with an odd number of values the result may not generate the last value:: sage: r = C.guess([1,2,4,8,9], algorithm='bm'); r C-finite sequence, generated by 1/(-2*x + 1) sage: r[0:5] [1, 2, 4, 8, 16] """ S = self.polynomial_ring() if algorithm == "bm": from sage.matrix.berlekamp_massey import berlekamp_massey if len(sequence) < 2: raise ValueError("Sequence too short for guessing.") R = PowerSeriesRing(QQ, "x") if len(sequence) % 2 == 1: sequence = sequence[:-1] l = len(sequence) - 1 denominator = S(berlekamp_massey(sequence).list()[::-1]) numerator = R(S(sequence) * denominator, prec=l).truncate() return CFiniteSequence(numerator / denominator) elif algorithm == "pari": global _gp if len(sequence) < 6: raise ValueError("Sequence too short for guessing.") if _gp is None: _gp = Gp() _gp( "ggf(v)=local(l,m,p,q,B);l=length(v);B=floor(l/2);\ if(B<3,return(0));m=matrix(B,B,x,y,v[x-y+B+1]);\ q=qflll(m,4)[1];if(length(q)==0,return(0));\ p=sum(k=1,B,x^(k-1)*q[k,1]);\ q=Pol(Pol(vector(l,n,v[l-n+1]))*p+O(x^(B+1)));\ if(polcoeff(p,0)<0,q=-q;p=-p);q=q/p;p=Ser(q+O(x^(l+1)));\ for(m=1,l,if(polcoeff(p,m-1)!=v[m],return(0)));q" ) _gp.set("gf", sequence) _gp("gf=ggf(gf)") num = S(sage_eval(_gp.eval("Vec(numerator(gf))"))[::-1]) den = S(sage_eval(_gp.eval("Vec(denominator(gf))"))[::-1]) if num == 0: return 0 else: return CFiniteSequence(num / den) else: from sage.matrix.constructor import matrix from sage.functions.other import floor, ceil from numpy import trim_zeros l = len(sequence) while l > 0 and sequence[l - 1] == 0: l -= 1 sequence = sequence[:l] if l == 0: return 0 if l < 6: raise ValueError("Sequence too short for guessing.") hl = ceil(ZZ(l) / 2) A = matrix([sequence[k : k + hl] for k in range(hl)]) K = A.kernel() if K.dimension() == 0: return 0 R = PolynomialRing(QQ, "x") den = R(trim_zeros(K.basis()[-1].list()[::-1])) if den == 1: return 0 offset = next((i for i, x in enumerate(sequence) if x != 0), None) S = PowerSeriesRing(QQ, "x", default_prec=l - offset) num = S(R(sequence) * den).add_bigoh(floor(ZZ(l) / 2 + 1)).truncate() if num == 0 or sequence != S(num / den).list(): return 0 else: return CFiniteSequence(num / den)
def riemann_roch_basis(self, D): r""" Return a basis for the Riemann-Roch space corresponding to `D`. This uses Singular's Brill-Noether implementation. INPUT: - ``D`` - a divisor OUTPUT: A list of function field elements that form a basis of the Riemann-Roch space EXAMPLE:: sage: R.<x,y,z> = GF(2)[] sage: f = x^3*y + y^3*z + x*z^3 sage: C = Curve(f); pts = C.rational_points() sage: D = C.divisor([ (4, pts[0]), (4, pts[2]) ]) sage: C.riemann_roch_basis(D) [x/y, 1, z/y, z^2/y^2, z/x, z^2/(x*y)] :: sage: R.<x,y,z> = GF(5)[] sage: f = x^7 + y^7 + z^7 sage: C = Curve(f); pts = C.rational_points() sage: D = C.divisor([ (3, pts[0]), (-1,pts[1]), (10, pts[5]) ]) sage: C.riemann_roch_basis(D) [(-2*x + y)/(x + y), (-x + z)/(x + y)] .. NOTE:: Currently this only works over prime field and divisors supported on rational points. """ f = self.defining_polynomial()._singular_() singular = f.parent() singular.lib('brnoeth') try: X1 = f.Adj_div() except (TypeError, RuntimeError) as s: raise RuntimeError(str(s) + "\n\n ** Unable to use the Brill-Noether Singular package to compute all points (see above).") X2 = singular.NSplaces(1, X1) # retrieve list of all computed closed points (possibly of degree >1) v = X2[3].sage_flattened_str_list() # We use sage_flattened_str_list since iterating through # the entire list through the sage/singular interface directly # would involve hundreds of calls to singular, and timing issues with # the expect interface could crop up. Also, this is vastly # faster (and more robust). v = [ v[i].partition(',') for i in range(len(v)) ] pnts = [ ( int(v[i][0]), int(v[i][2])-1 ) for i in range(len(v))] # retrieve coordinates of rational points R = X2[5][1][1] singular.set_ring(R) v = singular('POINTS').sage_flattened_str_list() coords = [self(int(v[3*i]), int(v[3*i+1]), int(v[3*i+2])) for i in range(len(v)//3)] # build correct representation of D for singular Dsupport = D.support() Dcoeffs = [] for x in pnts: if x[0] == 1: Dcoeffs.append(D.coefficient(coords[x[1]])) else: Dcoeffs.append(0) Dstr = str(tuple(Dcoeffs)) G = singular(','.join([str(x) for x in Dcoeffs]), type='intvec') # call singular's brill noether routine and return T = X2[1][2] T.set_ring() LG = G.BrillNoether(X2) LG = [X.split(',\n') for X in LG.sage_structured_str_list()] x,y,z = self.ambient_space().coordinate_ring().gens() vars = {'x':x, 'y':y, 'z':z} V = [(sage_eval(a, vars)/sage_eval(b, vars)) for a, b in LG] return V
def __to_CC(self, s): s = s.replace('.E','.0E').replace(' ','') return self.__CC(sage_eval(s, locals={'I':self.__CC.gen(0)}))
def riemann_roch_basis(self, D): r""" Return a basis for the Riemann-Roch space corresponding to `D`. This uses Singular's Brill-Noether implementation. INPUT: - ``D`` - a divisor OUTPUT: A list of function field elements that form a basis of the Riemann-Roch space EXAMPLE:: sage: R.<x,y,z> = GF(2)[] sage: f = x^3*y + y^3*z + x*z^3 sage: C = Curve(f); pts = C.rational_points() sage: D = C.divisor([ (4, pts[0]), (4, pts[2]) ]) sage: C.riemann_roch_basis(D) [x/y, 1, z/y, z^2/y^2, z/x, z^2/(x*y)] :: sage: R.<x,y,z> = GF(5)[] sage: f = x^7 + y^7 + z^7 sage: C = Curve(f); pts = C.rational_points() sage: D = C.divisor([ (3, pts[0]), (-1,pts[1]), (10, pts[5]) ]) sage: C.riemann_roch_basis(D) [(-2*x + y)/(x + y), (-x + z)/(x + y)] .. NOTE:: Currently this only works over prime field and divisors supported on rational points. """ f = self.defining_polynomial()._singular_() singular = f.parent() singular.lib('brnoeth') try: X1 = f.Adj_div() except (TypeError, RuntimeError) as s: raise RuntimeError( str(s) + "\n\n ** Unable to use the Brill-Noether Singular package to compute all points (see above)." ) X2 = singular.NSplaces(1, X1) # retrieve list of all computed closed points (possibly of degree >1) v = X2[3].sage_flattened_str_list( ) # We use sage_flattened_str_list since iterating through # the entire list through the sage/singular interface directly # would involve hundreds of calls to singular, and timing issues with # the expect interface could crop up. Also, this is vastly # faster (and more robust). v = [v[i].partition(',') for i in range(len(v))] pnts = [(int(v[i][0]), int(v[i][2]) - 1) for i in range(len(v))] # retrieve coordinates of rational points R = X2[5][1][1] singular.set_ring(R) v = singular('POINTS').sage_flattened_str_list() coords = [ self(int(v[3 * i]), int(v[3 * i + 1]), int(v[3 * i + 2])) for i in range(len(v) // 3) ] # build correct representation of D for singular Dsupport = D.support() Dcoeffs = [] for x in pnts: if x[0] == 1: Dcoeffs.append(D.coefficient(coords[x[1]])) else: Dcoeffs.append(0) Dstr = str(tuple(Dcoeffs)) G = singular(','.join([str(x) for x in Dcoeffs]), type='intvec') # call singular's brill noether routine and return T = X2[1][2] T.set_ring() LG = G.BrillNoether(X2) LG = [X.split(',\n') for X in LG.sage_structured_str_list()] x, y, z = self.ambient_space().coordinate_ring().gens() vars = {'x': x, 'y': y, 'z': z} V = [(sage_eval(a, vars) / sage_eval(b, vars)) for a, b in LG] return V
Dcoeffs = [] for x in pnts: if x[0] == 1: Dcoeffs.append(D.coefficient(coords[x[1]])) else: Dcoeffs.append(0) Dstr = str(tuple(Dcoeffs)) G = singular(','.join([str(x) for x in Dcoeffs]), type='intvec') # call singular's brill noether routine and return T = X2[1][2] T.set_ring() LG = G.BrillNoether(X2) LG = [X.split(',\n') for X in LG.sage_structured_str_list()] x,y,z = self.ambient_space().coordinate_ring().gens() vars = {'x':x, 'y':y, 'z':z} V = [(sage_eval(a, vars)/sage_eval(b, vars)) for a, b in LG] return V def rational_points(self, algorithm="enum", sort=True): r""" INPUT: - ``algorithm`` - string: - ``'enum'`` - straightforward enumeration - ``'bn'`` - via Singular's brnoeth package. EXAMPLE::
Dcoeffs = [] for x in pnts: if x[0] == 1: Dcoeffs.append(D.coefficient(coords[x[1]])) else: Dcoeffs.append(0) Dstr = str(tuple(Dcoeffs)) G = singular(','.join([str(x) for x in Dcoeffs]), type='intvec') # call singular's brill noether routine and return T = X2[1][2] T.set_ring() LG = G.BrillNoether(X2) LG = [X.split(',\n') for X in LG.sage_structured_str_list()] x, y, z = self.ambient_space().coordinate_ring().gens() vars = {'x': x, 'y': y, 'z': z} V = [(sage_eval(a, vars) / sage_eval(b, vars)) for a, b in LG] return V def rational_points(self, algorithm="enum", sort=True): r""" INPUT: - ``algorithm`` - string: - ``'enum'`` - straightforward enumeration - ``'bn'`` - via Singular's brnoeth package. EXAMPLE::
def guess(sequence, algorithm='pari'): """ Return the minimal CFiniteSequence that generates the sequence. Assume the first value has index 0. INPUT: - ``sequence`` -- list of integers - ``algorithm`` -- string - 'pari' - use Pari's implementation of LLL (fast) - 'bm' - use Sage's Berlekamp-Massey algorithm OUTPUT: - a CFiniteSequence, or 0 if none could be found EXAMPLES:: sage: CFiniteSequence.guess([1,2,4,8,16,32]) C-finite sequence, generated by 1/(-2*x + 1) sage: r = CFiniteSequence.guess([1,2,3,4,5]) Traceback (most recent call last): ... ValueError: Sequence too short for guessing. sage: CFiniteSequence.guess([1,0,0,0,0,0]) Finite sequence [1], offset = 0 With Pari LLL, all values are taken into account, and if no o.g.f. can be found, `0` is returned:: sage: CFiniteSequence.guess([1,0,0,0,0,1]) 0 With Berlekamp-Massey, if an odd number of values is given, the last one is dropped. So with an odd number of values the result may not generate the last value:: sage: r = CFiniteSequence.guess([1,2,4,8,9], algorithm='bm'); r C-finite sequence, generated by 1/(-2*x + 1) sage: r[0:5] [1, 2, 4, 8, 16] """ S = PolynomialRing(QQ, 'x') if algorithm == 'bm': if len(sequence) < 2: raise ValueError('Sequence too short for guessing.') R = PowerSeriesRing(QQ, 'x') if len(sequence) % 2 == 1: sequence = sequence[:-1] l = len(sequence) - 1 denominator = S(berlekamp_massey(sequence).list()[::-1]) numerator = R(S(sequence) * denominator, prec=l).truncate() return CFiniteSequence(numerator / denominator) else: global _gp if len(sequence) < 6: raise ValueError('Sequence too short for guessing.') if _gp is None: _gp = Gp() _gp("ggf(v)=local(l,m,p,q,B);l=length(v);B=floor(l/2);\ if(B<3,return(0));m=matrix(B,B,x,y,v[x-y+B+1]);\ q=qflll(m,4)[1];if(length(q)==0,return(0));\ p=sum(k=1,B,x^(k-1)*q[k,1]);\ q=Pol(Pol(vector(l,n,v[l-n+1]))*p+O(x^(B+1)));\ if(polcoeff(p,0)<0,q=-q;p=-p);q=q/p;p=Ser(q+O(x^(l+1)));\ for(m=1,l,if(polcoeff(p,m-1)!=v[m],return(0)));q") _gp.set('gf', sequence) _gp("gf=ggf(gf)") num = S(sage_eval(_gp.eval("Vec(numerator(gf))"))[::-1]) den = S(sage_eval(_gp.eval("Vec(denominator(gf))"))[::-1]) if num == 0: return 0 else: return CFiniteSequence(num / den) """