Ticket #11599: trac_11599_remove_class_suffix.patch

File trac_11599_remove_class_suffix.patch, 30.0 KB (added by vbraun, 10 years ago)

Initial patch

  • sage/schemes/elliptic_curves/ell_finite_field.py

    # HG changeset patch
    # User Volker Braun <vbraun@stp.dias.ie>
    # Date 1329691389 28800
    # Node ID e7de36bc238097cde068ff033d5c3791cdfe134b
    # Parent  6afbcab22657a3ef0ab39ee1354e102f22ffd025
    Trac #11599: Toric morphisms
    
    Remove _class suffix in various methods
    
    diff --git a/sage/schemes/elliptic_curves/ell_finite_field.py b/sage/schemes/elliptic_curves/ell_finite_field.py
    a b  
    9797
    9898        EllipticCurve_field.__init__(self, ainvs)
    9999
    100         self._point_class = ell_point.EllipticCurvePoint_finite_field
     100        self._point = ell_point.EllipticCurvePoint_finite_field
    101101
    102102    def plot(self, *args, **kwds):
    103103        """
  • sage/schemes/elliptic_curves/ell_generic.py

    diff --git a/sage/schemes/elliptic_curves/ell_generic.py b/sage/schemes/elliptic_curves/ell_generic.py
    a b  
    167167        # purposes.
    168168        from sage.rings.all import is_FiniteField, is_IntegerModRing
    169169        if is_FiniteField(K) or is_IntegerModRing(K):
    170             self._morphism_class = self._point_class = ell_point.EllipticCurvePoint_finite_field
     170            self._morphism = self._point = ell_point.EllipticCurvePoint_finite_field
    171171        elif K.is_field():
    172172            if is_NumberField(K):
    173                 self._morphism_class = self._point_class = ell_point.EllipticCurvePoint_number_field
     173                self._morphism = self._point = ell_point.EllipticCurvePoint_number_field
    174174            else:
    175                 self._morphism_class = self._point_class = ell_point.EllipticCurvePoint_field
     175                self._morphism = self._point = ell_point.EllipticCurvePoint_field
    176176        else:
    177             self._morphism_class = self._point_class = ell_point.EllipticCurvePoint
     177            self._morphism = self._point = ell_point.EllipticCurvePoint
    178178
    179179    def _defining_params_(self):
    180180        r"""
     
    850850        else:
    851851            raise ValueError, "No point with x-coordinate %s on %s"%(x, self)
    852852
    853     def _point_homset_class(self, *args, **kwds):
     853    def _point_homset(self, *args, **kwds):
    854854        r"""
    855855        Internal function. Returns the (abstract) group of points on this
    856856        elliptic curve over a ring.
     
    858858        EXAMPLES::
    859859       
    860860            sage: E=EllipticCurve(GF(5),[1,1])
    861             sage: E._point_homset_class(Spec(GF(5^10,'a'),GF(5)), E)
     861            sage: E._point_homset(Spec(GF(5^10,'a'),GF(5)), E)
    862862            Abelian group of points on Elliptic Curve defined
    863863            by y^2 = x^3 + x + 1 over Finite Field in a of size 5^10
    864864        """
  • sage/schemes/elliptic_curves/ell_number_field.py

    diff --git a/sage/schemes/elliptic_curves/ell_number_field.py b/sage/schemes/elliptic_curves/ell_number_field.py
    a b  
    157157            raise TypeError
    158158       
    159159        EllipticCurve_field.__init__(self, [field(x) for x in ainvs])
    160         self._point_class = ell_point.EllipticCurvePoint_number_field
     160        self._point = ell_point.EllipticCurvePoint_number_field
    161161
    162162    def simon_two_descent(self, verbose=0, lim1=5, lim3=50, limtriv=10, maxprob=20, limbigprime=30):
    163163        r"""
  • sage/schemes/elliptic_curves/ell_padic_field.py

    diff --git a/sage/schemes/elliptic_curves/ell_padic_field.py b/sage/schemes/elliptic_curves/ell_padic_field.py
    a b  
    6363       
    6464        EllipticCurve_field.__init__(self, [field(x) for x in ainvs])
    6565
    66         self._point_class = ell_point.EllipticCurvePoint_field
     66        self._point = ell_point.EllipticCurvePoint_field
    6767        self._genus = 1
    6868
    6969    def frobenius(self, P=None):
  • sage/schemes/generic/affine_space.py

    diff --git a/sage/schemes/generic/affine_space.py b/sage/schemes/generic/affine_space.py
    a b  
    274274        """
    275275        return "\\mathbf{A}_{%s}^%s"%(latex(self.base_ring()), self.dimension_relative())
    276276   
    277     def _morphism_class(self, *args, **kwds):
     277    def _morphism(self, *args, **kwds):
    278278        """
    279279        Construct a morphism determined by action on points of ``self``.
    280280
     
    294294            sage: AA.inject_variables()
    295295            Defining a0, a1, a2
    296296            sage: EndAA = AA.Hom(AA)
    297             sage: AA._morphism_class(EndAA, [a0*a1, a1*a2, a0*a2])
     297            sage: AA._morphism(EndAA, [a0*a1, a1*a2, a0*a2])
    298298            Scheme endomorphism of Affine Space of dimension 3 over Rational Field
    299299              Defn: Defined on coordinates by sending (a0, a1, a2) to
    300300                    (a0*a1, a1*a2, a0*a2)
    301301        """
    302302        return morphism.SchemeMorphism_polynomial_affine_space(*args, **kwds)
    303303
    304     def _point_homset_class(self, *args, **kwds):
     304    def _point_homset(self, *args, **kwds):
    305305        """
    306         Construct a Hom-space for ``self``.
     306        Construct a Hom-set for ``self``.
    307307       
    308308        INPUT:
    309309
     
    318318        EXAMPLES::
    319319         
    320320            sage: AA = AffineSpace(QQ, 3, 'a')
    321             sage: AA._point_homset_class(Spec(QQ), AA)
     321            sage: AA._point_homset(Spec(QQ), AA)
    322322            Set of rational points of Affine Space of dimension 3 over Rational Field
    323323        """
    324324        return homset.SchemeHomset_points_affine(*args, **kwds)
    325325
    326     def _point_class(self, *args, **kwds):
     326    def _point(self, *args, **kwds):
    327327        r"""
    328328        Construct a point of ``self``.
    329329
     
    340340        TESTS::
    341341
    342342            sage: AA = AffineSpace(QQ, 3, 'a')
    343             sage: AA._point_class(AA.point_homset(), [0,1,2])
     343            sage: AA._point(AA.point_homset(), [0,1,2])
    344344            (0, 1, 2)
    345345        """
    346346        return morphism.SchemeMorphism_point_affine(*args, **kwds)
  • sage/schemes/generic/algebraic_scheme.py

    diff --git a/sage/schemes/generic/algebraic_scheme.py b/sage/schemes/generic/algebraic_scheme.py
    a b  
    521521        """
    522522        return "Subscheme of %s"%self.__A
    523523
    524     def _point_homset_class(self, *args, **kwds):
    525         return self.__A._point_homset_class(*args, **kwds)
     524    def _point_homset(self, *args, **kwds):
     525        return self.__A._point_homset(*args, **kwds)
    526526
    527     def _point_class(self, *args, **kwds):
    528         return self.__A._point_class(*args, **kwds)
     527    def _point(self, *args, **kwds):
     528        return self.__A._point(*args, **kwds)
    529529
    530530
    531531
     
    14831483          x^2 - y*z
    14841484    """
    14851485
    1486     def _morphism_class(self, *args, **kwds):
     1486    def _morphism(self, *args, **kwds):
    14871487        return morphism.SchemeMorphism_polynomial_affine_space(*args, **kwds)
    14881488
    14891489    def dimension(self):
     
    16791679          x^2 - y*z
    16801680    """
    16811681
    1682     def _morphism_class(self, *args, **kwds):
     1682    def _morphism(self, *args, **kwds):
    16831683        r"""
    16841684        Construct a morphism determined by action on points of ``self``.
    16851685
     
    17051705              To:   Projective Space of dimension 2 over Rational Field
    17061706              Defn: Defined on coordinates by sending (x : y) to
    17071707                (x^2 : x*y : y^2)
    1708             sage: P1._morphism_class(H12, [x^2,x*y, y^2])
     1708            sage: P1._morphism(H12, [x^2,x*y, y^2])
    17091709            Scheme morphism:
    17101710              From: Projective Space of dimension 1 over Rational Field
    17111711              To:   Projective Space of dimension 2 over Rational Field
     
    20612061        super(AlgebraicScheme_subscheme_toric, self).__init__(toric_variety,
    20622062                                                              polynomials)
    20632063
    2064     def _morphism_class(self, *args, **kwds):
     2064    def _morphism(self, *args, **kwds):
    20652065        r"""
    20662066        Construct a morphism determined by action on points of ``self``.
    20672067
     
    20822082            Defining z0, z1, z2, z3
    20832083            sage: P1 = P1xP1.subscheme(z0-z2)
    20842084            sage: H = P1.Hom(P1xP1)
    2085             sage: P1._morphism_class(H, [z0,z1,z0,z3])
     2085            sage: P1._morphism(H, [z0,z1,z0,z3])
    20862086            Scheme morphism:
    20872087              From: Closed subscheme of 2-d toric variety
    20882088              covered by 4 affine patches defined by:
  • sage/schemes/generic/homset.py

    diff --git a/sage/schemes/generic/homset.py b/sage/schemes/generic/homset.py
    a b  
    44For schemes `X` and `Y`, this module implements the set of morphisms
    55`Hom(X,Y)`. This is done by :class:`SchemeHomset_generic`.
    66
    7 As a special case, the hom sets can also represent the points of a
     7As a special case, the Hom-sets can also represent the points of a
    88scheme. Recall that the `K`-rational points of a scheme `X` over `k`
    99can be identified with the set of morphisms `Spec(K) \to X`. In Sage
    1010the rational points are implemented by such scheme morphisms. This is
     
    1212
    1313.. note::
    1414
    15     You should not create the homsets manually. Instead, use the
     15    You should not create the Hom-sets manually. Instead, use the
    1616    :meth:`~sage.structure.parent.Hom` method that is inherited by all
    1717    schemes.
    1818   
     
    5656
    5757def is_SchemeHomset(H):
    5858    r"""
    59     Test whether ``H`` is a scheme homset.
     59    Test whether ``H`` is a scheme Hom-set.
    6060
    6161    EXAMPLES::
    6262
     
    7979#*******************************************************************
    8080class SchemeHomsetFactory(UniqueFactory):
    8181    """
    82     Factory for Hom sets of schemes.
     82    Factory for Hom-sets of schemes.
    8383
    8484    EXAMPLES::
    8585
     
    8787        sage: A3 = AffineSpace(QQ,3)
    8888        sage: Hom = A3.Hom(A2)
    8989       
    90     The Hom sets are unique::
     90    The Hom-sets are unique::
    9191   
    9292        sage: Hom is copy(Hom)
    9393        True
     
    9696        sage: loads(Hom.dumps()) is Hom
    9797        True
    9898
    99     Here is a tricky point. The Hom sets are not identical if
     99    Here is a tricky point. The Hom-sets are not identical if
    100100    domains/codomains are isomorphic but not identiacal::
    101101
    102102        sage: A3_iso = AffineSpace(QQ,3)
     
    119119    def create_key_and_extra_args(self, X, Y, category=None, base=ZZ,
    120120                                  check=True):
    121121        """
    122         Create a key that uniquely determines the Hom set.
     122        Create a key that uniquely determines the Hom-set.
    123123       
    124124        INPUT:
    125125       
     
    127127       
    128128        - ``Y`` -- a scheme. The codomain of the morphisms.
    129129       
    130         - ``category`` -- a category for the Hom sets (default: schemes over
     130        - ``category`` -- a category for the Hom-sets (default: schemes over
    131131          given base).
    132132
    133133        - ``base`` -- a scheme or a ring. The base scheme of domain
     
    205205        Y = extra_args.pop('Y')
    206206        base_ring = extra_args.pop('base_ring')
    207207        if is_Spec(X):
    208             return Y._point_homset_class(X, Y, category=category, base=base_ring, **extra_args)
     208            return Y._point_homset(X, Y, category=category, base=base_ring, **extra_args)
    209209        try:
    210             return X._homset_class(X, Y, category=category, base=base_ring, **extra_args)
     210            return X._homset(X, Y, category=category, base=base_ring, **extra_args)
    211211        except AttributeError:
    212212            return SchemeHomset_generic(X, Y, category=category, base=base_ring, **extra_args)
    213213
     
    221221#*******************************************************************
    222222class SchemeHomset_generic(HomsetWithBase):
    223223    r"""
    224     The base class for Hom sets of schemes.
     224    The base class for Hom-sets of schemes.
    225225
    226226    INPUT:
    227227
    228     - ``X`` -- a scheme. The domain of the Hom set.
     228    - ``X`` -- a scheme. The domain of the Hom-set.
    229229
    230     - ``Y`` -- a scheme. The codomain of the Hom set.
     230    - ``Y`` -- a scheme. The codomain of the Hom-set.
    231231
    232     - ``category`` -- a category (optional). The category of the Hom
    233       set.
     232    - ``category`` -- a category (optional). The category of the
     233      Hom-set.
    234234
    235235    - ``check`` -- boolean (optional, default=``True``). Whether to
    236236      check the defining data for consistency.
     
    250250
    251251    def __call__(self, *args, **kwds):
    252252        r"""
    253         Make Hom sets callable.
     253        Make Hom-sets callable.
    254254
    255255        See the ``_call_()`` method of the derived class. All
    256256        arguments are handed through.
     
    370370            TypeError: x must be a ring homomorphism, list or tuple
    371371        """
    372372        if isinstance(x, (list, tuple)):
    373             return self.domain()._morphism_class(self, x, check=check)
     373            return self.domain()._morphism(self, x, check=check)
    374374       
    375375        if is_RingHomomorphism(x):
    376376            return SchemeMorphism_spec(self, x, check=check)
     
    425425        INPUT:
    426426
    427427        - ``v`` -- anything that determines a scheme morphism in the
    428           hom set.
     428          Hom-set.
    429429
    430430        OUTPUT:
    431431
     
    455455        """
    456456        if len(v) == 1:
    457457            v = v[0]
    458         return self.codomain()._point_class(self, v, **kwds)
     458        return self.codomain()._point(self, v, **kwds)
    459459
    460460    def extended_codomain(self):
    461461        """
     
    510510
    511511    def value_ring(self):
    512512        """
    513         Return `R` for a point homset `X(Spec(R))`.
     513        Return `R` for a point Hom-set `X(Spec(R))`.
    514514
    515515        OUTPUT:
    516516       
     
    819819        INPUT:
    820820
    821821        - ``v`` -- anything that determines a scheme morphism in the
    822           hom set.
     822          Hom-set.
    823823
    824824        OUTPUT:
    825825
     
    841841        """
    842842        if len(v) == 1:
    843843            v = v[0]
    844         return self.codomain()._point_class(self.extended_codomain(), v, **kwds)
     844        return self.codomain()._point(self.extended_codomain(), v, **kwds)
    845845
    846846    def _repr_(self):
    847847        """
  • sage/schemes/generic/morphism.py

    diff --git a/sage/schemes/generic/morphism.py b/sage/schemes/generic/morphism.py
    a b  
    1111If you want to extend the Sage library with some new kind of scheme,
    1212your new class (say, ``myscheme``) should provide a method
    1313
    14 * ``myscheme._morphism_class(*args, **kwds)`` returning a morphism
     14* ``myscheme._morphism(*args, **kwds)`` returning a morphism
    1515  between two schemes in your category, usually defined via
    1616  polynomials. Your morphism class should derive from
    1717  :class:`SchemeMorphism_polynomial`. These morphisms will usually be
    18   elements of the hom set
     18  elements of the Hom-set
    1919  :class:`~sage.schemes.generic.homset.SchemeHomset_generic`.
    2020
    21 Optionally, you can also provide a special hom set class for your
     21Optionally, you can also provide a special Hom-set class for your
    2222subcategory of schemes. If you want to do this, you should also
    2323provide a method
    2424
    25 * ``myscheme._homset_class(*args, **kwds)`` returning a
    26   homset, which must be an element of a derived class of
     25* ``myscheme._homset(*args, **kwds)`` returning a
     26  Hom-set, which must be an element of a derived class of
    2727  `class:`~sage.schemes.generic.homset.SchemeHomset_generic`. If your
    28   new homset class does not use ``myscheme._morphism_class`` then you
     28  new Hom-set class does not use ``myscheme._morphism`` then you
    2929  do not have to provide it.
    3030
    3131Note that points on schemes are morphisms `Spec(K)\to X`, too. But we
    3232typically use a different notation, so they are implemented in a
    3333different derived class. For this, you should implement a method
    3434
    35 * ``myscheme._point_class(*args, **kwds)`` returning a point, that is,
     35* ``myscheme._point(*args, **kwds)`` returning a point, that is,
    3636  a morphism `Spec(K)\to X`. Your point class should derive from
    3737  :class:`SchemeMorphism_point`.
    3838
    39 Optionally, you can also provide a special hom set for the points, for
    40 example the point hom set can provide a method to enumerate all
     39Optionally, you can also provide a special Hom-set for the points, for
     40example the point Hom-set can provide a method to enumerate all
    4141points. If you want to do this, you should also provide a method
    4242
    43 * ``myscheme._point_homset_class(*args, **kwds)`` returning
    44   the :mod:`~sage.schemes.generic.homset` of points. The hom sets of
     43* ``myscheme._point_homset(*args, **kwds)`` returning
     44  the :mod:`~sage.schemes.generic.homset` of points. The Hom-sets of
    4545  points are implemented in classes named ``SchemeHomset_points_...``.
    46   If your new homset class does not use ``myscheme._point_class`` then
     46  If your new Hom-set class does not use ``myscheme._point`` then
    4747  you do not have to provide it. 
    4848
    4949AUTHORS:
     
    5858"""
    5959
    6060# Historical note: in trac #11599, V.B. renamed
    61 # * _point_morphism_class -> _morphism_class
    62 # * _homset_class -> _point_homset_class
     61# * _point_morphism_class -> _morphism
     62# * _homset_class -> _point_homset
    6363
    6464#*****************************************************************************
    6565#       Copyright (C) 2011 Volker Braun <vbraun.name@gmail.com>
     
    255255
    256256    def category(self):
    257257        """
    258         Return the category of the hom set.
     258        Return the category of the Hom-set.
    259259
    260260        OUTPUT:
    261261
     
    456456
    457457    INPUT:
    458458
    459     - ``parent`` -- homset with codomain equal to the base scheme of
     459    - ``parent`` -- Hom-set with codomain equal to the base scheme of
    460460      the domain.
    461461
    462462    EXAMPLES::
     
    508508
    509509    INPUT:
    510510
    511     - ``parent`` -- homset whose domain and codomain are affine schemes.
     511    - ``parent`` -- Hom-set whose domain and codomain are affine schemes.
    512512
    513513    - ``phi`` -- a ring morphism with matching domain and codomain.
    514514
     
    674674
    675675    INPUT:
    676676
    677     - ``parent`` -- homset whose domain and codomain are affine schemes.
     677    - ``parent`` -- Hom-set whose domain and codomain are affine schemes.
    678678
    679679    - ``polys`` -- a list/tuple/iterable of polynomials defining the
    680680      scheme morphism.
  • sage/schemes/generic/projective_space.py

    diff --git a/sage/schemes/generic/projective_space.py b/sage/schemes/generic/projective_space.py
    a b  
    348348        """
    349349        return "{\\mathbf P}_{%s}^%s"%(latex(self.base_ring()), self.dimension_relative())
    350350
    351     def _morphism_class(self, *args, **kwds):
     351    def _morphism(self, *args, **kwds):
     352        """
     353        Construct a morphism.
     354
     355        For internal use only. See :mod:`morphism` for details.
     356
     357        TESTS::
     358
     359            sage: P2.<x,y,z> = ProjectiveSpace(2, GF(3))
     360            sage: P2._morphism(P2.Hom(P2), [x,y,z])
     361            Scheme endomorphism of Projective Space of dimension 2 over Finite Field of size 3
     362              Defn: Defined on coordinates by sending (x : y : z) to
     363                    (x : y : z)
     364        """
    352365        return morphism.SchemeMorphism_polynomial_projective_space(*args, **kwds)
    353366
    354     def _point_homset_class(self, *args, **kwds):
     367    def _point_homset(self, *args, **kwds):
     368        """
     369        Construct a point Hom-set.
     370
     371        For internal use only. See :mod:`morphism` for details.
     372
     373        TESTS::
     374       
     375            sage: P2.<x,y,z> = ProjectiveSpace(2, GF(3))
     376            sage: P2._point_homset(Spec(GF(3)), P2)
     377            Set of rational points of Projective Space of dimension 2 over Finite Field of size 3
     378        """
    355379        return homset.SchemeHomset_points_projective_ring(*args, **kwds)
    356380
    357     def _point_class(self, *args, **kwds):
     381    def _point(self, *args, **kwds):
     382        """
     383        Construct a point.
     384
     385        For internal use only. See :mod:`morphism` for details.
     386
     387        TESTS::
     388
     389            sage: P2.<x,y,z> = ProjectiveSpace(2, GF(3))
     390            sage: point_homset = P2._point_homset(Spec(GF(3)), P2)
     391            sage: P2._point(point_homset, [1,2,3])
     392            (2 : 1 : 0)
     393        """
    358394        return morphism.SchemeMorphism_point_projective_ring(*args, **kwds)
    359395
    360396    def _repr_(self):
     
    459495       
    460496        INPUT:
    461497       
    462        
    463498        -  ``X`` - a list or tuple of equations
    464499       
    465        
    466500        EXAMPLES::
    467501       
    468502            sage: A.<x,y,z> = ProjectiveSpace(2, QQ)
     
    504538       
    505539        INPUT:
    506540       
     541        - ``i`` -- integer between 0 and dimension of self, inclusive.
    507542       
    508         -  ``i`` - integer between 0 and dimension of self,
    509            inclusive.
    510        
    511        
    512         OUTPUT: an ambient affine space with fixed projective_embedding
    513         map.
     543        OUTPUT:
     544
     545        An ambient affine space with fixed projective_embedding map.
    514546       
    515547        EXAMPLES::
    516548       
     
    550582
    551583
    552584class ProjectiveSpace_field(ProjectiveSpace_ring):
    553     def _point_homset_class(self, *args, **kwds):
     585    def _point_homset(self, *args, **kwds):
     586        """
     587        Construct a point Hom-set.
     588
     589        For internal use only. See :mod:`morphism` for details.
     590
     591        TESTS::
     592       
     593            sage: P2.<x,y,z> = ProjectiveSpace(2, GF(3))
     594            sage: P2._point_homset(Spec(GF(3)), P2)
     595            Set of rational points of Projective Space of dimension 2 over Finite Field of size 3
     596        """
    554597        return homset.SchemeHomset_points_projective_field(*args, **kwds)
    555598
    556     def _point_class(self, *args, **kwds):
     599    def _point(self, *args, **kwds):
     600        """
     601        Construct a point.
     602
     603        For internal use only. See :mod:`morphism` for details.
     604
     605        TESTS::
     606
     607            sage: P2.<x,y,z> = ProjectiveSpace(2, GF(3))
     608            sage: point_homset = P2._point_homset(Spec(GF(3)), P2)
     609            sage: P2._point(point_homset, [1,2,3])
     610            (2 : 1 : 0)
     611        """
    557612        return morphism.SchemeMorphism_point_projective_field(*args, **kwds)
    558613
    559614   
  • sage/schemes/generic/scheme.py

    diff --git a/sage/schemes/generic/scheme.py b/sage/schemes/generic/scheme.py
    a b  
    175175
    176176    __add__ = union
    177177
    178     def _morphism_class(self, *args, **kwds):
     178    def _morphism(self, *args, **kwds):
    179179        """
    180180        Construct a morphism determined by action on points of ``self``.
    181181
    182182        EXAMPLES::
    183183       
    184184            sage: X = Spec(QQ)
    185             sage: X._morphism_class()
     185            sage: X._morphism()
    186186            Traceback (most recent call last):
    187187            ...
    188188            NotImplementedError
     
    358358        # todo: update elliptic curve stuff to take point_homset as argument
    359359        from sage.schemes.elliptic_curves.ell_generic import is_EllipticCurve
    360360        if is_EllipticCurve(self):
    361             return self._point_class(self, v, check=check)
     361            return self._point(self, v, check=check)
    362362
    363363        return self.point_homset() (v, check=check)
    364364   
    365     def _point_class(self):
     365    def _point(self):
    366366        """
    367         Return the Hom set from some affine scheme to ``self``.
     367        Return the Hom-set from some affine scheme to ``self``.
    368368
    369369        OUTPUT:
    370370
    371         A scheme hom set, see :mod:`~sage.schemes.generic.homset`.
     371        A scheme Hom-set, see :mod:`~sage.schemes.generic.homset`.
    372372
    373373        EXAMPLES::
    374374       
    375375            sage: X = Spec(QQ)
    376             sage: X._point_class()
     376            sage: X._point()
    377377            Traceback (most recent call last):
    378378            ...
    379379            NotImplementedError
    380380        """
    381381        raise NotImplementedError
    382382
    383     def _point_homset_class(self, *args, **kwds):
     383    def _point_homset(self, *args, **kwds):
    384384        """
    385         Return the Hom set from ``self`` to another scheme.
     385        Return the Hom-set from ``self`` to another scheme.
    386386
    387387        EXAMPLES::
    388388       
    389389            sage: from sage.schemes.generic.scheme import Scheme
    390390            sage: X = Scheme(QQ)
    391             sage: X._point_homset_class()
     391            sage: X._point_homset()
    392392            Traceback (most recent call last):
    393393            ...
    394394            NotImplementedError
     
    641641
    642642        INPUT:
    643643
    644         - ``Y`` -- a scheme. The codomain of the Hom set.
     644        - ``Y`` -- a scheme. The codomain of the Hom-set.
    645645
    646646        - ``category`` -- a category (optional). The category of the
    647           Hom set.
     647          Hom-set.
    648648
    649649        - ``check`` -- boolean (optional, default=``True``). Whether
    650650          to check the defining data for consistency.
  • sage/schemes/generic/spec.py

    diff --git a/sage/schemes/generic/spec.py b/sage/schemes/generic/spec.py
    a b  
    365365        return Spec(self.coordinate_ring().base_extend(new_base.coordinate_ring()),
    366366                    self.base_ring())
    367367
    368     def _point_homset_class(self, *args, **kwds):
     368    def _point_homset(self, *args, **kwds):
    369369        """
    370         Return the Hom set class.
     370        Construct a point Hom-set.
     371       
     372        For internal use only. See :mod:`morphism` for more details.
    371373       
    372374        EXAMPLES::
    373375       
    374             sage: Spec(QQ)._point_homset_class(Spec(QQ), Spec(ZZ))
     376            sage: Spec(QQ)._point_homset(Spec(QQ), Spec(ZZ))
    375377            Set of rational points of Spectrum of Integer Ring
    376378        """
    377379        from sage.schemes.generic.homset import SchemeHomset_points_spec
  • sage/schemes/generic/toric_homset.py

    diff --git a/sage/schemes/generic/toric_homset.py b/sage/schemes/generic/toric_homset.py
    a b  
    44For schemes `X` and `Y`, this module implements the set of morphisms
    55`Hom(X,Y)`. This is done by :class:`SchemeHomset_generic`.
    66
    7 As a special case, the hom sets can also represent the points of a
     7As a special case, the Hom-sets can also represent the points of a
    88scheme. Recall that the `K`-rational points of a scheme `X` over `k`
    99can be identified with the set of morphisms `Spec(K) \to X`. In Sage,
    1010the rational points are implemented by such scheme morphisms. This is
     
    1212
    1313.. note::
    1414
    15     You should not create the homsets manually. Instead, use the
     15    You should not create the Hom-sets manually. Instead, use the
    1616    :meth:`~sage.structure.parent.Hom` method that is inherited by all
    1717    schemes.
    1818"""
  • sage/schemes/generic/toric_morphism.py

    diff --git a/sage/schemes/generic/toric_morphism.py b/sage/schemes/generic/toric_morphism.py
    a b  
    353353
    354354    INPUT:
    355355
    356     - ``parent`` -- homset whose domain and codomain are toric varieties.
     356    - ``parent`` -- Hom-set whose domain and codomain are toric varieties.
    357357
    358358    - ``fan_morphism`` -- A morphism of fans whose domain and codomain
    359359      fans equal the fans of the domain and codomain in the ``parent``
    360       homset.
     360      Hom-set.
    361361
    362362    - ``check`` -- boolean (optional, default:``True``). Whether to
    363363      check the input for consistency.
  • sage/schemes/generic/toric_variety.py

    diff --git a/sage/schemes/generic/toric_variety.py b/sage/schemes/generic/toric_variety.py
    a b  
    616616        raise TypeError("coordinates %s are in the exceptional set!"
    617617                        % str(coordinates)) # Need str, coordinates is a tuple
    618618
    619     def _point_homset_class(self, *args, **kwds):
     619    def _point_homset(self, *args, **kwds):
    620620        r"""
    621         Construct a `Hom`-space for ``self``.
     621        Construct a Hom-set for ``self``.
    622622
    623623        INPUT:
    624624
     
    634634
    635635            sage: fan = FaceFan(lattice_polytope.octahedron(2))
    636636            sage: P1xP1 = ToricVariety(fan)
    637             sage: P1xP1._point_homset_class(Spec(QQ), P1xP1)
     637            sage: P1xP1._point_homset(Spec(QQ), P1xP1)
    638638            Set of rational points of 2-d toric variety
    639639            covered by 4 affine patches
    640640        """
     
    684684        return r"\left[%s\right]" % (" : ".join(str(latex(coord))
    685685                                                for coord in coordinates))
    686686
    687     def _point_class(self, *args, **kwds):
     687    def _point(self, *args, **kwds):
    688688        r"""
    689689        Construct a point of ``self``.
    690690
     
    701701
    702702            sage: fan = FaceFan(lattice_polytope.octahedron(2))
    703703            sage: P1xP1 = ToricVariety(fan)
    704             sage: P1xP1._point_class(P1xP1, [1,2,3,4])
     704            sage: P1xP1._point(P1xP1, [1,2,3,4])
    705705            [1 : 2 : 3 : 4]
    706706        """
    707707        from sage.schemes.generic.toric_morphism import SchemeMorphism_point_toric_field
    708708        return SchemeMorphism_point_toric_field(*args, **kwds)
    709709
    710     def _homset_class(self, *args, **kwds):
     710    def _homset(self, *args, **kwds):
    711711        r"""
    712712        Return the homset between two toric varieties.
    713713
  • sage/schemes/hyperelliptic_curves/jacobian_generic.py

    diff --git a/sage/schemes/hyperelliptic_curves/jacobian_generic.py b/sage/schemes/hyperelliptic_curves/jacobian_generic.py
    a b  
    129129        except AttributeError:
    130130            raise ValueError, "Arguments must determine a valid Mumford divisor."
    131131
    132     def _point_homset_class(self, *args, **kwds):
     132    def _point_homset(self, *args, **kwds):
    133133        return jacobian_homset.JacobianHomset_divisor_classes(*args, **kwds)
    134134
    135     def _point_class(self, *args, **kwds):
     135    def _point(self, *args, **kwds):
    136136        return jacobian_morphism.JacobianMorphism_divisor_class_field(*args, **kwds)
    137137
    138138    def _cmp_(self,other):
  • sage/schemes/hyperelliptic_curves/jacobian_homset.py

    diff --git a/sage/schemes/hyperelliptic_curves/jacobian_homset.py b/sage/schemes/hyperelliptic_curves/jacobian_homset.py
    a b  
    156156        else:
    157157            return -1
    158158
    159     def _morphism_class(self, *args, **kwds):
     159    def _morphism(self, *args, **kwds):
    160160        return JacobianMorphism_divisor_class_field(*args, **kwds)
    161161
    162162    def curve(self):
  • sage/schemes/jacobians/abstract_jacobian.py

    diff --git a/sage/schemes/jacobians/abstract_jacobian.py b/sage/schemes/jacobians/abstract_jacobian.py
    a b  
    144144        """
    145145        return "Jacobian of %s"%self.__curve
    146146
    147     def _point_class(self):
     147    def _point(self):
     148        """
     149        Return the Hom-set from some affine scheme to ``self``.
     150
     151        OUTPUT:
     152
     153        This method always raises a ``NotImplementedError``; it is
     154        only abstract.
     155
     156        EXAMPLES::
     157       
     158            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
     159            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
     160            sage: J = Jacobian(Curve(x^3 + y^3 + z^3))
     161            sage: J._point()
     162            Traceback (most recent call last):
     163            ...
     164            NotImplementedError
     165        """
    148166        raise NotImplementedError
    149167
    150168    def curve(self):