# Changeset 12827:5e7aa739cec0

Ignore:
Timestamp:
08/11/09 00:30:36 (4 years ago)
Branch:
default
Message:

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

Location:
sage/schemes
Files:
30 edited

Unmodified
Removed
• ## sage/schemes/all.py

 r4851 """nodoctest all.py -- export of schemes to SAGE all.py -- export of schemes to Sage """ #***************************************************************************** # #   SAGE: System for Algebra and Geometry Experimentation #   Sage: System for Algebra and Geometry Experimentation # #       Copyright (C) 2005 William Stein
• ## sage/schemes/elliptic_curves/ell_curve_isogeny.py

 r12448 OUTPUT: (elliptic curve) the codomain of the seperable normalized isogeny from this kernel (elliptic curve) the codomain of the separable normalized isogeny from this kernel EXAMPLES:: # # we keep track of the 2 torsion and non2torsion seperately # we keep track of the 2 torsion and non2torsion separately __kernel_2tor = None __kernel_non2tor = None If initiating from a domain/codomain, this must be set to None. - codomain  - an elliptic curve (default:None).  If kernel is None, then this must be the codomain of a seperable normalized isogeny, then this must be the codomain of a separable normalized isogeny, furthermore, degree must be the degree of the isogeny from E to codomain. If kernel is not None, then this must be isomorphic to the codomain of the normalized seperable isogeny defined by kernel, normalized separable isogeny defined by kernel, in this case, the isogeny is post composed with an isomorphism so that this parameter is the codomain. - degree    - an integer (default:None). If kernel is None, then this is the degree of the isogeny from E to codomain. If kernel is not None, then this is used to determine wether or not to skip a gcd If kernel is not None, then this is used to determine whether or not to skip a gcd of the kernel polynomial with the two torsion polynomial of E. - model     - a string (defaul:None).  Only supported variable is "minimal", in which case if - model     - a string (default:None).  Only supported variable is "minimal", in which case if E is a curve over the rationals, then the codomain is set to be the unique global minimum model. - algorithm - a string (default:None).  If this parameter is None, then the algorithm is determined from the input. if (E1 != E_P): if (E1.a_invariants() != E_P.a_invariants()) : raise ValueError, "P must be on a curve with same weierstrass model as the domain curve of this isogeny." raise ValueError, "P must be on a curve with same Weierstrass model as the domain curve of this isogeny." change_output_ring = True self.__pre_isomorphism = isomorphism # calculuate the isomorphism as a rational map. # calculate the isomorphism as a rational map. (u, r, s, t) = isomorphism.tuple() self.__post_isomorphism = isomorphism # calculuate the isomorphism as a rational map. # calculate the isomorphism as a rational map. (u, r, s, t) = isomorphism.tuple() ################################### # Kohel's Variant of Velu's Forumla # Kohel's Variant of Velu's Formula ################################### EXAMPLES: These examples inherentl exercise this private function:: These examples inherently exercise this private function:: sage: R. = GF(7)[] def __compute_via_kohel(self, xP, yP): r""" Private function that applies Kohel's fomulas. Private function that applies Kohel's formulas. EXAMPLES: True Example over a numberfield:: Example over a number field:: sage: R. = QQ[] # or if it is a just a translation. # NOTE: This only works because we are using algorithms for calculating the isogenies that calculate # a seperable normalized isogeny, if this changes, this check will no longer be correct. # a separable normalized isogeny, if this changes, this check will no longer be correct. # if (check_prepost_isomorphism): Traceback (most recent call last): ... NotImplementedError: Numerical approximations do not make sense for Elliptic Curve Isogeies """ raise NotImplementedError, "Numerical approximations do not make sense for Elliptic Curve Isogeies" NotImplementedError: Numerical approximations do not make sense for Elliptic Curve Isogenies """ raise NotImplementedError, "Numerical approximations do not make sense for Elliptic Curve Isogenies" ALGORITHM: algorithm "fast" uses newton iteration and has complexity O(M(n)), algorithm "quadratic" has compexity O(n*M(n)) algorithm "fast" uses newton iteration and has complexity O(M(n)), algorithm "quadratic" has complexity O(n*M(n)) EXAMPLES:: trunc_exp = truncated_exp_fast(f, n) else: raise ValueError, "Unknown algorithm for computing truncated expoential." raise ValueError, "Unknown algorithm for computing truncated exponential." return trunc_exp - poly_ring - polynomial ring, to compute the \wp function in (assumes that the generator is z^2 for efficiency of storage/operations.) - A         - field element corresponding to the x coefficient in the weierstrass equaation of an elliptic curve - B         - field element corresponding to the constant coefficient in the weierstrass equation of an ellitpic curve - A         - field element corresponding to the x coefficient in the weierstrass equation of an elliptic curve - B         - field element corresponding to the constant coefficient in the weierstrass equation of an elliptic curve - 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. - poly_ring - polynomial ring, to compute the function in (assumes that the generator is z^2 for efficiency of storage/operations.) - A         - field element corresponding to the x coefficient in the weierstrass equaation of an elliptic curve - B         - field element corresponding to the constant coefficient in the weierstrass equation of an ellitpic curve - A         - field element corresponding to the x coefficient in the weierstrass equation of an elliptic curve - B         - field element corresponding to the constant coefficient in the weierstrass equation of an elliptic curve - 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. r""" Computes the degree ell isogeny between E1 and E2 via Stark's algorithm.  There must be a degree ell, seperable, Stark's algorithm.  There must be a degree ell, separable, normalized isogeny from E1 to E2. Given a full kernel polynomial (where two torsion x-coordinates are roots of multiplicity 1, and all other roots have multiplicity 2.)  of degree \ell-1, returns the maximum seperable divisor. 2.)  of degree \ell-1, returns the maximum separable divisor. (i.e. the kernel polynomial with roots of multiplicity at most 1). Computes the degree ell isogeny between E1 and E2. There must be a degree ell, seperable, normalized isogeny from There must be a degree ell, separable, normalized isogeny from E1 to E2.  If no algorithm is specified, this function determines the best algorithm to use. - algorithm - string (default:"starks") if None, this function automatically determines best algorithm to use. Otherwise uses the algorithm specified by the string.  Valid valuse are "starks" or "fastElkies" Otherwise uses the algorithm specified by the string.  Valid values are "starks" or "fastElkies" OUTPUT: # # Everything that follows here is how we get the kernel polynomial in the form we want # i.e. a seperable polynomial (no repeated roots.) # i.e. a separable polynomial (no repeated roots.) # ker_poly = split_kernel_polynomial(E1, ker_poly, ell) intermediate_domain = pre_isom.codomain().codomain() # compute the r,s,t valuse that clear the denominator of E2 # compute the r,s,t values that clear the denominator of E2 a1pr = E2.a1() a2pr = E2.a2() def compute_sequence_of_maps(E1, E2, ell): r""" 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. 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. EXAMPLES::
