passagemath-schemes 10.6.47__cp312-cp312-macosx_13_0_arm64.whl

sage/schemes/elliptic_curves/ell_modular_symbols.py

@@ -0,0 +1,775 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: neeeds database_cremona_mini_ellcurve
+r"""
+Modular symbols attached to elliptic curves over `\QQ`
+
+To an elliptic curve `E` over the rational numbers with conductor `N`,
+one can associate a space of modular symbols of level `N`, because `E`
+is known to be modular.  The space is two-dimensional and contains a
+subspace on which complex conjugation acts as multiplication by `+1`
+and one on which it acts by `-1`.
+
+There are three implementations of modular symbols, two within
+``Sage`` and one in Cremona's ``eclib`` library.
+One can choose here which one is used.
+
+Associated to `E` there is a canonical generator in each space. They are maps
+`[.]^+` and `[.]^{-}`, both `\QQ \to\QQ`. They are normalized such that
+
+.. MATH::
+
+   [r]^{+} \Omega^{+} + [r]^{-}\Omega^{-}  = \int_{\infty}^r 2\pi i f(z) dz
+
+where `f` is the newform associated to the isogeny class of `E` and
+`\Omega^{+}` is the smallest positive period of the Néron differential
+of `E` and `\Omega^{-}` is the smallest positive purely imaginary
+period. Note that it depends on `E` rather than on its isogeny class.
+
+From ``eclib`` version v20161230, both plus and minus symbols are
+available and are correctly normalized.  In the ``Sage``
+implementation, the computation of the space provides initial
+generators which are not necessarily correctly normalized; here we
+implement two methods that try to find the correct scaling factor.
+
+Modular symbols are used to compute `p`-adic `L`-functions.
+
+EXAMPLES::
+
+    sage: # needs eclib
+    sage: E = EllipticCurve("19a1")
+    sage: m = E.modular_symbol()
+    sage: m(0)
+    1/3
+    sage: m(1/17)
+    -2/3
+
+    sage: # needs eclib sage.graphs
+    sage: m2 = E.modular_symbol(-1, implementation='sage')
+    sage: m2(0)
+    0
+    sage: m2(1/5)
+    1/2
+
+    sage: # needs eclib
+    sage: V = E.modular_symbol_space(); V
+    Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 2
+     for Gamma_0(19) of weight 2 with sign 1 over Rational Field
+    sage: V.q_eigenform(30)
+    q - 2*q^3 - 2*q^4 + 3*q^5 - q^7 + q^9 + 3*q^11 + 4*q^12 - 4*q^13 - 6*q^15 + 4*q^16
+     - 3*q^17 + q^19 - 6*q^20 + 2*q^21 + 4*q^25 + 4*q^27 + 2*q^28 + 6*q^29 + O(q^30)
+
+For more details on modular symbols consult the following
+
+REFERENCES:
+
+- [MTT1986]_
+
+- [Cre1997]_
+
+- [SW2013]_
+
+AUTHORS:
+
+- William Stein (2007): first version
+
+- Chris Wuthrich (2008): add scaling and reference to eclib
+
+- John Cremona (2016): reworked eclib interface
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2007 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.arith.misc import (kronecker as kronecker_symbol,
+                             next_prime,
+                             prime_divisors,
+                             valuation)
+from sage.databases.cremona import parse_cremona_label
+from sage.misc.verbose import verbose
+from sage.modular.cusps import Cusps
+from sage.modular.modsym.all import ModularSymbols
+from sage.rings.infinity import unsigned_infinity as infinity
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+from sage.rings.rational_field import QQ
+from sage.structure.sage_object import SageObject
+
+from .constructor import EllipticCurve
+
+
+oo = Cusps(infinity)
+zero = Integer(0)
+
+
+def modular_symbol_space(E, sign, base_ring, bound=None):
+    r"""
+    Create the space of modular symbols of a given sign over a give base_ring,
+    attached to the isogeny class of the elliptic curve ``E``.
+
+    INPUT:
+
+    - ``E`` -- an elliptic curve over `\QQ`
+    - ``sign`` -- integer; -1, 0, or 1
+    - ``base_ring`` -- ring
+    - ``bound`` -- (default: ``None``) maximum number of Hecke operators to
+      use to cut out modular symbols factor.  If ``None``, use
+      enough to provably get the correct answer.
+
+    OUTPUT: a space of modular symbols
+
+    EXAMPLES::
+
+        sage: from sage.schemes.elliptic_curves.ell_modular_symbols import modular_symbol_space
+        sage: E = EllipticCurve('11a1')
+        sage: M = modular_symbol_space(E, -1, GF(37))
+        sage: M
+        Modular Symbols space of dimension 1 for Gamma_0(11) of weight 2 with sign -1
+         over Finite Field of size 37
+    """
+    if sign not in [-1, 0, 1]:
+        raise TypeError('sign must -1, 0 or 1')
+    N = E.conductor()
+    M = ModularSymbols(N, sign=sign, base_ring=base_ring)
+    if bound is None:
+        bound = M.hecke_bound() + 10
+    V = M
+    p = 2
+    target_dim = 1 if sign else 2
+    while p <= bound and V.dimension() > target_dim:
+        t = V.T(p)
+        ap = E.ap(p)
+        V = (t - ap).kernel()
+        p = next_prime(p)
+
+    return V
+
+
+class ModularSymbol(SageObject):
+    r"""
+    A modular symbol attached to an elliptic curve, which is the map
+    `\QQ\to \QQ` obtained by sending `r` to the normalized
+    symmetrized (or anti-symmetrized) integral `\infty` to `r`.
+
+    This is as defined in [MTT1986]_, but normalized to depend on the curve
+    and not only its isogeny class as in [SW2013]_.
+
+    See the documentation of ``E.modular_symbol()`` in elliptic curves
+    over the rational numbers for help.
+    """
+
+    def sign(self):
+        r"""
+        Return the sign of this elliptic curve modular symbol.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol()                            # needs eclib
+            sage: m.sign()                                                              # needs eclib
+            1
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('11a1').modular_symbol(sign=-1, implementation='sage')
+            sage: m.sign()
+            -1
+        """
+        return self._sign
+
+    def elliptic_curve(self):
+        r"""
+        Return the elliptic curve of this modular symbol.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol()                            # needs eclib
+            sage: m.elliptic_curve()                                                    # needs eclib
+            Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+        """
+        return self._E
+
+    def base_ring(self):
+        r"""
+        Return the base ring for this modular symbol.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol()                            # needs eclib
+            sage: m.base_ring()                                                         # needs eclib
+            Rational Field
+        """
+        return self._base_ring
+
+    def _repr_(self):
+        r"""
+        String representation of modular symbols.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol()                            # needs eclib
+            sage: m                                                                     # needs eclib
+            Modular symbol with sign 1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('43a1').modular_symbol(sign=-1, implementation='sage')
+            sage: m
+            Modular symbol with sign -1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 + x^2 over Rational Field
+        """
+        return "Modular symbol with sign %s over %s attached to %s" % (
+            self._sign, self._base_ring, self._E)
+
+
+class ModularSymbolECLIB(ModularSymbol):
+    def __init__(self, E, sign, nap=1000):
+        r"""Modular symbols attached to `E` using ``eclib``.
+
+        Note that the normalization used within ``eclib`` differs from the
+        normalization chosen here by a factor of 2 in the case of elliptic
+        curves with negative discriminant (with one real component) since
+        the convention there is to write the above integral as
+        `[r]^{+}x+[r]^{-}yi`, where the lattice is `\left<2x,x+yi\right>`,
+        so that `\Omega^{+}=2x` and `\Omega^{-}=2yi`.  We
+        allow for this below.
+
+        INPUT:
+
+        - ``E`` -- an elliptic curve
+
+        - ``sign`` -- integer; -1 or 1
+
+        - ``nap`` -- integer (default: 1000); the number of ap of E to use
+          in determining the normalisation of the modular symbols
+
+        EXAMPLES::
+
+            sage: # needs eclib
+            sage: from sage.schemes.elliptic_curves.ell_modular_symbols import ModularSymbolECLIB
+            sage: E = EllipticCurve('11a1')
+            sage: M = ModularSymbolECLIB(E,+1)
+            sage: M
+            Modular symbol with sign 1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+            sage: M(0)
+            1/5
+            sage: E = EllipticCurve('11a2')
+            sage: M = ModularSymbolECLIB(E,+1)
+            sage: M(0)
+            1
+
+        This is a rank 1 case with vanishing positive twists::
+
+            sage: # needs eclib
+            sage: E = EllipticCurve('121b1')
+            sage: M = ModularSymbolECLIB(E,+1)
+            sage: M(0)
+            0
+            sage: M(1/7)
+            1/2
+
+            sage: M = EllipticCurve('121d1').modular_symbol(implementation='eclib')     # needs eclib
+            sage: M(0)                                                                  # needs eclib
+            2
+
+            sage: E = EllipticCurve('15a1')                                             # needs eclib
+            sage: [C.modular_symbol(implementation='eclib')(0) for C in E.isogeny_class()]  # needs eclib
+            [1/4, 1/8, 1/4, 1/2, 1/8, 1/16, 1/2, 1]
+
+        Since :issue:`10256`, the interface for negative modular symbols in eclib is available::
+
+            sage: # needs eclib
+            sage: E = EllipticCurve('11a1')
+            sage: Mplus = E.modular_symbol(+1); Mplus
+            Modular symbol with sign 1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+            sage: [Mplus(1/i) for i in [1..11]]
+            [1/5, -4/5, -3/10, 7/10, 6/5, 6/5, 7/10, -3/10, -4/5, 1/5, 0]
+            sage: Mminus = E.modular_symbol(-1); Mminus
+            Modular symbol with sign -1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+            sage: [Mminus(1/i) for i in [1..11]]
+            [0, 0, 1/2, 1/2, 0, 0, -1/2, -1/2, 0, 0, 0]
+
+        The scaling factor relative to eclib's normalization is 1/2 for curves of negative discriminant::
+
+            sage: [E.discriminant() for E in cremona_curves([14])]                      # needs eclib
+            [-21952, 941192, -1835008, -28, 25088, 98]
+            sage: [E.modular_symbol()._scaling for E in cremona_curves([14])]           # needs eclib
+            [1/2, 1, 1/2, 1/2, 1, 1]
+
+        TESTS (for :issue:`10236`)::
+
+            sage: # needs eclib
+            sage: E = EllipticCurve('11a1')
+            sage: m = E.modular_symbol(implementation='eclib')
+            sage: m(1/7)
+            7/10
+            sage: m(0)
+            1/5
+
+        If ``nap`` is too small, the normalization in eclib used to be
+        incorrect (see :issue:`31317`), but since ``eclib`` version
+        v20210310 the value of ``nap`` is increased automatically by
+        ``eclib``::
+
+            sage: # needs eclib
+            sage: from sage.schemes.elliptic_curves.ell_modular_symbols import ModularSymbolECLIB
+            sage: E = EllipticCurve('1590g1')
+            sage: m = ModularSymbolECLIB(E, sign=+1, nap=300)
+            sage: [m(a/5) for a in [1..4]]
+            [13/2, -13/2, -13/2, 13/2]
+
+        These values are correct, and increasing ``nap`` has no
+        effect.  The correct values may verified by the numerical
+        implementation::
+
+            sage: # needs eclib
+            sage: m = ModularSymbolECLIB(E, sign=+1, nap=400)
+            sage: [m(a/5) for a in [1..4]]
+            [13/2, -13/2, -13/2, 13/2]
+            sage: m = E.modular_symbol(implementation='num')
+            sage: [m(a/5) for a in [1..4]]
+            [13/2, -13/2, -13/2, 13/2]
+        """
+        from sage.libs.eclib.newforms import ECModularSymbol
+
+        if sign not in [-1, 1]:
+            raise TypeError('sign must -1 or 1')
+        self._sign = ZZ(sign)
+        self._E = E
+        self._scaling = 1 if E.discriminant() > 0 else ZZ(1)/2
+        self._implementation = "eclib"
+        self._base_ring = QQ
+        # The ECModularSymbol class must be initialized with sign=0 to compute minus symbols
+        self._modsym = ECModularSymbol(E, int(sign == 1), nap)
+        self.cache = {True: {}, False: {}}
+
+    def _call_with_caching(self, r, base_at_infinity=True):
+        r"""
+        Evaluates the modular symbol at {0,`r`} or {oo,`r`}, caching the computed value.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol(implementation='eclib')      # needs eclib
+            sage: m._call_with_caching(0)                                               # needs eclib
+            1/5
+        """
+        cache = self.cache[base_at_infinity]
+        try:
+            return cache[r]
+        except KeyError:
+            pass
+        c = self._modsym(r, sign=self._sign, base_at_infinity=base_at_infinity) * self._scaling
+        cache[r] = c
+        return c
+
+    def __call__(self, r, base_at_infinity=True):
+        r"""
+        Evaluates the modular symbol at {0,`r`} or {oo,`r`}.
+
+        EXAMPLES::
+
+            sage: m = EllipticCurve('11a1').modular_symbol(implementation='eclib')      # needs eclib
+            sage: m(0)                                                                  # needs eclib
+            1/5
+        """
+        from sage.rings.rational import Rational
+        if r != oo:
+            r = Rational(r)
+            r = r.numer() % r.denom() / r.denom()
+        return self._modsym(r, sign=self._sign, base_at_infinity=base_at_infinity) * self._scaling
+
+
+class ModularSymbolSage(ModularSymbol):
+    def __init__(self, E, sign, normalize='L_ratio'):
+        """Modular symbols attached to `E` using ``sage``.
+
+        INPUT:
+
+        - ``E`` -- an elliptic curve
+        - ``sign`` -- integer; -1 or 1
+        - ``normalize`` -- either ``'L_ratio'`` (default), ``'period'``, or
+          ``'none'``; For ``'L_ratio'``, the modular symbol is correctly
+          normalized by comparing it to the quotient of `L(E,1)` by
+          the least positive period for the curve and some small
+          twists.  The normalization ``'period'`` uses the
+          integral_period_map for modular symbols and is known to be
+          equal to the above normalization up to the sign and a
+          possible power of 2.  For ``'none'``, the modular symbol is
+          almost certainly not correctly normalized, i.e. all values
+          will be a fixed scalar multiple of what they should be.  But
+          the initial computation of the modular symbol is much
+          faster, though evaluation of it after computing it won't be
+          any faster.
+
+        EXAMPLES::
+
+            sage: # needs sage.graphs
+            sage: E = EllipticCurve('11a1')
+            sage: from sage.schemes.elliptic_curves.ell_modular_symbols import ModularSymbolSage
+            sage: M = ModularSymbolSage(E, +1)
+            sage: M
+            Modular symbol with sign 1 over Rational Field attached to
+             Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational Field
+            sage: M(0)
+            1/5
+            sage: E = EllipticCurve('11a2')
+            sage: M = ModularSymbolSage(E, +1)
+            sage: M(0)
+            1
+            sage: M = ModularSymbolSage(E, -1)
+            sage: M(1/3)
+            1/2
+
+        This is a rank 1 case with vanishing positive twists.
+        The modular symbol is adjusted by -2::
+
+            sage: # needs sage.graphs
+            sage: E = EllipticCurve('121b1')
+            sage: M = ModularSymbolSage(E, -1, normalize='L_ratio')
+            sage: M(1/3)
+            1
+            sage: M._scaling
+            1
+
+            sage: # needs sage.graphs
+            sage: M = EllipticCurve('121d1').modular_symbol(implementation='sage')
+            sage: M(0)
+            2
+            sage: M = EllipticCurve('121d1').modular_symbol(implementation='sage',
+            ....:                                           normalize='none')
+            sage: M(0)
+            1
+
+            sage: # needs sage.graphs
+            sage: E = EllipticCurve('15a1')
+            sage: [C.modular_symbol(implementation='sage', normalize='L_ratio')(0)
+            ....:  for C in E.isogeny_class()]
+            [1/4, 1/8, 1/4, 1/2, 1/8, 1/16, 1/2, 1]
+            sage: [C.modular_symbol(implementation='sage', normalize='period')(0)
+            ....:  for C in E.isogeny_class()]
+            [1/8, 1/16, 1/8, 1/4, 1/16, 1/32, 1/4, 1/2]
+            sage: [C.modular_symbol(implementation='sage', normalize='none')(0)
+            ....:  for C in E.isogeny_class()]
+            [1, 1, 1, 1, 1, 1, 1, 1]
+        """
+        if sign not in [-1, 1]:
+            raise TypeError('sign must -1 or 1')
+        self._sign = ZZ(sign)
+        self._E = E
+        self._implementation = "sage"
+        self._normalize = normalize
+        self._modsym = E.modular_symbol_space(sign=self._sign)
+        self._base_ring = self._modsym.base_ring()
+        self._ambient_modsym = self._modsym.ambient_module()
+
+        if normalize == "L_ratio":
+            self._e = self._modsym.dual_eigenvector()
+            self._find_scaling_L_ratio()
+            if self._failed_to_scale:
+                self._find_scaling_period()  # will reset _e and _scaling
+            else:
+                self._e *= self._scaling
+        elif normalize == "period" :
+            self._find_scaling_period()      # this will set _e and _scaling
+        elif normalize == "none":
+            self._scaling = 1
+            self._e = self._modsym.dual_eigenvector()
+        else :
+            raise ValueError("no normalization %s known for modular symbols" % normalize)
+
+    def _find_scaling_L_ratio(self):
+        r"""
+        This function is use to set ``_scaling``, the factor used to adjust the
+        scalar multiple of the modular symbol.
+        If `[0]`, the modular symbol evaluated at 0, is nonzero, we can just scale
+        it with respect to the approximation of the L-value. It is known that
+        the quotient is a rational number with small denominator.
+        Otherwise we try to scale using quadratic twists.
+
+        ``_scaling`` will be set to a rational nonzero multiple if we succeed and to 1 otherwise.
+        Even if we fail we scale at least to make up the difference between the periods
+        of the `X_0`-optimal curve and our given curve `E` in the isogeny class.
+
+        EXAMPLES::
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('11a1').modular_symbol(implementation='sage')
+            sage: m._scaling
+            1/5
+            sage: m = EllipticCurve('11a2').modular_symbol(implementation='sage')
+            sage: m._scaling
+            1
+            sage: m = EllipticCurve('11a3').modular_symbol(implementation='sage')
+            sage: m._scaling
+            1/25
+            sage: m = EllipticCurve('37a1').modular_symbol(implementation='sage')
+            sage: m._scaling
+            -1
+            sage: m = EllipticCurve('37a1').modular_symbol()
+            sage: m._scaling
+            1
+            sage: m = EllipticCurve('389a1').modular_symbol()
+            sage: m._scaling
+            1
+            sage: m = EllipticCurve('389a1').modular_symbol(implementation='sage')
+            sage: m._scaling
+            1
+            sage: m = EllipticCurve('196a1').modular_symbol(implementation='sage')
+            sage: m._scaling
+            1
+
+        Some harder cases fail::
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('121b1').modular_symbol(implementation='sage')
+            Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2
+            sage: m._scaling
+            1
+
+        TESTS::
+
+            sage: # needs sage.graphs
+            sage: rk0 = ['11a1', '11a2', '15a1', '27a1', '37b1']
+            sage: for la in rk0:  # long time (3s on sage.math, 2011)
+            ....:          E = EllipticCurve(la)
+            ....:          me = E.modular_symbol(implementation='eclib')
+            ....:          ms = E.modular_symbol(implementation='sage')
+            ....:          print("{} {} {}".format(E.lseries().L_ratio()*E.real_components(), me(0), ms(0)))
+            1/5 1/5 1/5
+            1 1 1
+            1/4 1/4 1/4
+            1/3 1/3 1/3
+            2/3 2/3 2/3
+
+            sage: # needs sage.graphs
+            sage: rk1 = ['37a1','43a1','53a1', '91b1','91b2','91b3']
+            sage: [EllipticCurve(la).modular_symbol()(0) for la in rk1]  # long time (1s on sage.math, 2011)
+            [0, 0, 0, 0, 0, 0]
+            sage: for la in rk1:  # long time (8s on sage.math, 2011)
+            ....:       E = EllipticCurve(la)
+            ....:       m = E.modular_symbol()
+            ....:       lp = E.padic_lseries(5)
+            ....:       for D in [5,17,12,8]:
+            ....:           ED = E.quadratic_twist(D)
+            ....:           md = sum([kronecker(D,u)*m(ZZ(u)/D) for u in range(D)])
+            ....:           etaD = lp._quotient_of_periods_to_twist(D)
+            ....:           assert ED.lseries().L_ratio()*ED.real_components() * etaD == md
+        """
+        E = self._E
+        self._scaling = 1 # initial value, may be changed later.
+        self._failed_to_scale = False
+
+        if self._sign == 1 :
+            at0 = self(0)
+            if at0 != 0 :
+                l1 = self.__lalg__(1)
+                if at0 != l1:
+                    verbose('scale modular symbols by %s' % (l1/at0))
+                    self._scaling = l1/at0
+            else :
+                # if [0] = 0, we can still hope to scale it correctly by considering twists of E
+                Dlist = [5,8,12,13,17,21,24,28,29, 33, 37, 40, 41, 44, 53, 56, 57, 60, 61, 65, 69, 73, 76, 77, 85, 88, 89, 92, 93, 97]  # a list of positive fundamental discriminants
+                j = 0
+                at0 = 0
+                # computes [0]+ for the twist of E by D until one value is nonzero
+                while j < 30 and at0 == 0 :
+                    D = Dlist[j]
+                    # the following line checks if the twist of the newform of E by D is a newform
+                    # this is to avoid that we 'twist back'
+                    if all( valuation(E.conductor(),ell) <= valuation(D,ell) for ell in prime_divisors(D) ) :
+                        at0 = sum([kronecker_symbol(D,u) * self(ZZ(u)/D) for u in range(1,abs(D))])
+                    j += 1
+                if j == 30 and at0 == 0: # curves like "121b1", "225a1", "225e1", "256a1", "256b1", "289a1", "361a1", "400a1", "400c1", "400h1", "441b1", "441c1", "441d1", "441f1 .. will arrive here
+                    print("Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2")
+                    self._failed_to_scale = True
+                else :
+                    l1 = self.__lalg__(D)
+                    if at0 != l1:
+                        verbose('scale modular symbols by %s found at D=%s ' % (l1/at0,D), level=2)
+                        self._scaling = l1/at0
+
+        else : # that is when sign = -1
+            Dlist = [-3,-4,-7,-8,-11,-15,-19,-20,-23,-24, -31, -35, -39, -40, -43, -47, -51, -52, -55, -56, -59, -67, -68, -71, -79, -83, -84, -87, -88, -91]  # a list of negative fundamental discriminants
+            j = 0
+            at0 = 0
+            while j < 30 and at0 == 0 :
+                # computes [0]+ for the twist of E by D until one value is nonzero
+                D = Dlist[j]
+                if all( valuation(E.conductor(),ell) <= valuation(D,ell) for ell in prime_divisors(D) ) :
+                    at0 = - sum([kronecker_symbol(D,u) * self(ZZ(u)/D) for u in range(1,abs(D))])
+                j += 1
+            if j == 30 and at0 == 0: # no more hope for a normalization
+                print("Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by -1 and a power of 2")
+                self._failed_to_scale = True
+            else :
+                l1 = self.__lalg__(D)
+                if at0 != l1:
+                    verbose('scale modular symbols by %s' % (l1/at0))
+                    self._scaling = l1/at0
+
+    def __lalg__(self, D):
+        r"""
+        For positive `D`, this function evaluates the quotient
+        `L(E_D,1)\cdot \sqrt(D)/\Omega_E` where `E_D` is the twist of
+        `E` by `D`, `\Omega_E` is the least positive period of `E`.
+
+        For negative `E`, it is the quotient
+        `L(E_D,1)\cdot \sqrt(-D)/\Omega^{-}_E`
+        where `\Omega^{-}_E` is the least positive imaginary part of a
+        non-real period of `E`.
+
+        EXAMPLES::
+
+            sage: # needs sage.graphs
+            sage: E = EllipticCurve('11a1')
+            sage: m = E.modular_symbol(sign=+1, implementation='sage')
+            sage: m.__lalg__(1)
+            1/5
+            sage: m.__lalg__(3)
+            5/2
+        """
+        from sage.misc.functional import sqrt
+        # the computation of the L-value could take a lot of time,
+        # but then the conductor is so large
+        # that the computation of modular symbols for E took even longer
+
+        E = self._E
+        ED = E.quadratic_twist(D)
+        lv = ED.lseries().L_ratio()  # this is L(ED,1) divided by the Néron period omD of ED
+        lv *= ED.real_components()  # now it is by the least positive period
+        omD = ED.period_lattice().basis()[0]
+        if D > 0 :
+            om = E.period_lattice().basis()[0]
+            q = sqrt(D) * omD / om * 8
+        else :
+            om = E.period_lattice().basis()[1].imag()
+            if E.real_components() == 1:
+                om *= 2
+            q = sqrt(-D) * omD / om * 8
+
+        # see padic_lseries.pAdicLeries._quotient_of_periods_to_twist
+        # for the explanation of the second factor
+        verbose('real approximation is %s' % q)
+        return lv / 8 * QQ(q.round())
+
+    def _find_scaling_period(self):
+        r"""
+        Uses the integral period map of the modular symbol implementation in sage
+        in order to determine the scaling. The resulting modular symbol is correct
+        only for the `X_0`-optimal curve, at least up to a possible factor +- a
+        power of 2.
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve('11a1')
+            sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
+            sage: m._e
+            (1/5, 1/2)
+            sage: E = EllipticCurve('11a2')
+            sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
+            sage: m._e
+            (1, 5/2)
+            sage: E = EllipticCurve('121b2')
+            sage: m = sage.schemes.elliptic_curves.ell_modular_symbols.ModularSymbolSage(E,+1,normalize='period')
+            sage: m._e
+            (0, 0, 0, 11/2, 11/2, 11/2, 11/2, -3, 3/2, 1/2, -1, 2)
+
+        TESTS::
+
+            sage: E = EllipticCurve('19a1')
+            sage: m = E.modular_symbol(sign=+1, implementation='sage', normalize='none')
+            sage: m._find_scaling_period()
+            sage: m._scaling
+            1
+
+            sage: E = EllipticCurve('19a2')
+            sage: m = E.modular_symbol(sign=+1, implementation='sage', normalize='none')
+            sage: m._scaling
+            1
+            sage: m._find_scaling_period()
+            sage: m._scaling
+            3
+        """
+        P = self._modsym.integral_period_mapping()
+        self._e = P.matrix().transpose().row(0)
+        self._e /= 2
+        E = self._E
+        try :
+            crla = parse_cremona_label(E.label())
+        except RuntimeError: # raised when curve is outside of the table
+            print("Warning : Could not normalize the modular symbols, maybe all further results will be multiplied by a rational number.")
+            self._scaling = 1
+        else :
+            cr0 = Integer(crla[0]).str() + crla[1] + '1'
+            E0 = EllipticCurve(cr0)
+            if self._sign == 1:
+                q = E0.period_lattice().basis()[0]/E.period_lattice().basis()[0]
+            else:
+                q = E0.period_lattice().basis()[1].imag()/E.period_lattice().basis()[1].imag()
+                if E0.real_components() == 1:
+                    q *= 2
+                if E.real_components() == 1:
+                    q /= 2
+            q = QQ((q * 200).round()) / 200
+            verbose('scale modular symbols by %s' % q)
+            self._scaling = q
+        c = self(0)  #  required, to change base point from oo to 0
+        if c < 0:
+            c *= -1
+            self._scaling *= -1
+        self._at_zero = c
+        self._e *= self._scaling
+
+    def _call_with_caching(self, r):
+        r"""
+        Evaluates the modular symbol at `r`, caching the computed value.
+
+        EXAMPLES::
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('11a1').modular_symbol(implementation='sage')
+            sage: m._call_with_caching(0)
+            1/5
+        """
+        try:
+            return self.__cache[r]
+        except AttributeError:
+            self.__cache = {}
+        except KeyError:
+            pass
+        w = self._ambient_modsym([oo,r]).element()
+        c = (self._e).dot_product(w)
+        self.__cache[r] = c
+        return c
+
+    def __call__(self, r, base_at_infinity=True):
+        r"""
+        Evaluates the modular symbol at {0,`r`} or {oo,`r`}.
+
+        EXAMPLES::
+
+            sage: # needs sage.graphs
+            sage: m = EllipticCurve('11a1').modular_symbol(implementation='sage')
+            sage: m(0)
+            1/5
+        """
+        # this next line takes most of the time  # zero = weight-2
+        w = self._ambient_modsym.modular_symbol([zero, oo, Cusps(r)], check=False)
+        c = (self._e).dot_product(w.element())
+        if not base_at_infinity:
+            if self._at_zero is None:
+                self._at_zero = self(0)
+            c -= self._at_zero
+        return c