def __init__(self, PP, f, h=None, names=None, genus=None): x, y, z = PP.gens() df = f.degree() F1 = sum([f[i] * x**i * z**(df - i) for i in range(df + 1)]) if h is None: F = y**2 * z**(df - 2) - F1 else: dh = h.degree() deg = max(df, dh + 1) F0 = sum([h[i] * x**i * z**(dh - i) for i in range(dh + 1)]) F = y**2 * z**(deg - 2) + F0 * y * z**(deg - dh - 1) - F1 * z**(deg - df) plane_curve.ProjectiveCurve_generic.__init__(self, PP, F) R = PP.base_ring() if names == None: names = ["x", "y"] elif isinstance(names, str): names = names.split(",") self._names = names P1 = PolynomialRing(R, name=names[0]) P2 = PolynomialRing(P1, name=names[1]) self._PP = PP self._printing_ring = P2 self._hyperelliptic_polynomials = (f, h) self._genus = genus
def _denominator(): R = PolynomialRing(ZZ, "T") T = R.gen() denom = R(1) lc = self._f.list()[-1] if lc == 1: # MONIC for i in range(2, self._delta + 1): if self._delta % i == 0: phi = euler_phi(i) G = IntegerModRing(i) ki = G(self._q).multiplicative_order() denom = denom * (T**ki - 1)**(phi // ki) return denom else: # Non-monic x = PolynomialRing(self._Fq, "x").gen() f = x**self._delta - lc L = f.splitting_field("a") roots = [r for r, _ in f.change_ring(L).roots()] roots_dict = dict([(r, i) for i, r in enumerate(roots)]) rootsfrob = [ L.frobenius_endomorphism(self._Fq.degree())(r) for r in roots ] m = zero_matrix(len(roots)) for i, r in enumerate(roots): m[i, roots_dict[rootsfrob[i]]] = 1 return R(R(m.characteristic_polynomial()) // (T - 1))
def __init__(self, X, S): R = X.base_ring() SchemeHomset_generic.__init__(self, spec.Spec(S, R), X) P2 = X.curve()._printing_ring if S != R: y = str(P2.gen()) x = str(P2.base_ring().gen()) P1 = PolynomialRing(S, name=x) P2 = PolynomialRing(P1, name=y) self._printing_ring = P2
def __init__(self, Y, X, **kwds): R = X.base_ring() S = Y.coordinate_ring() SchemeHomset_points.__init__(self, Y, X, **kwds) P2 = X.curve()._printing_ring if S != R: y = str(P2.gen()) x = str(P2.base_ring().gen()) P1 = PolynomialRing(S, name=x) P2 = PolynomialRing(P1, name=y) self._printing_ring = P2
def __init__(self, params, asym=False): (self.n, self.q, sigma, self.sigma_prime, self.k) = params S, x = PolynomialRing(ZZ, 'x').objgen() self.R = S.quotient_ring(S.ideal(x**self.n + 1)) Sq = PolynomialRing(Zmod(self.q), 'x') self.Rq = Sq.quotient_ring(Sq.ideal(x**self.n + 1)) # draw z_is uniformly from Rq and compute its inverse in Rq if asym: z = [self.Rq.random_element() for i in range(self.k)] self.zinv = [z_i**(-1) for z_i in z] else: # or do symmetric version z = self.Rq.random_element() zinv = z**(-1) z, self.zinv = zip(*[(z, zinv) for i in range(self.k)]) # set up some discrete Gaussians DGSL_sigma = DGSL(ZZ**self.n, sigma) self.D_sigma = lambda: self.Rq(list(DGSL_sigma())) # discrete Gaussian in ZZ^n with stddev sigma_prime, yields random level-0 encodings DGSL_sigmap_ZZ = DGSL(ZZ**self.n, self.sigma_prime) self.D_sigmap_ZZ = lambda: self.Rq(list(DGSL_sigmap_ZZ())) # draw g repeatedly from a Gaussian distribution of Z^n (with param sigma) # until g^(-1) in QQ[x]/<x^n + 1> is small (< n^2) Sk = PolynomialRing(QQ, 'x') K = Sk.quotient_ring(Sk.ideal(x**self.n + 1)) while True: l = self.D_sigma() ginv_K = K(mod_near_poly(l, self.q))**(-1) ginv_size = vector(ginv_K).norm() if ginv_size < self.n**2: g = self.Rq(l) self.ginv = g**(-1) break # discrete Gaussian in I = <g>, yields random encodings of 0 short_g = vector(ZZ, mod_near_poly(g, self.q)) DGSL_sigmap_I = DGSL(short_g, self.sigma_prime) self.D_sigmap_I = lambda: self.Rq(list(DGSL_sigmap_I())) # compute zero-testing parameter p_zt # randomly draw h (in Rq) from a discrete Gaussian with param q^(1/2) self.h = self.Rq(list(DGSL(ZZ**self.n, round(sqrt(self.q)))())) # create p_zt self.p_zt = self.ginv * self.h * prod(z)
def velu(kernel, domain=None): E = kernel[0].curve() Q = PolynomialRing(E.base_field(), ['x', 'y']) x, y = Q.gens() X = x Y = y R = [] v = 0 w = 0 for P in kernel: g_x = 3 * P[0]**2 + E.a4() g_y = -2 * P[1] u_P = g_y**2 if 2 * P == E(0, 1, 0): R.append(P) v_P = g_x else: if not -P in R: R.append(P) v_P = 2 * g_x else: continue v += v_P w += (u_P + P[0] * v_P) X += (v_P / (x - P[0]) + u_P / (x - P[0])**2) Y -= (2 * u_P * y / (x - P[0])**3 + v_P * (y - P[1]) / (x - P[0])**2 - g_x * g_y / (x - P[0])**2) a = E.a4() - 5 * v b = E.a6() - 7 * w if domain != None: try: a = domain.base_field()(a) b = domain.base_field()(b) codomain = EllipticCurve(domain.base_field(), [a, b]) R = PolynomialRing(E.base_field(), ['x', 'y']) Rf = R.fraction_field() X = Rf(X) Y = Rf(Y) f = standard_form((X, Y), domain) except: codomain = EllipticCurve(E.base_field(), [a, b]) f = standard_form((X, Y), E) else: codomain = EllipticCurve(E.base_field(), [a, b]) f = standard_form((X, Y), E) return codomain, f
def _check_muqt(mu, q, t, pi=None): """ EXAMPLES:: sage: from sage.combinat.sf.ns_macdonald import _check_muqt sage: P, q, t, n, R, x = _check_muqt([0,0,1],None,None) sage: P Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field sage: q q sage: t t sage: n Nonattacking fillings of [0, 0, 1] sage: R Multivariate Polynomial Ring in x0, x1, x2 over Fraction Field of Multivariate Polynomial Ring in q, t over Rational Field sage: x (x0, x1, x2) :: sage: q,t = var('q,t') sage: P, q, t, n, R, x = _check_muqt([0,0,1],q,None) Traceback (most recent call last): ... ValueError: you must specify either both q and t or neither of them :: sage: P, q, t, n, R, x = _check_muqt([0,0,1],q,2) Traceback (most recent call last): ... ValueError: the parents of q and t must be the same """ if q is None and t is None: P = PolynomialRing(QQ, 'q,t').fraction_field() q, t = P.gens() elif q is not None and t is not None: if q.parent() != t.parent(): raise ValueError("the parents of q and t must be the same") P = q.parent() else: raise ValueError( "you must specify either both q and t or neither of them") n = NonattackingFillings(mu, pi) R = PolynomialRing(P, len(n._shape), 'x') x = R.gens() return P, q, t, n, R, x
def __init__(self, R, n, q=None): """ TESTS:: sage: HeckeAlgebraSymmetricGroupT(QQ, 3) Hecke algebra of the symmetric group of order 3 on the T basis over Univariate Polynomial Ring in q over Rational Field :: sage: HeckeAlgebraSymmetricGroupT(QQ, 3, q=1) Hecke algebra of the symmetric group of order 3 with q=1 on the T basis over Rational Field """ self.n = n self._basis_keys = permutation.Permutations(n) self._name = "Hecke algebra of the symmetric group of order %s"%self.n self._one = permutation.Permutation(range(1,n+1)) if q is None: q = PolynomialRing(R, 'q').gen() R = q.parent() else: if q not in R: raise ValueError, "q must be in R (= %s)"%R self._name += " with q=%s"%q self._q = q CombinatorialAlgebra.__init__(self, R) # _repr_ customization: output the basis element indexed by [1,2,3] as [1,2,3] self.print_options(prefix="")
def lfsr_connection_polynomial(s): """ INPUT: - ``s`` -- a sequence of elements of a finite field of even length OUTPUT: - ``C(x)`` -- the connection polynomial of the minimal LFSR. This implements the algorithm in section 3 of J. L. Massey's article [Mas1969]_. EXAMPLES:: sage: F = GF(2) sage: F Finite Field of size 2 sage: o = F(0); l = F(1) sage: key = [l,o,o,l]; fill = [l,l,o,l]; n = 20 sage: s = lfsr_sequence(key,fill,n); s [1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0] sage: lfsr_connection_polynomial(s) x^4 + x + 1 sage: from sage.matrix.berlekamp_massey import berlekamp_massey sage: berlekamp_massey(s) x^4 + x^3 + 1 Notice that ``berlekamp_massey`` returns the reverse of the connection polynomial (and is potentially must faster than this implementation). """ # Initialization: FF = s[0].base_ring() R = PolynomialRing(FF, "x") x = R.gen() C = R(1); B = R(1); m = 1; b = FF(1); L = 0; N = 0 while N < len(s): if L > 0: r = min(L+1,C.degree()+1) d = s[N] + sum([(C.list())[i]*s[N-i] for i in range(1,r)]) if L == 0: d = s[N] if d == 0: m += 1 N += 1 if d > 0: if 2*L > N: C = C - d*b**(-1)*x**m*B m += 1 N += 1 else: T = C C = C - d*b**(-1)*x**m*B L = N + 1 - L m = 1 b = d B = T N += 1 return C
def get_basic_integral(G, cocycle, gamma, center, j, prec=None): p = G.p HOC = cocycle.parent() V = HOC.coefficient_module() if prec is None: prec = V.precision_cap() Cp = Qp(p, prec) verbose('precision = %s' % prec) R = PolynomialRing(Cp, names='t') PS = PowerSeriesRing(Cp, names='z') t = R.gen() z = PS.gen() if prec is None: prec = V.precision_cap() try: coeff_depth = V.precision_cap() except AttributeError: coeff_depth = V.coefficient_module().precision_cap() resadd = ZZ(0) edgelist = G.get_covering(1)[1:] for rev, h in edgelist: a, b, c, d = [Cp(o) for o in G.embed(h, prec).list()] try: c0val = 0 pol = PS(d * z + b) / PS(c * z + a) pol -= Cp.teichmuller(center) pol = pol**j pol = pol.polynomial() newgamma = G.Gpn( G.reduce_in_amalgam(h * gamma.quaternion_rep, return_word=False)) if rev: # DEBUG newgamma = newgamma.conjugate_by(G.wp()) print 'reversing' if G.use_shapiro(): mu_e = cocycle.evaluate_and_identity(newgamma) else: mu_e = cocycle.evaluate(newgamma) if newgamma.quaternion_rep != 1: print 'newgamma = ', newgamma except AttributeError: verbose('...') continue if HOC._use_ps_dists: tmp = sum(a * mu_e.moment(i) for a, i in izip(pol.coefficients(), pol.exponents()) if i < len(mu_e._moments)) else: tmp = mu_e.evaluate_at_poly(pol, Cp, coeff_depth) resadd += tmp try: if G.use_shapiro(): tmp = cocycle.get_liftee().evaluate_and_identity(newgamma) else: tmp = cocycle.get_liftee().evaluate(newgamma) except IndexError: pass return resadd
def compute_tau0(v0,gamma,wD,return_exact = False): r''' INPUT: - v0: F -> its localization at p - gamma: the image of wD (the generator for an order of F) under an optimal embedding OUTPUT: The element tau_0 such that gamma * [tau_0,1] = wD * [tau_0,1] ''' R = PolynomialRing(QQ,names = 'X') X = R.gen() F = v0.domain() Cp = v0.codomain() assert wD.minpoly() == gamma.minpoly() a,b,c,d = gamma.list() tau0_vec = (c*X**2+(d-a)*X-b).roots(F) tau0 = v0(tau0_vec[0][0]) idx = 0 if c * tau0 + d != v0(wD): tau0 = v0(tau0_vec[1][0]) idx = 1 return tau0_vec[idx][0] if return_exact == True else tau0
def padic_gauss_sum(a, p, f, prec=20, factored=False, algorithm='pari', parent=None): # Copied from Sage from sage.rings.padics.factory import Zp from sage.rings.all import PolynomialRing q = p**f a = a % (q - 1) if parent is None: R = Zp(p, prec) else: R = parent out = -R.one() if a != 0: t = R(1 / (q - 1)) for i in range(f): out *= (a * t).gamma(algorithm) a = (a * p) % (q - 1) s = sum(a.digits(base=p)) if factored: return (s, out) X = PolynomialRing(R, name='X').gen() pi = R.ext(X**(p - 1) + p, names='pi').gen() out *= pi**s return out
def coordinate_ring(self): """ Return the coordinate ring of this scheme. EXAMPLES:: sage: ProjectiveSpace(3, GF(19^2,'alpha'), 'abcd').coordinate_ring() Multivariate Polynomial Ring in a, b, c, d over Finite Field in alpha of size 19^2 :: sage: ProjectiveSpace(3).coordinate_ring() Multivariate Polynomial Ring in x0, x1, x2, x3 over Integer Ring :: sage: ProjectiveSpace(2, QQ, ['alpha', 'beta', 'gamma']).coordinate_ring() Multivariate Polynomial Ring in alpha, beta, gamma over Rational Field """ try: return self._coordinate_ring except AttributeError: self._coordinate_ring = PolynomialRing( self.base_ring(), self.variable_names(), self.dimension_relative() + 1) return self._coordinate_ring
def is_supersingular(E): p = E.base_field().characteristic() j = E.j_invariant() if not j in GF(p**2): return False if p <= 3: return j == 0 F = ClassicalModularPolynomialDatabase()[2] x = PolynomialRing(GF(p**2), 'x').gen() f = F(x, j) roots = [i[0] for i in f.roots() for _ in range(i[1])] if len(roots) < 3: return False vertices = [j, j, j] m = floor(log(p, 2)) + 1 for k in range(1, m + 1): for i in range(3): f = F(x, roots[i]) g = x - vertices[i] a = f.quo_rem(g)[0] vertices[i] = roots[i] attempt = a.roots() if len(attempt) == 0: return False roots[i] = attempt[0][0] return True
def differential_operator(f, g, k): r""" Return the differential operator `(f g)_k` symbolically in the polynomial ring in ``dfdx, dfdy, dgdx, dgdy``. This is defined by Mestre on p 315 [M]_: `(f g)_k = \frac{(m - k)! (n - k)!}{m! n!} \left( \frac{\del f}{\del x} \frac{\del g}{\del y} - \frac{\del f}{\del y} \frac{\del g}{\del x} \right)^k ` . EXAMPLES:: sage: from sage.schemes.hyperelliptic_curves.invariants import differential_operator sage: R.<x, y> = QQ[] sage: differential_operator(x, y, 0) 1 sage: differential_operator(x, y, 1) -dfdy*dgdx + dfdx*dgdy sage: differential_operator(x*y, x*y, 2) 1/4*dfdy^2*dgdx^2 - 1/2*dfdx*dfdy*dgdx*dgdy + 1/4*dfdx^2*dgdy^2 sage: differential_operator(x^2*y, x*y^2, 2) 1/36*dfdy^2*dgdx^2 - 1/18*dfdx*dfdy*dgdx*dgdy + 1/36*dfdx^2*dgdy^2 sage: differential_operator(x^2*y, x*y^2, 4) 1/576*dfdy^4*dgdx^4 - 1/144*dfdx*dfdy^3*dgdx^3*dgdy + 1/96*dfdx^2*dfdy^2*dgdx^2*dgdy^2 - 1/144*dfdx^3*dfdy*dgdx*dgdy^3 + 1/576*dfdx^4*dgdy^4 """ (x, y) = f.parent().gens() n = max(ZZ(f.degree()), ZZ(k)) m = max(ZZ(g.degree()), ZZ(k)) R, (fx, fy, gx, gy) = PolynomialRing(f.base_ring(), 4, 'dfdx,dfdy,dgdx,dgdy').objgens() const = (m - k).factorial() * (n - k).factorial() / (m.factorial() * n.factorial()) U = f.base_ring()(const) * (fx*gy - fy*gx)**k return U
def diffsymb(U, f, g): r""" Given a differential operator ``U`` in ``dfdx, dfdy, dgdx, dgdy``, represented symbolically by ``U``, apply it to ``f, g``. EXAMPLES:: sage: from sage.schemes.hyperelliptic_curves.invariants import diffsymb sage: R.<x, y> = QQ[] sage: S.<dfdx, dfdy, dgdx, dgdy> = QQ[] sage: [ diffsymb(dd, x^2, y*0 + 1) for dd in S.gens() ] [2*x, 0, 0, 0] sage: [ diffsymb(dd, x*0 + 1, y^2) for dd in S.gens() ] [0, 0, 0, 2*y] sage: [ diffsymb(dd, x^2, y^2) for dd in S.gens() ] [2*x*y^2, 0, 0, 2*x^2*y] sage: diffsymb(dfdx + dfdy*dgdy, y*x^2, y^3) 2*x*y^4 + 3*x^2*y^2 """ (x, y) = f.parent().gens() R, (fx, fy, gx, gy) = PolynomialRing(f.base_ring(), 4, 'dfdx,dfdy,dgdx,dgdy').objgens() res = 0 for coeff, mon in list(U): mon = R(mon) a = diffxy(f, x, mon.degree(fx), y, mon.degree(fy)) b = diffxy(g, x, mon.degree(gx), y, mon.degree(gy)) temp = coeff * a * b res = res + temp return res
def generator_relations(self, K): """ An ideal `I` in a polynomial ring `R` over `K`, such that the associated ring is `R / I` surjects onto the ring of modular forms with coefficients in `K`. INPUT: - `K` -- A ring. OUTPUT: An ideal in a polynomial ring. TESTS:: sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import * sage: t = ModularFormTestType_scalar() sage: t.generator_relations(QQ) Ideal (g1^2 - g2, g1^3 - g3, g1^4 - g4, g1^5 - g5) of Multivariate Polynomial Ring in g1, g2, g3, g4, g5 over Rational Field """ if K.has_coerce_map_from(ZZ): R = PolynomialRing(K, self._generator_names(K)) g1 = R.gen(0) return R.ideal([ g1**i - g for (i, g) in list(enumerate([None] + list(R.gens())))[2:] ]) raise NotImplementedError
def _pcubicroots(b, c, d): r""" Local function returning the number of roots of `x^3 + b*x^2 + c*x + d` modulo `P`, counting multiplicities """ return sum([rr[1] for rr in PolynomialRing(F, 'x')([F(d), F(c), F(b), F(1)]).roots()],0)
def generator_relations(self, K): """ An ideal `I` in a polynomial ring `R` over `K`, such that the associated ring is `R / I` surjects onto the ring of modular forms with coefficients in `K`. INPUT: - `K` -- A ring. OUTPUT: An ideal in a polynomial ring. TESTS:: sage: from psage.modform.fourier_expansion_framework.modularforms.modularform_testtype import * sage: t = ModularFormTestType_vectorvalued() sage: t.generator_relations(QQ) Ideal (g1^2 - g2, g1^3 - g3, g1^4 - g4, g1^5 - g5) of Multivariate Polynomial Ring in g1, g2, g3, g4, g5, v1, v2, v3 over Rational Field """ if K.has_coerce_map_from(ZZ): R = PolynomialRing( K, self.non_vector_valued()._generator_names(K) + self._generator_names(K)) return R.ideal().parent()( self.non_vector_valued().generator_relations(K)) raise NotImplementedError
def frobenius(self, P=None): """ Returns the Frobenius as a function on the group of points of this elliptic curve. EXAMPLES:: sage: Qp = pAdicField(13) sage: E = EllipticCurve(Qp,[1,1]) sage: type(E.frobenius()) <... 'function'> sage: point = E(0,1) sage: E.frobenius(point) (0 : 1 + O(13^20) : 1 + O(13^20)) Check that :trac:`29709` is fixed:: sage: Qp = pAdicField(13) sage: E = EllipticCurve(Qp,[0,0,1,0,1]) sage: E.frobenius(E(1,1)) Traceback (most recent call last): ... NotImplementedError: Curve must be in weierstrass normal form. sage: E = EllipticCurve(Qp,[0,1,0,0,1]) sage: E.frobenius(E(0,1)) (0 : 1 + O(13^20) : 1 + O(13^20)) """ try: _frob = self._frob except AttributeError: K = self.base_field() p = K.prime() x = PolynomialRing(K, 'x').gen(0) a1, a2, a3, a4, a6 = self.a_invariants() if a1 != 0 or a3 != 0: raise NotImplementedError( "Curve must be in weierstrass normal form.") f = x * x * x + a2 * x * x + a4 * x + a6 h = (f(x**p) - f**p) # internal function: I don't know how to doctest it... def _frob(P): x0 = P[0] y0 = P[1] uN = (1 + h(x0) / y0**(2 * p)).sqrt() yres = y0**p * uN xres = x0**p if (yres - y0).valuation() == 0: yres = -yres return self.point([xres, yres, K(1)]) self._frob = _frob if P is None: return _frob else: return _frob(P)
def expand(self): """ EXAMPLES:: sage: X = SchubertPolynomialRing(ZZ) sage: X([2,1,3]).expand() x0 sage: map(lambda x: x.expand(), [X(p) for p in Permutations(3)]) [1, x0 + x1, x0, x0*x1, x0^2, x0^2*x1] TESTS: Calling .expand() should always return an element of an MPolynomialRing :: sage: X = SchubertPolynomialRing(ZZ) sage: f = X([1]); f X[1] sage: type(f.expand()) <type 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomial_libsingular'> sage: f.expand() 1 sage: f = X([1,2]) sage: type(f.expand()) <type 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomial_libsingular'> sage: f = X([1,3,2,4]) sage: type(f.expand()) <type 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomial_libsingular'> """ p = symmetrica.t_SCHUBERT_POLYNOM(self) if not is_MPolynomial(p): R = PolynomialRing(self.parent().base_ring(), 1, 'x') p = R(p) return p
def local_coordinates_at_infinity(self, prec=20, name='t'): """ For the genus `g` hyperelliptic curve `y^2 = f(x)`, return `(x(t), y(t))` such that `(y(t))^2 = f(x(t))`, where `t = x^g/y` is the local parameter at infinity INPUT: - ``prec`` -- desired precision of the local coordinates - ``name`` -- generator of the power series ring (default: ``t``) OUTPUT: `(x(t),y(t))` such that `y(t)^2 = f(x(t))` and `t = x^g/y` is the local parameter at infinity EXAMPLES:: sage: R.<x> = QQ['x'] sage: H = HyperellipticCurve(x^5-5*x^2+1) sage: x,y = H.local_coordinates_at_infinity(10) sage: x t^-2 + 5*t^4 - t^8 - 50*t^10 + O(t^12) sage: y t^-5 + 10*t - 2*t^5 - 75*t^7 + 50*t^11 + O(t^12) :: sage: R.<x> = QQ['x'] sage: H = HyperellipticCurve(x^3-x+1) sage: x,y = H.local_coordinates_at_infinity(10) sage: x t^-2 + t^2 - t^4 - t^6 + 3*t^8 + O(t^12) sage: y t^-3 + t - t^3 - t^5 + 3*t^7 - 10*t^11 + O(t^12) Note: if even degree model, just returns local coordinate above one point AUTHOR: - Jennifer Balakrishnan (2007-12) """ g = self.genus() pol = self.hyperelliptic_polynomials()[0] K = LaurentSeriesRing(self.base_ring(), name) t = K.gen() K.set_default_prec(prec + 2) L = PolynomialRing(K, 'x') x = L.gen() i = 0 w = (x**g / t)**2 - pol wprime = w.derivative(x) if pol.degree() == 2 * g + 1: x = t**-2 else: x = t**-1 for i in range((RR(log(prec + 2) / log(2))).ceil()): x = x - w(x) / wprime(x) y = x**g / t return x + O(t**(prec + 2)), y + O(t**(prec + 2))
def _sage_(self): """ EXAMPLES: sage: m = lie('[[1,0,3,3],[12,4,-4,7],[-1,9,8,0],[3,-5,-2,9]]') # optional - lie sage: m.sage() # optional - lie [ 1 0 3 3] [12 4 -4 7] [-1 9 8 0] [ 3 -5 -2 9] """ t = self.type() if t == 'grp': raise ValueError, "cannot convert Lie groups to native Sage objects" elif t == 'mat': import sage.matrix.constructor return sage.matrix.constructor.matrix( eval( str(self).replace('\n','').strip()) ) elif t == 'pol': import sage.misc.misc from sage.rings.all import PolynomialRing, QQ #Figure out the number of variables s = str(self) open_bracket = s.find('[') close_bracket = s.find(']') nvars = len(s[open_bracket:close_bracket].split(',')) #create the polynomial ring R = PolynomialRing(QQ, nvars, 'x') x = R.gens() pol = R(0) #Split up the polynomials into terms terms = [] for termgrp in s.split(' - '): #The first entry in termgrp has #a negative coefficient termgrp = "-"+termgrp.strip() terms += termgrp.split('+') #Make sure we don't accidentally add a negative #sign to the first monomial if s[0] != "-": terms[0] = terms[0][1:] #go through all the terms in s for term in terms: xpos = term.find('X') coef = eval(term[:xpos].strip()) exps = eval(term[xpos+1:].strip()) monomial = sage.misc.misc.prod(map(lambda i: x[i]**exps[i] , range(nvars))) pol += coef * monomial return pol elif t == 'tex': return repr(self) elif t == 'vid': return None else: return ExpectElement._sage_(self)
def trace_of_frobenius_mod_2(E): F = E.base_field() x = PolynomialRing(F, 'x').gen() f = x ** 3 + E.a4() * x + E.a6() q = F.order() if gcd(f, power_mod(x, q, f) - x).is_constant(): return 1 else: return 0
def eisenstein_basis(N, k, verbose=False): r""" Find spanning list of 'easy' generators for the subspace of `M_k(\Gamma_0(N))` generated by level 1 Eisenstein series and their images of even integer weights up to `k`. INPUT: - N -- positive integer - k -- positive integer - ``verbose`` -- bool (default: False) OUTPUT: - list of monomials in images of level 1 Eisenstein series - prec of q-expansions needed to determine element of `M_k(\Gamma_0(N))`. EXAMPLES:: sage: from psage.modform.rational.special import eisenstein_basis sage: eisenstein_basis(5,4) ([E4(q^5)^1, E4(q^1)^1, E2^*(q^5)^2], 3) sage: eisenstein_basis(11,2,verbose=True) # warning below because of verbose Warning -- not enough series. ([E2^*(q^11)^1], 2) sage: eisenstein_basis(11,2,verbose=False) ([E2^*(q^11)^1], 2) """ assert N > 1 if k % 2 != 0: return [] # Make list E of Eisenstein series, to enough precision to # determine them, until we span space. M = ModularForms(N, k) prec = M.echelon_basis()[-1].valuation() + 1 gens = eisenstein_gens(N, k, prec) R = PolynomialRing(ZZ, len(gens), ['E%sq%s'%(g[1],g[0]) for g in gens]) z = [(R.gen(i), g[1]) for i, g in enumerate(gens)] m = monomials(z, k) A = QQ**prec V = A.zero_subspace() E = [] for i, z in enumerate(m): d = z.degrees() f = prod(g[2]**d[i] for i, g in enumerate(gens) if d[i]) v = A(f.padded_list(prec)) if v not in V: V = V + A.span([v]) w = [(gens[i][0],gens[i][1],d[i]) for i in range(len(d)) if d[i]] E.append(EisensteinMonomial(w)) if V.dimension() == M.dimension(): return E, prec if verbose: print "Warning -- not enough series." return E, prec
def _delta_poly_modulo(N, prec=10): """ Return the q-expansion of `\Delta` modulo `N`. Used internally by the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp` for more information. INPUT: - `N` -- positive integer modulo which we want to compute `\Delta` - ``prec`` -- integer; the absolute precision of the output OUTPUT: the polynomial of degree ``prec``-1 which is the truncation of `\Delta` modulo `N`, as an element of the polynomial ring in `q` over the integers modulo `N`. EXAMPLES:: sage: from sage.modular.modform.vm_basis import _delta_poly_modulo sage: _delta_poly_modulo(5, 7) 2*q^6 + 3*q^4 + 2*q^3 + q^2 + q sage: _delta_poly_modulo(10, 12) 2*q^11 + 7*q^9 + 6*q^7 + 2*q^6 + 8*q^4 + 2*q^3 + 6*q^2 + q """ if prec <= 0: raise ValueError("prec must be positive") v = [0] * prec # Let F = \sum_{n >= 0} (-1)^n (2n+1) q^(floor(n(n+1)/2)). # Then delta is F^8. stop = int((-1 + math.sqrt(8 * prec)) / 2.0) for n in xrange(stop + 1): v[n * (n + 1) // 2] = ((N - 1) * (2 * n + 1) if (n & 1) else (2 * n + 1)) from sage.rings.all import Integers P = PolynomialRing(Integers(N), 'q') f = P(v) t = verbose('made series') # fast way of computing f*f truncated at prec f = f._mul_trunc_(f, prec) t = verbose('squared (1 of 3)', t) f = f._mul_trunc_(f, prec) t = verbose('squared (2 of 3)', t) f = f._mul_trunc_(f, prec - 1) t = verbose('squared (3 of 3)', t) f = f.shift(1) t = verbose('shifted', t) return f
def integrate_H1(G, cycle, cocycle, depth=1, method='moments', prec=None, parallelize=False, twist=False, progress_bar=False, multiplicative=True, return_valuation=False): if prec is None: prec = cocycle.parent().coefficient_module().base_ring().precision_cap( ) verbose('precision = %s' % prec) Cp = cycle.parent().coefficient_module().base_field() R = PolynomialRing(Cp, names='t') t = R.gen() if method == 'moments': integrate_H0 = integrate_H0_moments else: assert method == 'riemann' integrate_H0 = integrate_H0_riemann jj = 0 total_integrals = cycle.size_of_support() verbose('Will do %s integrals' % total_integrals) input_vec = [] resmul = Cp(1) resadd = Cp(0) resval = ZZ(0) for g, divisor in cycle.get_data(): jj += 1 if divisor.degree() != 0: 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)) g = g.conjugate_by(G.wp()**-1) newresadd, newresmul, newresval = integrate_H0(G, divisor, cocycle, depth, g, prec, jj, total_integrals, progress_bar, parallelize) resadd += newresadd resmul *= newresmul resval += newresval if not multiplicative: if return_valuation: return resadd, resval, Cp.teichmuller(resmul) else: return resadd else: return Cp.prime()**resval * Cp.teichmuller(resmul) * resadd.exp()
def _pquadroots(a, b, c): r""" Local function returning True iff `ax^2 + bx + c` has roots modulo `P` """ (a, b, c) = (F(a), F(b), F(c)) if a == 0: return (b != 0) or (c == 0) elif p == 2: return len(PolynomialRing(F, "x")([c,b,a]).roots()) > 0 else: return (b**2 - 4*a*c).is_square()
def root_extension_field(self): r""" Return the extension field of the base field of (the parent of) ``self`` in which the corresponding fixed points of ``self`` lie. The variable name of the corresponding generator is ``e``. It corresponds to ``e=sqrt(D)``, where ``D`` is the discriminant of ``self``. If the extension degree is ``1`` then the base field is returned. The correct embedding is the positive resp. positive imaginary one. Unfortunately no default embedding can be specified for relative number fields yet. EXAMPLES:: sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=infinity) sage: G.V(3).root_extension_field() Number Field in e with defining polynomial x^2 - 32 sage: G.T().root_extension_field() == G.base_field() True sage: (G.S()).root_extension_field() Number Field in e with defining polynomial x^2 + 4 sage: G = HeckeTriangleGroup(n=7) sage: G.V(3).root_extension_field() Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field sage: G.V(1).root_extension_field() == G.base_field() True sage: G.U().root_extension_field() Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field """ K = self.parent().base_field() x = PolynomialRing(K, 'x').gen() D = self.discriminant() if D.is_square(): return K else: # unfortunately we can't set embeddings for relative extensions :-( # return K.extension(x**2 - D, 'e', embedding=AA(D).sqrt()) L = K.extension(x**2 - D, 'e') #e = AA(D).sqrt() #emb = L.hom([e]) #L._unset_embedding() #L.register_embedding(emb) #return NumberField(L.absolute_polynomial(), 'e', structure=AbsoluteFromRelative(L), embedding=(???)) return L
def rational_period_functions(self, k, D): r""" Return a list of basic rational period functions of weight ``k`` for discriminant ``D``. The list is expected to be a generating set for all rational period functions of the given weight and discriminant (unknown). The method assumes that ``D > 0``. Also see the element method `rational_period_function` for more information. - ``k`` -- An even integer, the desired weight of the rational period functions. - ``D`` -- An element of the base ring corresponding to a valid discriminant. EXAMPLES:: sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: sorted(G.rational_period_functions(k=4, D=12)) [(z^4 - 1)/z^4] sage: sorted(G.rational_period_functions(k=-2, D=12)) [-z^2 + 1, 4*lam*z^2 - 4*lam] sage: sorted(G.rational_period_functions(k=2, D=14)) [(24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), (24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), 1/z, (z^2 - 1)/z^2] sage: sorted(G.rational_period_functions(k=-4, D=14)) [-16*z^4 + 16, -z^4 + 1, 16*z^4 - 16] """ try: k = ZZ(k) if not ZZ(2).divides(k): raise TypeError except TypeError: raise ValueError("k={} has to be an even integer!".format(k)) z = PolynomialRing(self.base_ring(), 'z').gen() R = [] if k != 0: R.append(ZZ(1) - z**(-k)) if k == 2: R.append(z**(-1)) L = self.class_representatives(D=D, primitive=True) for v in L: rat = v.rational_period_function(k) if rat != 0: R.append(rat) return R