• ## sage/schemes/elliptic_curves/ell_egros.py

 r12728 Using the "proof=False" flag suppresses these warnings. EXAMPLES: We find all elliptic cruves with good reduction outside 2, EXAMPLES: We find all elliptic curves with good reduction outside 2, listing the label of each: printed without proof=False (unless the optional database is installed: two of the auxiliary curves whose Mordell-Weil bases are required have conductors 13068 and 52272 so are in the databse): required have conductors 13068 and 52272 so are in the database): sage: [e.label() for e in EllipticCurves_with_good_reduction_outside_S([11], proof=False)] is undefined if S is not a list or contains non-primes. OUPUT: OUTPUT: A sorted list of all elliptic curves defined over Q with E = EllipticCurve([0,0,0,0,a6]) # This curve may not be minimal at 2 or 3, but the # S-integral_points function requires minimalilty at primes in # S-integral_points function requires minimality at primes in # S, so we find a new model which is p-minimal at both 2 and 3 # if they are in S.  Note that the isomorphism between models
• ## sage/schemes/elliptic_curves/ell_field.py

 r12740 the curve returned is the unique curve (up to isomorphism) defined over F isomorphic to the original curve over the quadratic extension of F but not over F itself.  Over infinte quadratic extension of F but not over F itself.  Over infinite fields, an error is raised if D is not given. If initiating from a domain/codomain, this must be set to None. - codomain  - an elliptic curve (default:None).  If kernel is None, then this must be the codomain of a seperable normalized isogeny, then this must be the codomain of a separable normalized isogeny, furthermore, degree must be the degree of the isogeny from self to codomain. If kernel is not None, then this must be isomorphic to the codomain of the normalized seperable isogeny defined by kernel, normalized separable isogeny defined by kernel, in this case, the isogeny is post composed with an isomorphism so that this parameter is the codomain. - degree    - an integer (default:None). If kernel is None, then this is the degree of the isogeny from self to codomain. If kernel is not None, then this is used to determine wether or not to skip a gcd If kernel is not None, then this is used to determine whether or not to skip a GCD of the kernel polynomial with the two torsion polynomial of self. - model     - a string (defaul:None).  Only supported variable is "minimal", in which case if - model     - a string (default:None).  Only supported variable is "minimal", in which case if self is a curve over the rationals, then the codomain is set to be the unique global minimum model. - algorithm - a string (default:None).  If this parameter is None, then the algorithm is determined from the input. def isogeny_codomain(self, kernel, degree=None, algorithm=None): r""" Returns the codomain of the isogeny from self with givien kernel. Returns the codomain of the isogeny from self with given kernel. This redirects to the isogeny_codomain_from_kernel function, see that function for more information. OUTPUT: (elliptic curve) the codomain of the seperable normalized isogeny from this kernel (elliptic curve) the codomain of the separable normalized isogeny from this kernel
• ## sage/schemes/elliptic_curves/ell_generic.py

 r12287 return (x, -y-a1*x-a3) # the x-coordonate does not depend on the sign of m.  The work # the x-coordinate does not depend on the sign of m.  The work # here is done by functions defined earlier: Via:  (u,r,s,t) = (1, 0, 0, 0)] We can also find istomorphisms defined over extension fields:: We can also find isomorphisms defined over extension fields:: sage: E=EllipticCurve(GF(7),[0,0,0,1,1])
• ## sage/schemes/elliptic_curves/ell_modular_symbols.py

 r12287 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 quardatic twists. Otherwise we try to scale using quadratic twists. _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 EXAMPLES: Construction from Weierstrass coeffiecients (a-invariants), long form:: Construction from Weierstrass coefficients (a-invariants), long form:: sage: E = EllipticCurve([1,2,3,4,5]); E Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over Rational Field Construction from Weierstrass coeffiecients (a-invariants), Construction from Weierstrass coefficients (a-invariants), short form (sets a_1=a_2=a_3=0):: # # E <--> [0, 1, 1, -2, 0]   389A #  E = EllipticCurve([0, 1, 1, -2, 0]);   // SAGE or MAGMA #  E = EllipticCurve([0, 1, 1, -2, 0]);   // Sage or MAGMA #  e = E.pari_mincurve() #  f = ellinit([0,1,1,-2,0]); OUTPUT: a power series (in th evariable 'q') a power series (in the variable 'q') .. note:: so). Probably it could just round at some point. For rigour, you would need to bound the tail by assuming (essentially) that all the a_n are as large as possible, but in practise they a_n are as large as possible, but in practice they exhibit significant (square root) cancellation. One difficulty is that it doesn't do the sum in 1-2-3-4 order; it uses This plots helps you see that the above Manin constants are right.  Note that the vertex labels are 0-based unlinke the right.  Note that the vertex labels are 0-based unlike the Cremona isogeny labels:: We explicitly verify in the above example that indeed that index is divisibly by 2 by writing down a generator of index is divisible by 2 by writing down a generator of E(QQ)/tor + E^D(QQ)/tor that is divisible by 2 in E(K):: #  - The regulator. #    First we compute the regualtor of the subgroup E(QQ) + E^D(QQ) #    First we compute the regulator of the subgroup E(QQ) + E^D(QQ) #    of E(K).   The factor of 2 in the regulator #    accounts for the fact that the height over K is twice the def _heegner_best_tau(self, D, prec=None): """ Given a discrimanent D, find the Heegner point \tau in the Given a discriminant D, find the Heegner point \tau in the upper half plane with largest imaginary part (which is optimal for evaluating the modular parametrization). If the optional it is computed with prec bits of working precision, otherwise it attempts to recognize it exactly over the Hilbert class field of K. In this  latter case, the answer is *not* proveably correct but a strong consistancy check is made. In this  latter case, the answer is *not* provably correct but a strong consistency check is made. INPUT:: [-3, -2, -1, 0, 1, 2, 3, 4, 8, 11, 14, 21, 37, 52, 93] TODO: reimplement this using the much faster point searching TODO: re-implement this using the much faster point searching implemented in Stoll's ratpoints program. c4, c6 = E.c_invariants() disc = E.discriminant() #internal function is doing only a comparision of E and E.short_weierstass_model() so the following is easier #internal function is doing only a comparison of E and E.short_weierstass_model() so the following is easier if a1 == a2 == a3 == 0: is_short = True
