Changeset 12827:5e7aa739cec0


Ignore:
Timestamp:
08/11/09 00:30:36 (4 years ago)
Author:
Minh Van Nguyen <nguyenminh2@…>
Branch:
default
Message:

trac 6731: spell-check all modules under sage/schemes

Location:
sage/schemes
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • sage/schemes/all.py

    r4851 r12827  
    11"""nodoctest 
    2 all.py -- export of schemes to SAGE 
     2all.py -- export of schemes to Sage 
    33""" 
    44 
    55#***************************************************************************** 
    66# 
    7 #   SAGE: System for Algebra and Geometry Experimentation     
     7#   Sage: System for Algebra and Geometry Experimentation     
    88# 
    99#       Copyright (C) 2005 William Stein <wstein@gmail.com> 

  • sage/schemes/elliptic_curves/ell_curve_isogeny.py

    r12448 r12827  
    9595    OUTPUT: 
    9696 
    97     (elliptic curve) the codomain of the seperable normalized isogeny from this kernel 
     97    (elliptic curve) the codomain of the separable normalized isogeny from this kernel 
    9898 
    9999    EXAMPLES:: 
    … …  
    678678    # 
    679679 
    680     # we keep track of the 2 torsion and non2torsion seperately 
     680    # we keep track of the 2 torsion and non2torsion separately 
    681681    __kernel_2tor = None 
    682682    __kernel_non2tor = None 
    … …  
    710710                          If initiating from a domain/codomain, this must be set to None. 
    711711        - ``codomain``  - an elliptic curve (default:None).  If ``kernel`` is None, 
    712                           then this must be the codomain of a seperable normalized isogeny, 
     712                          then this must be the codomain of a separable normalized isogeny, 
    713713                          furthermore, ``degree`` must be the degree of the isogeny from ``E`` to ``codomain``. 
    714714                          If ``kernel`` is not None, then this must be isomorphic to the codomain of the  
    715                           normalized seperable isogeny defined by ``kernel``,  
     715                          normalized separable isogeny defined by ``kernel``,  
    716716                          in this case, the isogeny is post composed with an isomorphism so that this parameter is the codomain. 
    717717        - ``degree``    - an integer (default:None). 
    718718                          If ``kernel`` is None, then this is the degree of the isogeny from ``E`` to ``codomain``. 
    719                           If ``kernel`` is not None, then this is used to determine wether or not to skip a gcd  
     719                          If ``kernel`` is not None, then this is used to determine whether or not to skip a gcd  
    720720                          of the kernel polynomial with the two torsion polynomial of ``E``. 
    721         - ``model``     - a string (defaul:None).  Only supported variable is "minimal", in which case if  
     721        - ``model``     - a string (default:None).  Only supported variable is "minimal", in which case if  
    722722                          ``E`` is a curve over the rationals, then the codomain is set to be the unique global minimum model. 
    723723        - ``algorithm`` - a string (default:None).  If this parameter is None, then the algorithm is determined from the input. 
    … …  
    840840        if (E1 != E_P): 
    841841            if (E1.a_invariants() != E_P.a_invariants()) : 
    842                 raise ValueError, "P must be on a curve with same weierstrass model as the domain curve of this isogeny." 
     842                raise ValueError, "P must be on a curve with same Weierstrass model as the domain curve of this isogeny." 
    843843            change_output_ring = True 
    844844 
    … …  
    13141314        self.__pre_isomorphism = isomorphism 
    13151315 
    1316         # calculuate the isomorphism as a rational map. 
     1316        # calculate the isomorphism as a rational map. 
    13171317 
    13181318        (u, r, s, t) = isomorphism.tuple() 
    … …  
    13621362        self.__post_isomorphism = isomorphism 
    13631363 
    1364         # calculuate the isomorphism as a rational map. 
     1364        # calculate the isomorphism as a rational map. 
    13651365 
    13661366        (u, r, s, t) = isomorphism.tuple() 
    … …  
    17751775 
    17761776    ################################### 
    1777     # Kohel's Variant of Velu's Forumla 
     1777    # Kohel's Variant of Velu's Formula 
    17781778    ################################### 
    17791779 
    … …  
    18661866        EXAMPLES: 
    18671867 
    1868         These examples inherentl exercise this private function:: 
     1868        These examples inherently exercise this private function:: 
    18691869 
    18701870            sage: R.<x> = GF(7)[] 
    … …  
    22212221    def __compute_via_kohel(self, xP, yP): 
    22222222        r""" 
    2223         Private function that applies Kohel's fomulas. 
     2223        Private function that applies Kohel's formulas. 
    22242224 
    22252225        EXAMPLES: 
    … …  
    25712571            True 
    25722572 
    2573         Example over a numberfield:: 
     2573        Example over a number field:: 
    25742574 
    25752575            sage: R.<x> = QQ[] 
    … …  
    28542854        # or if it is a just a translation. 
    28552855        # NOTE: This only works because we are using algorithms for calculating the isogenies that calculate  
    2856         # a seperable normalized isogeny, if this changes, this check will no longer be correct. 
     2856        # a separable normalized isogeny, if this changes, this check will no longer be correct. 
    28572857        # 
    28582858        if (check_prepost_isomorphism): 
    … …  
    31153115            Traceback (most recent call last): 
    31163116            ... 
    3117             NotImplementedError: Numerical approximations do not make sense for Elliptic Curve Isogeies 
    3118  
    3119         """ 
    3120         raise NotImplementedError, "Numerical approximations do not make sense for Elliptic Curve Isogeies" 
     3117            NotImplementedError: Numerical approximations do not make sense for Elliptic Curve Isogenies 
     3118 
     3119        """ 
     3120        raise NotImplementedError, "Numerical approximations do not make sense for Elliptic Curve Isogenies" 
    31213121 
    31223122 
    … …  
    34613461    ALGORITHM: 
    34623462     
    3463     algorithm "fast" uses newton iteration and has complexity O(M(n)), algorithm "quadratic" has compexity O(n*M(n)) 
     3463    algorithm "fast" uses newton iteration and has complexity O(M(n)), algorithm "quadratic" has complexity O(n*M(n)) 
    34643464 
    34653465    EXAMPLES:: 
    … …  
    34793479        trunc_exp = truncated_exp_fast(f, n) 
    34803480    else: 
    3481         raise ValueError, "Unknown algorithm for computing truncated expoential." 
     3481        raise ValueError, "Unknown algorithm for computing truncated exponential." 
    34823482 
    34833483    return trunc_exp 
    … …  
    35373537     
    35383538     - ``poly_ring`` - polynomial ring, to compute the `\wp` function in (assumes that the generator is `z^2` for efficiency of storage/operations.) 
    3539      - ``A``         - field element corresponding to the `x` coefficient in the weierstrass equaation of an elliptic curve 
    3540      - ``B``         - field element corresponding to the constant coefficient in the weierstrass equation of an ellitpic curve 
     3539     - ``A``         - field element corresponding to the `x` coefficient in the weierstrass equation of an elliptic curve 
     3540     - ``B``         - field element corresponding to the constant coefficient in the weierstrass equation of an elliptic curve 
    35413541     - ``ell``       - degree of `z` to compute the truncated function to.  If `p` is the characteristic of the underlying field.     If `p > 0` then we must have `2\ell + 3 < p`.  
    35423542 
    … …  
    35953595     
    35963596     - ``poly_ring`` - polynomial ring, to compute the function in (assumes that the generator is `z^2` for efficiency of storage/operations.) 
    3597      - ``A``         - field element corresponding to the `x` coefficient in the weierstrass equaation of an elliptic curve 
    3598      - ``B``         - field element corresponding to the constant coefficient in the weierstrass equation of an ellitpic curve 
     3597     - ``A``         - field element corresponding to the `x` coefficient in the weierstrass equation of an elliptic curve 
     3598     - ``B``         - field element corresponding to the constant coefficient in the weierstrass equation of an elliptic curve 
    35993599     - ``ell``       - degree of `z` to compute the truncated function to.  If `p` is the characteristic of the underlying field and `p > 0`, then we must have `2\ell + 3 < p`.  
    36003600 
    … …  
    38083808    r""" 
    38093809    Computes the degree ``ell`` isogeny between ``E1`` and ``E2`` via 
    3810     Stark's algorithm.  There must be a degree ``ell``, seperable, 
     3810    Stark's algorithm.  There must be a degree ``ell``, separable, 
    38113811    normalized isogeny from ``E1`` to ``E2``. 
    38123812 
    … …  
    39533953    Given a full kernel polynomial (where two torsion `x`-coordinates 
    39543954    are roots of multiplicity 1, and all other roots have multiplicity 
    3955     2.)  of degree `\ell-1`, returns the maximum seperable divisor. 
     3955    2.)  of degree `\ell-1`, returns the maximum separable divisor. 
    39563956    (i.e. the kernel polynomial with roots of multiplicity at most 1). 
    39573957     
    … …  
    39913991    Computes the degree ``ell`` isogeny between ``E1`` and ``E2``. 
    39923992 
    3993     There must be a degree ``ell``, seperable, normalized isogeny from 
     3993    There must be a degree ``ell``, separable, normalized isogeny from 
    39943994    ``E1`` to ``E2``.  If no algorithm is specified, this function 
    39953995    determines the best algorithm to use. 
    … …  
    40044004 
    40054005    - ``algorithm`` - string (default:"starks") if None, this function automatically determines best algorithm to use. 
    4006                    Otherwise uses the algorithm specified by the string.  Valid valuse are "starks" or "fastElkies" 
     4006                   Otherwise uses the algorithm specified by the string.  Valid values are "starks" or "fastElkies" 
    40074007 
    40084008    OUTPUT: 
    … …  
    40474047    # 
    40484048    # Everything that follows here is how we get the kernel polynomial in the form we want 
    4049     # i.e. a seperable polynomial (no repeated roots.) 
     4049    # i.e. a separable polynomial (no repeated roots.) 
    40504050    # 
    40514051    ker_poly = split_kernel_polynomial(E1, ker_poly, ell) 
    … …  
    41404140    intermediate_domain = pre_isom.codomain().codomain() 
    41414141 
    4142     # compute the r,s,t valuse that clear the denominator of E2 
     4142    # compute the r,s,t values that clear the denominator of E2 
    41434143    a1pr = E2.a1() 
    41444144    a2pr = E2.a2() 
    … …  
    41594159def compute_sequence_of_maps(E1, E2, ell): 
    41604160    r""" 
    4161     Given domain ``E1`` and codomain ``E2`` such that there is a degree ``ell`` seperable normalized isogeny from ``E1`` to ``E2``,    returns pre/post isomorphism, as well as intermediate domain and codomain, and kernel polynomial. 
     4161    Given domain ``E1`` and codomain ``E2`` such that there is a degree ``ell`` separable normalized isogeny from ``E1`` to ``E2``,    returns pre/post isomorphism, as well as intermediate domain and codomain, and kernel polynomial. 
    41624162 
    41634163    EXAMPLES:: 

  • sage/schemes/elliptic_curves/ell_egros.py

    r12728 r12827  
    3030Using the "proof=False" flag suppresses these warnings. 
    3131 
    32 EXAMPLES: We find all elliptic cruves with good reduction outside 2, 
     32EXAMPLES: We find all elliptic curves with good reduction outside 2, 
    3333listing the label of each: 
    3434 
    … …  
    6262printed without proof=False (unless the optional database is 
    6363installed: two of the auxiliary curves whose Mordell-Weil bases are 
    64 required have conductors 13068 and 52272 so are in the databse): 
     64required have conductors 13068 and 52272 so are in the database): 
    6565 
    6666    sage: [e.label() for e in EllipticCurves_with_good_reduction_outside_S([11], proof=False)] 
    … …  
    307307        is undefined if S is not a list or contains non-primes. 
    308308 
    309     OUPUT: 
     309    OUTPUT: 
    310310 
    311311        A sorted list of all elliptic curves defined over `Q` with 
    … …  
    413413        E = EllipticCurve([0,0,0,0,a6]) 
    414414        # This curve may not be minimal at 2 or 3, but the 
    415         # S-integral_points function requires minimalilty at primes in 
     415        # S-integral_points function requires minimality at primes in 
    416416        # S, so we find a new model which is p-minimal at both 2 and 3 
    417417        # if they are in S.  Note that the isomorphism between models 

  • sage/schemes/elliptic_curves/ell_field.py

    r12740 r12827  
    6767        the curve returned is the unique curve (up to isomorphism) 
    6868        defined over `F` isomorphic to the original curve over the 
    69         quadratic extension of `F` but not over `F` itself.  Over infinte 
     69        quadratic extension of `F` but not over `F` itself.  Over infinite 
    7070        fields, an error is raised if `D` is not given. 
    7171 
    … …  
    555555                          If initiating from a domain/codomain, this must be set to None. 
    556556        - ``codomain``  - an elliptic curve (default:None).  If ``kernel`` is None, 
    557                           then this must be the codomain of a seperable normalized isogeny, 
     557                          then this must be the codomain of a separable normalized isogeny, 
    558558                          furthermore, ``degree`` must be the degree of the isogeny from self to ``codomain``. 
    559559                          If ``kernel`` is not None, then this must be isomorphic to the codomain of the  
    560                           normalized seperable isogeny defined by ``kernel``,  
     560                          normalized separable isogeny defined by ``kernel``,  
    561561                          in this case, the isogeny is post composed with an isomorphism so that this parameter is the codomain. 
    562562        - ``degree``    - an integer (default:None). 
    563563                          If ``kernel`` is None, then this is the degree of the isogeny from self to ``codomain``. 
    564                           If ``kernel`` is not None, then this is used to determine wether or not to skip a gcd  
     564                          If ``kernel`` is not None, then this is used to determine whether or not to skip a GCD  
    565565                          of the kernel polynomial with the two torsion polynomial of self. 
    566         - ``model``     - a string (defaul:None).  Only supported variable is "minimal", in which case if  
     566        - ``model``     - a string (default:None).  Only supported variable is "minimal", in which case if  
    567567                          self is a curve over the rationals, then the codomain is set to be the unique global minimum model. 
    568568        - ``algorithm`` - a string (default:None).  If this parameter is None, then the algorithm is determined from the input. 
    … …  
    590590    def isogeny_codomain(self, kernel, degree=None, algorithm=None): 
    591591        r""" 
    592         Returns the codomain of the isogeny from self with givien kernel. 
     592        Returns the codomain of the isogeny from self with given kernel. 
    593593        This redirects to the isogeny_codomain_from_kernel function, 
    594594        see that function for more information. 
    … …  
    604604        OUTPUT: 
    605605 
    606         (elliptic curve) the codomain of the seperable normalized isogeny from this kernel 
     606        (elliptic curve) the codomain of the separable normalized isogeny from this kernel 
    607607 
    608608 

  • sage/schemes/elliptic_curves/ell_generic.py

    r12287 r12827  
    21202120            return (x, -y-a1*x-a3) 
    21212121 
    2122         # the x-coordonate does not depend on the sign of m.  The work 
     2122        # the x-coordinate does not depend on the sign of m.  The work 
    21232123        # here is done by functions defined earlier: 
    21242124 
    … …  
    22612261            Via:  (u,r,s,t) = (1, 0, 0, 0)] 
    22622262         
    2263         We can also find istomorphisms defined over extension fields:: 
     2263        We can also find isomorphisms defined over extension fields:: 
    22642264         
    22652265            sage: E=EllipticCurve(GF(7),[0,0,0,1,1]) 

  • sage/schemes/elliptic_curves/ell_modular_symbols.py

    r12287 r12827  
    202202        it with respect to the approximation of the L-value. It is known that 
    203203        the quotient is a rational number with small denominator. 
    204         Otherwise we try to scale using quardatic twists. 
     204        Otherwise we try to scale using quadratic twists. 
    205205 
    206206        ``_scaling`` will be set to a rational non-zero multiple if we succeed and to 1 otherwise. 

  • sage/schemes/elliptic_curves/ell_rational_field.py

    r12736 r12827  
    137137    EXAMPLES: 
    138138         
    139     Construction from Weierstrass coeffiecients (`a`-invariants), long form:: 
     139    Construction from Weierstrass coefficients (`a`-invariants), long form:: 
    140140         
    141141        sage: E = EllipticCurve([1,2,3,4,5]); E 
    142142        Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over Rational Field 
    143143         
    144     Construction from Weierstrass coeffiecients (`a`-invariants), 
     144    Construction from Weierstrass coefficients (`a`-invariants), 
    145145    short form (sets `a_1=a_2=a_3=0`):: 
    146146         
    … …  
    10031003        # 
    10041004        # E <--> [0, 1, 1, -2, 0]   389A 
    1005         #  E = EllipticCurve([0, 1, 1, -2, 0]);   // SAGE or MAGMA 
     1005        #  E = EllipticCurve([0, 1, 1, -2, 0]);   // Sage or MAGMA 
    10061006        #  e = E.pari_mincurve() 
    10071007        #  f = ellinit([0,1,1,-2,0]); 
    … …  
    10461046        OUTPUT:  
    10471047 
    1048         a power series (in th evariable 'q') 
     1048        a power series (in the variable 'q') 
    10491049         
    10501050        .. note:: 
    … …  
    31173117        so). Probably it could just round at some point. For rigour, you 
    31183118        would need to bound the tail by assuming (essentially) that all the 
    3119         `a_n` are as large as possible, but in practise they 
     3119        `a_n` are as large as possible, but in practice they 
    31203120        exhibit significant (square root) cancellation. One difficulty is 
    31213121        that it doesn't do the sum in 1-2-3-4 order; it uses 
    … …  
    39583958         
    39593959        This plots helps you see that the above Manin constants are 
    3960         right.  Note that the vertex labels are 0-based unlinke the 
     3960        right.  Note that the vertex labels are 0-based unlike the 
    39613961        Cremona isogeny labels:: 
    39623962 
    … …  
    50415041 
    50425042        We explicitly verify in the above example that indeed that 
    5043         index is divisibly by 2 by writing down a generator of  
     5043        index is divisible by 2 by writing down a generator of  
    50445044        E(QQ)/tor + E^D(QQ)/tor that is divisible by 2 in E(K):: 
    50455045 
    … …  
    52495249 
    52505250        #  - The regulator. 
    5251         #    First we compute the regualtor of the subgroup E(QQ) + E^D(QQ) 
     5251        #    First we compute the regulator of the subgroup E(QQ) + E^D(QQ) 
    52525252        #    of E(K).   The factor of 2 in the regulator  
    52535253        #    accounts for the fact that the height over K is twice the 
    … …  
    53345334    def _heegner_best_tau(self, D, prec=None): 
    53355335        """ 
    5336         Given a discrimanent `D`, find the Heegner point `\tau` in the  
     5336        Given a discriminant `D`, find the Heegner point `\tau` in the  
    53375337        upper half plane with largest imaginary part (which is optimal 
    53385338        for evaluating the modular parametrization). If the optional 
    … …  
    53615361        it is computed with ``prec`` bits of working precision, otherwise it  
    53625362        attempts to recognize it exactly over the Hilbert class field of `K`.  
    5363         In this  latter case, the answer is *not* proveably correct but a  
    5364         strong consistancy check is made.  
     5363        In this  latter case, the answer is *not* provably correct but a  
     5364        strong consistency check is made.  
    53655365         
    53665366        INPUT:: 
    … …  
    57445744            [-3, -2, -1, 0, 1, 2, 3, 4, 8, 11, 14, 21, 37, 52, 93] 
    57455745 
    5746         TODO: reimplement this using the much faster point searching 
     5746        TODO: re-implement this using the much faster point searching 
    57475747        implemented in Stoll's ``ratpoints`` program. 
    57485748 
    … …  
    65526552        c4, c6 = E.c_invariants() 
    65536553        disc = E.discriminant() 
    6554         #internal function is doing only a comparision of E and E.short_weierstass_model() so the following is easier 
     6554        #internal function is doing only a comparison of E and E.short_weierstass_model() so the following is easier 
    65556555        if a1 == a2 == a3 == 0: 
    65566556            is_short = True 

  • sage/schemes/elliptic_curves/ell_tate_curve.py

    r12102 r12827  
    2828- William Stein (2007-05-29): added some examples; editing. 
    2929 
    30 - chris wuthrich (04/09): reformated docstrings. 
     30- chris wuthrich (04/09): reformatted docstrings. 
    3131 
    3232""" 

  • sage/schemes/elliptic_curves/ell_torsion.py

    r12224 r12827  
    117117    AUTHORS: 
    118118 
    119     - Nick Alexamder - initial implementation over `\QQ`. 
     119    - Nick Alexander - initial implementation over `\QQ`. 
    120120    - Chris Wuthrich - initial implementation over number fields. 
    121121    - John Cremona - additional features and unification. 

  • sage/schemes/elliptic_curves/gp_cremona.py

    r11376 r12827  
    22Cremona PARI Scripts 
    33 
    4 Access to Cremona's PARI scripts via SAGE. 
     4Access to Cremona's PARI scripts via Sage. 
    55""" 
    66 
    … …  
    4646     
    4747    INPUT: 
    48         e -- five-tuple of integers that define a minimal weierstrass equation 
     48        e -- five-tuple of integers that define a minimal Weierstrass equation 
    4949    OUTPUT: 
    5050        integer -- the ("computed") analytic rank r of E 
    … …  
    8282     
    8383    INPUT: 
    84         e -- five-tuple of integers that define a minimal weierstrass equation 
     84        e -- five-tuple of integers that define a minimal Weierstrass equation 
    8585 
    8686    OUTPUT: 
    … …  
    118118    NOTE: This is an internal function used in the function 
    119119    _abelian_group_data() for curves over finite (prime) field.  Users 
    120     should instead use higher-level funtions -- see examples. 
     120    should instead use higher-level functions -- see examples. 
    121121 
    122122    WARNING: The algorithm uses random points, so the generators in 

  • sage/schemes/elliptic_curves/gp_simon.py

    r11837 r12827  
    100100    s = gp.eval('ans=%s;'%cmd) 
    101101    if s.find("###") != -1: 
    102         raise RuntimeError, "%s\nAn error occured while running Simon's 2-descent program"%s 
     102        raise RuntimeError, "%s\nAn error occurred while running Simon's 2-descent program"%s 
    103103    if verbose > 0: 
    104104        print s 

  • sage/schemes/elliptic_curves/lseries_ell.py

    r12287 r12827  
    9595        \note{If algorithm='magma', then the precision is in digits rather 
    9696        than bits and the object returned is a Magma L-series, which has 
    97         different functionality from the SAGE L-series.} 
     97        different functionality from the Sage L-series.} 
    9898 
    9999        EXAMPLES: 
    … …  
    363363            float -- L(E,1) 
    364364            float -- a bound on the error in the approximation; this 
    365                      is a proveably correct upper bound on the sum 
     365                     is a provably correct upper bound on the sum 
    366366                     of the tail end of the series used to compute L(E,1). 
    367367 
    … …  
    401401        k = int(k) 
    402402        if k == 0: k = int(ceil(sqrtN)) 
    403         an = self.__E.anlist(k)           # list of SAGE ints 
     403        an = self.__E.anlist(k)           # list of Sage ints 
    404404        # Compute z = e^(-2pi/sqrt(N)) 
    405405        pi = 3.14159265358979323846 

  • sage/schemes/elliptic_curves/mod5family.py

    r576 r12827  
    1010    AUTHORS: 
    1111        -- Alice Silverberg and Karl Rubin (original PARI/GP version) 
    12         -- William Stein -- SAGE version. 
     12        -- William Stein -- Sage version. 
    1313    """ 
    1414    J = 4*a**3 / (4*a**3+27*b**2) 

  • sage/schemes/elliptic_curves/monsky_washnitzer.py

    r12365 r12827  
    271271         
    272272         
    273         -  ``p0, p1, p2`` - coefficients; must be coercable 
     273        -  ``p0, p1, p2`` - coefficients; must be coercible 
    274274           into poly_ring() 
    275275         
    … …  
    334334        -  ``parent`` - a SpecialCubicQuotientRing 
    335335         
    336         -  ``p0, p1, p2`` - coefficients; must be coercable 
     336        -  ``p0, p1, p2`` - coefficients; must be coercible 
    337337           into parent.poly_ring() 
    338338         
    … …  
    616616        # for certain base rings, e.g. when we compute b*c3 in the 
    617617        # final line. They shouldn't be necessary. Need to fix this 
    618         # somewhere else in SAGE. 
     618        # somewhere else in Sage. 
    619619        a = parent._poly_ring(a) 
    620620        b = parent._poly_ring(b) 
    … …  
    17111711#  
    17121712# I tried to embed must stuff into the rings themselves rather than  
    1713 # just extract and manipulate lists of coefficents. Hence the implementations  
     1713# just extract and manipulate lists of coefficients. Hence the implementations  
    17141714# below are much less optimized, so are much slower, but should hopefully be  
    17151715# easier to follow. (E.g. one can print/make sense of intermediate results.)  
    … …  
    17571757    # this is a hack until pAdics are fast 
    17581758    # (They are in the latest development bundle, but its not standard and I'd need to merge.  
    1759     # (it will periodically cast into this ring to reduce coefficent size) 
     1759    # (it will periodically cast into this ring to reduce coefficient size) 
    17601760    rational_S._prec_cap = p**M 
    17611761    rational_S._p = p 

  • sage/schemes/elliptic_curves/padic_height.py

    r4803 r12827  
    6666    """ 
    6767    INPUT: 
    68         E -- five-tuple of integers that define a weierstrass equation 
     68        E -- five-tuple of integers that define a Weierstrass equation 
    6969        p -- a prime number 
    7070        point -- point on E 
    … …  
    8484     
    8585    INPUT: 
    86         E -- five-tuple of integers that define a weierstrass equation 
     86        E -- five-tuple of integers that define a Weierstrass equation 
    8787        p -- a prime number 
    8888        points -- list of points on E 
    … …  
    9999    """ 
    100100    INPUT: 
    101         E -- five-tuple of integers that define a weierstrass equation 
     101        E -- five-tuple of integers that define a Weierstrass equation 
    102102        p -- a prime number 
    103103        prec -- precision parameter 

  • sage/schemes/elliptic_curves/padic_lseries.py

    r12287 r12827  
    258258        -  ``sign`` - +1 (default) or -1 (only implemented without twists) 
    259259 
    260         -  ``quadratic_twist`` - a fundamental discriminant of a quardratic field or +1 (default)  
     260        -  ``quadratic_twist`` - a fundamental discriminant of a quadratic field or +1 (default)  
    261261 
    262262        EXAMPLES:: 
    … …  
    675675        -  ``n`` - (default: 2) a positive integer 
    676676        -  ``quadratic_twist`` - (default: +1) a fundamental discriminant 
    677            of a qudratic field, coprime to the  
     677           of a quadratic field, coprime to the  
    678678           conductor of the curve 
    679679        -  ``prec`` - (default: 5) maximal number of terms of the series 
    … …  
    896896        - ``n`` - (default: 3) a positive integer 
    897897 
    898         - ``prec`` - (default: 5) maxima number of terms of the series 
     898        - ``prec`` - (default: 5) maximum number of terms of the series 
    899899          to compute; to compute as many as possible just 
    900900          give a very large number for prec; the result will 
    … …  
    12871287        coordinates of the result are independent of the chosen Weierstrass equation. 
    12881288         
    1289         NOTE: The definition here is corrected with repect to Perrin-Riou's article [PR]. See 
     1289        NOTE: The definition here is corrected with respect to Perrin-Riou's article [PR]. See 
    12901290        [SW]. 
    12911291         
    … …  
    13521352         
    13531353        # note the correction here with respect to Perrin-Riou's definition. 
    1354         # only this way the result will be indep of the choice of v1 and v2. 
     1354        # only this way the result will be independent of the choice of v1 and v2. 
    13551355        reg1 = regv(v1)/Dp_pairing(omega_vec,v1)**(rk-1) 
    13561356         

  • sage/schemes/elliptic_curves/padics.py

    r12089 r12827  
    176176     
    177177    TODO: - remove restriction that curve must be in minimal 
    178     weierstrass form. This is currently required for E.gens(). 
     178    Weierstrass form. This is currently required for E.gens(). 
    179179     
    180180    AUTHORS: 
    … …  
    223223        2*5^2 + 2*5^3 + 5^4 + 5^5 + 4*5^6 + 3*5^8 + 4*5^9 + O(5^10) 
    224224 
    225     The result is not dependend on the model for the curve:: 
     225    The result is not dependent on the model for the curve:: 
    226226     
    227227        sage: E = EllipticCurve([0,0,0,0,2^12*17]) 
    … …  
    282282     
    283283    TODO: - remove restriction that curve must be in minimal 
    284     weierstrass form. This is currently required for E.gens(). 
     284    Weierstrass form. This is currently required for E.gens(). 
    285285     
    286286    AUTHORS: 
    … …  
    386386    EXAMPLES: 
    387387     
    388     37a has trivial tamagawa numbers so all points have nonsingular 
     388    37a has trivial Tamagawa numbers so all points have nonsingular 
    389389    reduction at all primes:: 
    390390     
    … …  
    613613        0 
    614614 
    615     The result is not dependend on the model for the curve: 
     615    The result is not dependent on the model for the curve:: 
     616 
    616617        sage: E = EllipticCurve([0,0,0,0,2^12*17]) 
    617618        sage: Em = E.minimal_model() 
    … …  
    969970    # todo: implement the p == 3 case 
    970971    # NOTE: If we ever implement p == 3, it's necessary to check over 
    971     # the precision loss estimates (below) vey carefully; I think it 
     972    # the precision loss estimates (below) very carefully; I think it 
    972973    # may become necessary to compute E2 to an even higher precision. 
    973974    if p < 5: 
    … …  
    10171018 
    10181019    # Convert to a power series and remove the -1/x term. 
    1019     # Also we artifically bump up the accuracy from N-2 to to N-1 digits; 
     1020    # Also we artificially bump up the accuracy from N-2 to to N-1 digits; 
    10201021    # the constant term needs to be known to N-1 digits, so we compute 
    10211022    # it directly 
    … …  
    11561157    # todo: implement the p == 3 case 
    11571158    # NOTE: If we ever implement p == 3, it's necessary to check over 
    1158     # the precision loss estimates (below) vey carefully; I think it 
     1159    # the precision loss estimates (below) very carefully; I think it 
    11591160    # may become necessary to compute E2 to an even higher precision. 
    11601161    if p < 5: 
    … …  
    12071208 
    12081209    # Convert to a power series and remove the -1/x term. 
    1209     # Also we artifically bump up the accuracy from N-2 to N-1+lamb digits; 
     1210    # Also we artificially bump up the accuracy from N-2 to N-1+lamb digits; 
    12101211    # the constant term needs to be known to N-1+lamb digits, so we compute 
    12111212    # it directly 
    … …  
    14151416    # todo: here I should be able to write: 
    14161417    #  return E2_of_X / fudge_factor 
    1417     # However, there is a bug in SAGE (#51 on trac) which makes this 
     1418    # However, there is a bug in Sage (#51 on trac) which makes this 
    14181419    # crash sometimes when prec == 1. For example, 
    14191420    #    EllipticCurve([1, 1, 1, 1, 1]).padic_E2(5, 1) 
    … …  
    14271428    See the parameters and documentation for padic_E2. 
    14281429    """ 
    1429     # TODO change the basis back to the original euqation. 
     1430    # TODO change the basis back to the original equation. 
    14301431    # TODO, add lots of comments like the above 
    14311432    if check_hypotheses: 
    … …  
    14561457    # When we change coordinates like this, we might scale the invariant 
    14571458    # differential, so we need to account for this. We do this by 
    1458     # comparing discriminants: if the discrimimants differ by u^12, 
     1459    # comparing discriminants: if the discriminants differ by u^12, 
    14591460    # then the differentials differ by u. There's a sign ambiguity here, 
    14601461    # but it doesn't matter because E2 changes by u^2 :-) 
    … …  
    14691470 
    14701471    assert X.discriminant().valuation(p) == 0, "Something's gone wrong. " \ 
    1471            "The discriminant of the weierstrass model should be a unit " \ 
     1472           "The discriminant of the Weierstrass model should be a unit " \ 
    14721473           " at p." 
    14731474 
    … …  
    15841585    for s in misc.newton_method_sizes(N): 
    15851586        # zero-extend to s terms 
    1586         # todo: there has to be a better way in SAGE to do this... 
     1587        # todo: there has to be a better way in Sage to do this... 
    15871588        G = Rx(G.list(), s) 
    15881589         

  • sage/schemes/elliptic_curves/period_lattice.py

    r12632 r12827  
    349349 
    350350        - ``algorithm`` (string, default 'sage') -- choice of 
    351           implementation (for real ambeddings only) between 'sage' 
     351          implementation (for real embeddings only) between 'sage' 
    352352          (native Sage implementation) or 'pari' (use the pari 
    353353          library: only available for real embeddings). 
    … …  
    425425 
    426426        - ``algorithm`` (string, default 'sage') -- choice of 
    427           implementation (for real ambeddings only) between 'sage' 
     427          implementation (for real embeddings only) between 'sage' 
    428428          (native Sage implementation) or 'pari' (use the pari 
    429429          library: only available for real embeddings). 
    … …  
    661661         
    662662        - ``algorithm`` (string, default 'sage') -- choice of 
    663           implementation (for real ambeddings only) between 'sage' 
     663          implementation (for real embeddings only) between 'sage' 
    664664          (native Sage implementation) or 'pari' (use the pari 
    665665          library: only available for real embeddings). 

  • sage/schemes/elliptic_curves/sea.py

    r4718 r12827  
    3030        E -- list of 5 integers that defines an elliptic curve 
    3131        p -- prime number 
    32         early_abort -- bool (default: Falst); if True an early abort 
     32        early_abort -- bool (default: False); if True an early abort 
    3333                       technique is used and the computation is 
    3434                       interrupted as soon as a small divisor of the 

  • sage/schemes/elliptic_curves/sha_tate.py

    r12611 r12827  
    161161        r""" 
    162162        Returns the Birch and Swinnerton-Dyer conjectural order of Sha 
    163         as a provably corret integer, unless the analytic rank is > 1, 
     163        as a provably correct integer, unless the analytic rank is > 1, 
    164164        in which case this function returns a numerical value. 
    165165 
    … …  
    487487                shan0 = lstar[0]/bsdp[0] 
    488488            else: 
    489                 shan0 = 0   # this should actully never happen 
     489                shan0 = 0   # this should actually never happen 
    490490            if bsdp[1] != 0: 
    491491                shan1 = lstar[1]/bsdp[1] 
    … …  
    586586 
    587587        TO DO: This should be rewritten, to give the exact order 
    588         of Sha[2], or if we can not find sufficently many points 
     588        of Sha[2], or if we can not find sufficiently many points 
    589589        it should give a lower bound.  
    590590 

  • sage/schemes/elliptic_curves/weierstrass_morphism.py

    r12048 r12827  
    8383        .. note:: 
    8484 
    85            In a list of automprhisms, there is no guarantee that the 
     85           In a list of automorphisms, there is no guarantee that the 
    8686           identity will be first! 
    8787 
    … …  
    140140    def __invert__(self): 
    141141        r"""  
    142         Returns the inverse of this isomporphism. 
     142        Returns the inverse of this isomorphism. 
    143143 
    144144        EXAMPLES:: 
    … …  
    193193        representing the `a`-invariants of an elliptic curve `E`, 
    194194        returning the `a`-invariants of `w(E)`; or to `P=[x,y]` or 
    195         `P=[x,y,z]` represeting a point in `\mathbb{A}^2` or 
     195        `P=[x,y,z]` representing a point in `\mathbb{A}^2` or 
    196196        `\mathbb{P}^2`, returning the transformed point. 
    197197 
    … …  
    386386 
    387387        Given two Elliptic Curves ``E`` and ``F`` (represented by 
    388         Weierstrass models as uaual), and a transformation ``urst`` 
     388        Weierstrass models as usual), and a transformation ``urst`` 
    389389        from ``E`` to ``F``, construct an isomorphism from ``E`` to 
    390390        ``F``.  An exception is raised if ``urst(E)!=F``.  At most one 
    … …  
    565565    def __mul__(self,other): 
    566566        r""" 
    567         Returns the compsition of this WeierstrassIsomorphism and the other, 
     567        Returns the composition of this WeierstrassIsomorphism and the other, 
    568568 
    569569        WeierstrassMorphisms can be composed using ``*`` if the 

  • sage/schemes/generic/algebraic_scheme.py

    r12099 r12827  
    590590        scheme. 
    591591         
    592         EXAMPLES: First we construct the union of a doubled and triplled 
     592        EXAMPLES: First we construct the union of a doubled and tripled 
    593593        line in the affine plane over `\QQ`. 
    594594         

  • sage/schemes/generic/glue.py

    r11711 r12827  
    11""" 
    2 Scheme obtained by glueing two other schemes 
     2Scheme obtained by gluing two other schemes 
    33""" 
    44 

  • sage/schemes/generic/projective_space.py

    r12099 r12827  
    148148     
    149149    Projective spaces are not cached, i.e., there can be several with 
    150     the same base ring and dimension (to facilitate glueing 
     150    the same base ring and dimension (to facilitate gluing 
    151151    constructions). 
    152152    """ 

  • sage/schemes/hyperelliptic_curves/hypellfrob.pyx

    r10627 r12827  
    8787   """ 
    8888 
    89    # SAGE objects that wrap the NTL objects 
     89   # Sage objects that wrap the NTL objects 
    9090   cdef ntl_ZZ pp 
    9191   cdef ntl_ZZX QQ 
    … …  
    114114 
    115115   # Note: the C++ code actually resets the size of the matrix, but this seems 
    116    # to confuse the SAGE NTL wrapper. So to be safe I'm setting it ahead of 
     116   # to confuse the Sage NTL wrapper. So to be safe I'm setting it ahead of 
    117117   # time. 
    118118   mm = ntl_mat_ZZ(2*g, 2*g) 

  • sage/schemes/hyperelliptic_curves/hyperelliptic_finite_field.py

    r11901 r12827  
    213213                            points.append(self.point([x, r*b+b, one], check=True)) 
    214214                        except KeyError: 
    215                             # y^2 + by + c irreducable, so yields no points 
     215                            # y^2 + by + c irreducible, so yields no points 
    216216                            pass 
    217217                    else:  # b == 0 
    … …  
    246246        quadratic for y. 
    247247         
    248         Caches all square roots ahead of time by sqaring every element of 
     248        Caches all square roots ahead of time by squaring every element of 
    249249        the field. Elements must have an __index__ method. 
    250250         

  • sage/schemes/hyperelliptic_curves/hyperelliptic_padic_field.py

    r12365 r12827  
    9797         
    9898        Because this lift of frobenius acts as $x \mapsto x^p$,   
    99         take the Teichmuler lift of $x$ and then find a matching y 
     99        take the Teichmuller lift of $x$ and then find a matching y 
    100100        from that.  
    101101         
    … …  
    251251         
    252252        """ 
    253         # TODO: implement jacobians and show the relationship directly 
     253        # TODO: implement Jacobians and show the relationship directly 
    254254        import sage.schemes.elliptic_curves.monsky_washnitzer as monsky_washnitzer 
    255255        K = self.base_ring() 

  • sage/schemes/plane_curves/affine_curve.py

    r11996 r12827  
    111111        Return local coordinates to precision n at the given point. 
    112112         
    113             Behaviour is flakey - some choices of `n` are worst that 
     113            Behaviour is flaky - some choices of `n` are worst that 
    114114            others. 
    115115         

  • sage/schemes/plane_curves/all.py

    r12103 r12827  
    55#***************************************************************************** 
    66# 
    7 #   SAGE: System for Algebra and Geometry Experimentation     
     7#   Sage: System for Algebra and Geometry Experimentation     
    88# 
    99#       Copyright (C) 2005 William Stein <was@math.harvard.edu> 

  • sage/schemes/plane_curves/projective_curve.py

    r12103 r12827  
    121121        Return local coordinates to precision n at the given point. 
    122122         
    123             Behaviour is flakey - some choices of `n` are worst that 
     123            Behaviour is flaky - some choices of `n` are worst that 
    124124            others. 
    125125         
    … …  
    298298         
    299299        -  ``sort`` - bool (default: True), if True return the 
    300            point list sorted. If False, returns the pointes in the order 
     300           point list sorted. If False, returns the points in the order 
    301301           computed by Singular. 
    302302         
    … …  
    362362         
    363363        -  ``sort`` - bool (default: True), if True return the 
    364            point list sorted. If False, returns the pointes in the order 
     364           point list sorted. If False, returns the points in the order 
    365365           computed by Singular. 
    366366         
Note: See TracChangeset for help on using the changeset viewer.