• ## sage/schemes/elliptic_curves/ell_tate_curve.py

 r12102 - William Stein (2007-05-29): added some examples; editing. - chris wuthrich (04/09): reformated docstrings. - chris wuthrich (04/09): reformatted docstrings. """
• ## sage/schemes/elliptic_curves/ell_torsion.py

 r12224 AUTHORS: - Nick Alexamder - initial implementation over \QQ. - Nick Alexander - initial implementation over \QQ. - Chris Wuthrich - initial implementation over number fields. - John Cremona - additional features and unification.
• ## sage/schemes/elliptic_curves/gp_cremona.py

 r11376 Cremona PARI Scripts Access to Cremona's PARI scripts via SAGE. Access to Cremona's PARI scripts via Sage. """ INPUT: e -- five-tuple of integers that define a minimal weierstrass equation e -- five-tuple of integers that define a minimal Weierstrass equation OUTPUT: integer -- the ("computed") analytic rank r of E INPUT: e -- five-tuple of integers that define a minimal weierstrass equation e -- five-tuple of integers that define a minimal Weierstrass equation OUTPUT: NOTE: This is an internal function used in the function _abelian_group_data() for curves over finite (prime) field.  Users should instead use higher-level funtions -- see examples. should instead use higher-level functions -- see examples. WARNING: The algorithm uses random points, so the generators in
• ## sage/schemes/elliptic_curves/gp_simon.py

 r11837 s = gp.eval('ans=%s;'%cmd) if s.find("###") != -1: raise RuntimeError, "%s\nAn error occured while running Simon's 2-descent program"%s raise RuntimeError, "%s\nAn error occurred while running Simon's 2-descent program"%s if verbose > 0: print s
• ## sage/schemes/elliptic_curves/lseries_ell.py

 r12287 \note{If algorithm='magma', then the precision is in digits rather than bits and the object returned is a Magma L-series, which has different functionality from the SAGE L-series.} different functionality from the Sage L-series.} EXAMPLES: float -- L(E,1) float -- a bound on the error in the approximation; this is a proveably correct upper bound on the sum is a provably correct upper bound on the sum of the tail end of the series used to compute L(E,1). k = int(k) if k == 0: k = int(ceil(sqrtN)) an = self.__E.anlist(k)           # list of SAGE ints an = self.__E.anlist(k)           # list of Sage ints # Compute z = e^(-2pi/sqrt(N)) pi = 3.14159265358979323846
• ## sage/schemes/elliptic_curves/mod5family.py

 r576 AUTHORS: -- Alice Silverberg and Karl Rubin (original PARI/GP version) -- William Stein -- SAGE version. -- William Stein -- Sage version. """ J = 4*a**3 / (4*a**3+27*b**2)
• ## sage/schemes/elliptic_curves/monsky_washnitzer.py

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

 r4803 """ INPUT: E -- five-tuple of integers that define a weierstrass equation E -- five-tuple of integers that define a Weierstrass equation p -- a prime number point -- point on E INPUT: E -- five-tuple of integers that define a weierstrass equation E -- five-tuple of integers that define a Weierstrass equation p -- a prime number points -- list of points on E """ INPUT: E -- five-tuple of integers that define a weierstrass equation E -- five-tuple of integers that define a Weierstrass equation p -- a prime number prec -- precision parameter

 r12287 -  sign - +1 (default) or -1 (only implemented without twists) -  quadratic_twist - a fundamental discriminant of a quardratic field or +1 (default) -  quadratic_twist - a fundamental discriminant of a quadratic field or +1 (default) EXAMPLES:: -  n - (default: 2) a positive integer -  quadratic_twist - (default: +1) a fundamental discriminant of a qudratic field, coprime to the of a quadratic field, coprime to the conductor of the curve -  prec - (default: 5) maximal number of terms of the series - n - (default: 3) a positive integer - prec - (default: 5) maxima number of terms of the series - prec - (default: 5) maximum number of terms of the series to compute; to compute as many as possible just give a very large number for prec; the result will coordinates of the result are independent of the chosen Weierstrass equation. NOTE: The definition here is corrected with repect to Perrin-Riou's article [PR]. See NOTE: The definition here is corrected with respect to Perrin-Riou's article [PR]. See [SW]. # note the correction here with respect to Perrin-Riou's definition. # only this way the result will be indep of the choice of v1 and v2. # only this way the result will be independent of the choice of v1 and v2. reg1 = regv(v1)/Dp_pairing(omega_vec,v1)**(rk-1)

 r12089 TODO: - remove restriction that curve must be in minimal weierstrass form. This is currently required for E.gens(). Weierstrass form. This is currently required for E.gens(). AUTHORS: 2*5^2 + 2*5^3 + 5^4 + 5^5 + 4*5^6 + 3*5^8 + 4*5^9 + O(5^10) The result is not dependend on the model for the curve:: The result is not dependent on the model for the curve:: sage: E = EllipticCurve([0,0,0,0,2^12*17]) TODO: - remove restriction that curve must be in minimal weierstrass form. This is currently required for E.gens(). Weierstrass form. This is currently required for E.gens(). AUTHORS: EXAMPLES: 37a has trivial tamagawa numbers so all points have nonsingular 37a has trivial Tamagawa numbers so all points have nonsingular reduction at all primes:: 0 The result is not dependend on the model for the curve: The result is not dependent on the model for the curve:: sage: E = EllipticCurve([0,0,0,0,2^12*17]) sage: Em = E.minimal_model() # todo: implement the p == 3 case # NOTE: If we ever implement p == 3, it's necessary to check over # the precision loss estimates (below) vey carefully; I think it # the precision loss estimates (below) very carefully; I think it # may become necessary to compute E2 to an even higher precision. if p < 5: # Convert to a power series and remove the -1/x term. # Also we artifically bump up the accuracy from N-2 to to N-1 digits; # Also we artificially bump up the accuracy from N-2 to to N-1 digits; # the constant term needs to be known to N-1 digits, so we compute # it directly # todo: implement the p == 3 case # NOTE: If we ever implement p == 3, it's necessary to check over # the precision loss estimates (below) vey carefully; I think it # the precision loss estimates (below) very carefully; I think it # may become necessary to compute E2 to an even higher precision. if p < 5: # Convert to a power series and remove the -1/x term. # Also we artifically bump up the accuracy from N-2 to N-1+lamb digits; # Also we artificially bump up the accuracy from N-2 to N-1+lamb digits; # the constant term needs to be known to N-1+lamb digits, so we compute # it directly # todo: here I should be able to write: #  return E2_of_X / fudge_factor # However, there is a bug in SAGE (#51 on trac) which makes this # However, there is a bug in Sage (#51 on trac) which makes this # crash sometimes when prec == 1. For example, #    EllipticCurve([1, 1, 1, 1, 1]).padic_E2(5, 1) See the parameters and documentation for padic_E2. """ # TODO change the basis back to the original euqation. # TODO change the basis back to the original equation. # TODO, add lots of comments like the above if check_hypotheses: # When we change coordinates like this, we might scale the invariant # differential, so we need to account for this. We do this by # comparing discriminants: if the discrimimants differ by u^12, # comparing discriminants: if the discriminants differ by u^12, # then the differentials differ by u. There's a sign ambiguity here, # but it doesn't matter because E2 changes by u^2 :-) assert X.discriminant().valuation(p) == 0, "Something's gone wrong. " \ "The discriminant of the weierstrass model should be a unit " \ "The discriminant of the Weierstrass model should be a unit " \ " at p." for s in misc.newton_method_sizes(N): # zero-extend to s terms # todo: there has to be a better way in SAGE to do this... # todo: there has to be a better way in Sage to do this... G = Rx(G.list(), s)
• ## sage/schemes/elliptic_curves/period_lattice.py

 r12632 - algorithm (string, default 'sage') -- choice of implementation (for real ambeddings only) between 'sage' implementation (for real embeddings only) between 'sage' (native Sage implementation) or 'pari' (use the pari library: only available for real embeddings). - algorithm (string, default 'sage') -- choice of implementation (for real ambeddings only) between 'sage' implementation (for real embeddings only) between 'sage' (native Sage implementation) or 'pari' (use the pari library: only available for real embeddings). - algorithm (string, default 'sage') -- choice of implementation (for real ambeddings only) between 'sage' implementation (for real embeddings only) between 'sage' (native Sage implementation) or 'pari' (use the pari library: only available for real embeddings).
• ## sage/schemes/elliptic_curves/sea.py

 r4718 E -- list of 5 integers that defines an elliptic curve p -- prime number early_abort -- bool (default: Falst); if True an early abort early_abort -- bool (default: False); if True an early abort technique is used and the computation is interrupted as soon as a small divisor of the
• ## sage/schemes/elliptic_curves/sha_tate.py

 r12611 r""" Returns the Birch and Swinnerton-Dyer conjectural order of Sha as a provably corret integer, unless the analytic rank is > 1, as a provably correct integer, unless the analytic rank is > 1, in which case this function returns a numerical value. shan0 = lstar[0]/bsdp[0] else: shan0 = 0   # this should actully never happen shan0 = 0   # this should actually never happen if bsdp[1] != 0: shan1 = lstar[1]/bsdp[1] TO DO: This should be rewritten, to give the exact order of Sha[2], or if we can not find sufficently many points of Sha[2], or if we can not find sufficiently many points it should give a lower bound.
• ## sage/schemes/elliptic_curves/weierstrass_morphism.py

 r12048 .. note:: In a list of automprhisms, there is no guarantee that the In a list of automorphisms, there is no guarantee that the identity will be first! def __invert__(self): r""" Returns the inverse of this isomporphism. Returns the inverse of this isomorphism. EXAMPLES:: representing the a-invariants of an elliptic curve E, returning the a-invariants of w(E); or to P=[x,y] or P=[x,y,z] represeting a point in \mathbb{A}^2 or P=[x,y,z] representing a point in \mathbb{A}^2 or \mathbb{P}^2, returning the transformed point. Given two Elliptic Curves E and F (represented by Weierstrass models as uaual), and a transformation urst Weierstrass models as usual), and a transformation urst from E to F, construct an isomorphism from E to F.  An exception is raised if urst(E)!=F.  At most one def __mul__(self,other): r""" Returns the compsition of this WeierstrassIsomorphism and the other, Returns the composition of this WeierstrassIsomorphism and the other, WeierstrassMorphisms can be composed using * if the
• ## sage/schemes/generic/algebraic_scheme.py

 r12099 scheme. EXAMPLES: First we construct the union of a doubled and triplled EXAMPLES: First we construct the union of a doubled and tripled line in the affine plane over \QQ.
• ## sage/schemes/generic/glue.py

 r11711 """ Scheme obtained by glueing two other schemes Scheme obtained by gluing two other schemes """
• ## sage/schemes/generic/projective_space.py

 r12099 Projective spaces are not cached, i.e., there can be several with the same base ring and dimension (to facilitate glueing the same base ring and dimension (to facilitate gluing constructions). """
• ## sage/schemes/hyperelliptic_curves/hypellfrob.pyx

 r10627 """ # SAGE objects that wrap the NTL objects # Sage objects that wrap the NTL objects cdef ntl_ZZ pp cdef ntl_ZZX QQ # Note: the C++ code actually resets the size of the matrix, but this seems # to confuse the SAGE NTL wrapper. So to be safe I'm setting it ahead of # to confuse the Sage NTL wrapper. So to be safe I'm setting it ahead of # time. mm = ntl_mat_ZZ(2*g, 2*g)
• ## sage/schemes/hyperelliptic_curves/hyperelliptic_finite_field.py

 r11901 points.append(self.point([x, r*b+b, one], check=True)) except KeyError: # y^2 + by + c irreducable, so yields no points # y^2 + by + c irreducible, so yields no points pass else:  # b == 0 quadratic for y. Caches all square roots ahead of time by sqaring every element of Caches all square roots ahead of time by squaring every element of the field. Elements must have an __index__ method.
 r12365 Because this lift of frobenius acts as $x \mapsto x^p$, take the Teichmuler lift of $x$ and then find a matching y take the Teichmuller lift of $x$ and then find a matching y from that. """ # TODO: implement jacobians and show the relationship directly # TODO: implement Jacobians and show the relationship directly import sage.schemes.elliptic_curves.monsky_washnitzer as monsky_washnitzer K = self.base_ring()
 r11996 Return local coordinates to precision n at the given point. Behaviour is flakey - some choices of n are worst that Behaviour is flaky - some choices of n are worst that others.
 r12103 Return local coordinates to precision n at the given point. Behaviour is flakey - some choices of n are worst that Behaviour is flaky - some choices of n are worst that others. -  sort - bool (default: True), if True return the point list sorted. If False, returns the pointes in the order point list sorted. If False, returns the points in the order computed by Singular. -  sort - bool (default: True), if True return the point list sorted. If False, returns the pointes in the order point list sorted. If False, returns the points in the order computed by Singular.