Ticket #9054: trac_9054-part3.patch

File trac_9054-part3.patch, 23.5 KB (added by was, 7 years ago)
  • sage/rings/function_field/constructor.py

    # HG changeset patch
    # User William Stein <wstein@gmail.com>
    # Date 1274928994 25200
    # Node ID 7f05bf6d613ef8004b9d767401fe6ddfc70c8b38
    # Parent  c3dd4c08eaefb4782dc8bf946a611bfeb4fe5a82
    [mq]: trac-9054-part3.patch
    
    diff -r c3dd4c08eaef -r 7f05bf6d613e sage/rings/function_field/constructor.py
    a b  
    11import function_field
    22
    33def FunctionField(X, names=None):
     4    """
     5    Return the function field defined by X.
     6
     7    INPUT:
     8
     9        - `X` -- a field; return the function field in one variable over X.
     10
     11        - ``names`` -- name of variable as a string
     12   
     13    EXAMPLES::
     14
     15        sage: FunctionField(QQ,'alpha')
     16        Rational function field in alpha over Rational Field
     17        sage: K.<alpha> = FunctionField(GF(7)); K
     18        Rational function field in alpha over Finite Field of size 7
     19    """
    420    return function_field.RationalFunctionField(X, names=names)
    521   
  • sage/rings/function_field/function_field.py

    diff -r c3dd4c08eaef -r 7f05bf6d613e sage/rings/function_field/function_field.py
    a b  
    259259        """
    260260        return self._base_field
    261261
     262    def random_element(self, *args, **kwds):
     263        """
     264        Create a random element of this function field.  Parameters
     265        are passed onto the random_element method of the base_field.
     266
     267        EXAMPLES::
     268
     269            sage: K.<x> = FunctionField(QQ); R.<y> = K[]
     270            sage: L.<w> = K.extension(y^2 - (x^2 + x))
     271            sage: L.random_element()
     272            ((x^2 - x + 2/3)/(x^2 + 1/3*x - 1))*w^2 + ((-1/4*x^2 + 1/2*x - 1)/(-5/2*x + 2/3))*w + (-1/2*x^2 - 4)/(-12*x^2 + 1/2*x - 1/95)
     273        """
     274        return self(self._ring.random_element(degree=self.degree(), *args, **kwds))
     275
    262276    def polynomial(self):
    263277        """
    264278        Return the univariate polynomial that defines this function
     
    507521
    508522        Must be over a field::
    509523       
    510             sage: FunctionField(ZZ)
     524            sage: FunctionField(ZZ, 't')
    511525            Traceback (most recent call last):
    512526            ...
    513527            TypeError: constant_field must be a field
    514528        """
     529        if names is None:
     530            raise ValueError, "variable name must be specified"
    515531        if not constant_field.is_field():
    516532            raise TypeError, "constant_field must be a field"
    517533        ParentWithGens.__init__(self, self, names=names, category = category)
     
    579595                raise TypeError
    580596        return function_field_element.FunctionFieldElement_P1(self, self._field(x))
    581597
     598    def random_element(self, *args, **kwds):
     599        """
     600        Create a random element of this rational function field.
     601        Parameters are passed onto the random_element method of the
     602        underlying fraction field.
     603
     604        EXAMPLES::
     605
     606            sage: FunctionField(QQ,'alpha').random_element()
     607            (-1/2*a^2 - 4)/(-12*a^2 + 1/2*a - 1/95)
     608        """
     609        return self(self._field.random_element(*args, **kwds))
     610
    582611    def degree(self):
    583612        """
    584613        Return the degree over the base field of this rational
  • sage/rings/function_field/function_field_element.py

    diff -r c3dd4c08eaef -r 7f05bf6d613e sage/rings/function_field/function_field_element.py
    a b  
    11from sage.structure.element import FieldElement
    22
     3def is_FunctionFieldElement(x):
     4    """
     5    Return True if x is any type of function field element.
     6   
     7    EXAMPLES::
     8
     9        sage: t = FunctionField(QQ,'t').gen()
     10        sage: sage.rings.function_field.function_field_element.is_FunctionFieldElement(t)
     11        True
     12        sage: sage.rings.function_field.function_field_element.is_FunctionFieldElement(0)
     13        False
     14    """
     15    return isinstance(x, FunctionFieldElement)
     16
    317class FunctionFieldElement(FieldElement):
    4     pass
     18    """
     19    The abstract base class for function field elements.
     20   
     21    EXAMPLES::
    522
     23        sage: t = FunctionField(QQ,'t').gen()
     24        sage: isinstance(t, sage.rings.function_field.function_field_element.FunctionFieldElement)
     25        True
     26    """
     27    def matrix(self):
     28        r"""
     29        Return the matrix of multiplication by self.
     30
     31        EXAMPLES::
     32
     33        A rational function field:
     34       
     35            sage: K.<t> = FunctionField(QQ)
     36            sage: t.matrix()
     37            [t]
     38            sage: (1/(t+1)).matrix()
     39            [1/(t + 1)]
     40
     41        Now an example in a nontrivial extension of a rational function field::
     42       
     43            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     44            sage: Y.matrix()
     45            [     0      1]
     46            [-4*x^3      x]
     47            sage: Y.matrix().charpoly('Z')
     48            Z^2 - x*Z + 4*x^3
     49
     50        An example in a relative extension, where neither function
     51        field is rational::
     52
     53            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     54            sage: M.<T> = L[]; Z.<alpha> = L.extension(T^3 - Y^2*T + x)
     55            sage: alpha.matrix()
     56            [          0           1           0]
     57            [          0           0           1]
     58            [         -x x*Y - 4*x^3           0]
     59        """
     60        try: return self._matrix
     61        except AttributeError:
     62            # Multiply each power of field generator on the left by this
     63            # element; make matrix whose rows are the coefficients of the
     64            # result, and transpose.
     65            K = self.parent()
     66            v = []
     67            x = K.gen()
     68            a = K(1)
     69            d = K.degree()
     70            for n in range(d):
     71                v += (a*self).list()
     72                a *= x
     73            k = K.base_ring()
     74            import sage.matrix.matrix_space
     75            M = sage.matrix.matrix_space.MatrixSpace(k, d)
     76            self._matrix = M(v)
     77            return self._matrix
     78
     79    def trace(self):
     80        """
     81        Return the trace of this function field element.
     82
     83        EXAMPLES::
     84
     85            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     86            sage: Y.trace()
     87            x
     88        """
     89        return self.matrix().trace()
     90
     91    def norm(self):
     92        """
     93        Return the norm of this function field element.
     94
     95        EXAMPLES::
     96       
     97            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     98            sage: Y.norm()
     99            4*x^3
     100
     101
     102        The norm is relative::
     103       
     104            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     105            sage: M.<T> = L[]; Z.<alpha> = L.extension(T^3 - Y^2*T + x)
     106            sage: alpha.norm()
     107            -x
     108            sage: alpha.norm().parent()
     109            Function field in Y defined by y^2 - x*y + 4*x^3
     110        """
     111        return self.matrix().determinant()
     112
     113    def characteristic_polynomial(self, *args, **kwds):
     114        """
     115        Return the characteristic polynomial of this function field
     116        element.  Give an optional input string to name the variable
     117        in the characteristic polynomial.
     118
     119        EXAMPLES::
     120
     121            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     122            sage: M.<T> = L[]; Z.<alpha> = L.extension(T^3 - Y^2*T + x)
     123            sage: x.characteristic_polynomial('W')
     124            W - x
     125            sage: Y.characteristic_polynomial('W')
     126            W^2 - x*W + 4*x^3
     127            sage: alpha.characteristic_polynomial('W')
     128            W^3 + (-x*Y + 4*x^3)*W + x
     129        """
     130        return self.matrix().characteristic_polynomial(*args, **kwds)
     131
     132    charpoly = characteristic_polynomial
     133
     134    def minimal_polynomial(self, *args, **kwds):
     135        """
     136        Return the minimal polynomial of this function field element.
     137        Give an optional input string to name the variable in the
     138        characteristic polynomial.
     139
     140        EXAMPLES::
     141
     142            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     143            sage: M.<T> = L[]; Z.<alpha> = L.extension(T^3 - Y^2*T + x)
     144            sage: x.minimal_polynomial('W')
     145            W - x
     146            sage: Y.minimal_polynomial('W')
     147            W^2 - x*W + 4*x^3
     148            sage: alpha.minimal_polynomial('W')
     149            W^3 + (-x*Y + 4*x^3)*W + x
     150        """
     151        return self.matrix().minimal_polynomial(*args, **kwds)
     152
     153    minpoly = minimal_polynomial
     154   
    6155class FunctionFieldElement_polymod(FunctionFieldElement):
     156    """
     157    EXAMPLES::
     158
     159        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     160        sage: x*Y + 1/x^3
     161        x*Y + 1/x^3       
     162    """
    7163    def __init__(self, parent, x):
     164        """
     165        EXAMPLES::
     166
     167             sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     168             sage: type(Y)
     169             <class 'sage.rings.function_field.function_field_element.FunctionFieldElement_polymod'>             
     170        """
    8171        FieldElement.__init__(self, parent)
    9172        self._x = x
    10173
    11174    def _repr_(self):
     175        """
     176        EXAMPLES::
     177
     178            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     179            sage: Y._repr_()
     180            'Y'
     181        """
    12182        return self._x._repr(name=self.parent().variable_name())
    13183       
    14184    def __nonzero__(self):
     185        """
     186        EXAMPLES::
     187
     188            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     189            sage: bool(Y)
     190            True
     191            sage: bool(L(0))
     192            False
     193        """
    15194        return self._x.__nonzero__()
    16195
    17196    def __cmp__(self, other):
     197        """
     198        EXAMPLES::
     199
     200            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     201            sage: cmp(L, 0)
     202            1
     203            sage: cmp(0, L)
     204            -1
     205        """
    18206        return cmp(self._x, other._x)
    19207
    20208    def _add_(self, right):
     209        """
     210        EXAMPLES::
     211
     212            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     213            sage: (2*Y + x/(1+x^3))  +  (3*Y + 5*x*Y)         # indirect doctest
     214            (5*x + 5)*Y + x/(x^3 + 1)
     215        """
    21216        return self.parent()(self._x + right._x)
    22217
    23218    def _sub_(self, right):
     219        """
     220        EXAMPLES::
     221
     222            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     223            sage: (2*Y + x/(1+x^3))  -  (3*Y + 5*x*Y)         # indirect doctest
     224            (-5*x - 1)*Y + x/(x^3 + 1)
     225        """
    24226        return self.parent()(self._x - right._x)
    25227
    26228    def _mul_(self, right):
     229        """
     230        EXAMPLES::
     231
     232            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     233            sage: Y  *  (3*Y + 5*x*Y)                          # indirect doctest
     234            (5*x^2 + 3*x)*Y - 20*x^4 - 12*x^3
     235        """
    27236        P = self.parent()
    28237        f = self._x * right._x
    29238        return P(f.quo_rem(P._polynomial)[1])
    30239
    31240    def _div_(self, right):
     241        """
     242        EXAMPLES::
     243
     244            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     245            sage: (2*Y + x/(1+x^3))  /  (2*Y + x/(1+x^3))       # indirect doctest
     246            1
     247        """
    32248        return self * ~right
    33249
    34250    def __invert__(self):
     251        """
     252        EXAMPLES::
     253
     254            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     255            sage: a = ~(2*Y + 1/x); a                           # indirect doctest
     256            (-x^2/(8*x^5 + x^2 + 1/2))*Y + (2*x^3 + x)/(16*x^5 + 2*x^2 + 1)
     257            sage: a*(2*Y + 1/x)
     258            1
     259        """
    35260        P = self.parent()
    36261        return P(self._x.xgcd(P._polynomial)[1])
    37262
    38263    def list(self):
     264        """
     265        EXAMPLES::
     266
     267            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     268            sage: a = ~(2*Y + 1/x); a
     269            (-x^2/(8*x^5 + x^2 + 1/2))*Y + (2*x^3 + x)/(16*x^5 + 2*x^2 + 1)
     270            sage: a.list()
     271            [(2*x^3 + x)/(16*x^5 + 2*x^2 + 1), -x^2/(8*x^5 + x^2 + 1/2)]
     272            sage: (x*Y).list()
     273            [0, x]
     274        """
    39275        return self._x.padded_list(self.parent().degree())
    40276       
    41277
    42278class FunctionFieldElement_P1(FunctionFieldElement):
     279    """
     280    EXAMPLES::
     281   
     282        sage: FunctionField(QQ, 't')
     283        Rational function field in t over Rational Field
     284    """
    43285    def __init__(self, parent, x):
     286        """
     287        EXAMPLES::
     288       
     289            sage: FunctionField(QQ,'t').gen()^3
     290            t^3
     291        """
    44292        FieldElement.__init__(self, parent)
    45293        self._x = x
    46294
    47295    def list(self):
     296        """
     297        EXAMPLES::
     298
     299            sage: K.<t> = FunctionField(QQ)
     300            sage: t.list()
     301            [t]
     302        """
    48303        return [self]
    49304
    50305    def _repr_(self):
     306        """
     307        EXAMPLES::
     308
     309            sage: K.<t> = FunctionField(QQ)
     310            sage: t._repr_()
     311            't'
     312        """
    51313        return repr(self._x)
    52314       
    53315    def __nonzero__(self):
     316        """
     317        EXAMPLES::
     318
     319            sage: K.<t> = FunctionField(QQ)
     320            sage: bool(t)
     321            True
     322            sage: bool(K(0))
     323            False
     324            sage: bool(K(1))
     325            True
     326        """
    54327        return self._x.__nonzero__()
    55328
    56329    def __cmp__(self, other):
     330        """
     331        EXAMPLES::
     332
     333            sage: K.<t> = FunctionField(QQ)
     334            sage: cmp(t, 0)
     335            1
     336            sage: cmp(t, t^2)
     337            -1
     338        """
    57339        return cmp(self._x, other._x)
    58340
    59341    def _add_(self, right):
     342        """
     343        EXAMPLES::
     344       
     345            sage: K.<t> = FunctionField(QQ)
     346            sage: t + (3*t^3)                      # indirect doctest
     347            3*t^3 + t
     348        """
    60349        return self.parent()(self._x + right._x)
    61350
    62351    def _sub_(self, right):
     352        """
     353        EXAMPLES::
     354
     355
     356            sage: K.<t> = FunctionField(QQ)
     357            sage: t - (3*t^3)                      # indirect doctest
     358            -3*t^3 + t
     359        """
    63360        return self.parent()(self._x - right._x)
    64361
    65362    def _mul_(self, right):
     363        """
     364        EXAMPLES::
     365
     366            sage: K.<t> = FunctionField(QQ)
     367            sage: (t+1) * (t^2-1)                  # indirect doctest
     368            t^3 + t^2 - t - 1
     369        """
    66370        return self.parent()(self._x * right._x)
    67371
    68372    def _div_(self, right):
     373        """
     374        EXAMPLES::
     375
     376            sage: K.<t> = FunctionField(QQ)
     377            sage: (t+1) / (t^2 - 1)                # indirect doctest
     378            1/(t - 1)
     379        """
    69380        return self.parent()(self._x / right._x)
     381
     382    def numerator(self):
     383        """
     384        EXAMPLES::
     385
     386            sage: K.<t> = FunctionField(QQ)
     387            sage: f = (t+1) / (t^2 - 1/3); f
     388            (t + 1)/(t^2 - 1/3)
     389            sage: f.numerator()                    # indirect doctest
     390            t + 1
     391        """
     392        return self._x.numerator()
     393
     394    def denominator(self):
     395        """
     396        EXAMPLES::
     397
     398            sage: K.<t> = FunctionField(QQ)
     399            sage: f = (t+1) / (t^2 - 1/3); f
     400            (t + 1)/(t^2 - 1/3)
     401            sage: f.denominator()                  # indirect doctest
     402            t^2 - 1/3
     403        """
     404        return self._x.denominator()
  • sage/rings/function_field/maps.py

    diff -r c3dd4c08eaef -r 7f05bf6d613e sage/rings/function_field/maps.py
    a b  
    99    r"""
    1010    A base class for various isomorphisms between function fields and
    1111    vector spaces.
     12
     13    EXAMPLES::
     14
     15        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     16        sage: V, f, t = L.vector_space()
     17        sage: isinstance(f, sage.rings.function_field.maps.FunctionFieldIsomorphism)
     18        True
    1219    """
    1320    def _repr_type(self):
     21        """
     22        Return the type of this map (an isomorphism), for the purposes of printing out self. 
     23       
     24        EXAMPLES::
     25
     26            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     27            sage: V, f, t = L.vector_space()
     28            sage: f._repr_type()
     29            'Isomorphism'
     30        """
    1431        return "Isomorphism"
    1532
    1633    def is_injective(self):
     34        """
     35        Return True, since this isomorphism is injective.
     36       
     37        EXAMPLES::
     38
     39            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     40            sage: V, f, t = L.vector_space()           
     41            sage: f.is_injective()
     42            True
     43        """
    1744        return True
    1845
    1946    def is_surjective(self):
     47        """
     48        Return True, since this isomorphism is surjective.
     49       
     50        EXAMPLES::
     51
     52            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     53            sage: V, f, t = L.vector_space()           
     54            sage: f.is_surjective()
     55            True
     56        """
    2057        return True
    2158
    2259class MapVectorSpaceToFunctionField(FunctionFieldIsomorphism):
    2360    r"""
     61    An isomorphism from a vector space and a function field.
     62   
    2463    EXAMPLES:
    2564
     65        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     66        sage: V, f, t = L.vector_space(); f
     67        Isomorphism map:
     68          From: Vector space of dimension 2 over Rational function field in x over Rational Field
     69          To:   Function field in Y defined by y^2 - x*y + 4*x^3
    2670    """
    2771    def __init__(self, V, K):
     72        """
     73        EXAMPLES::
     74       
     75            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     76            sage: V, f, t = L.vector_space(); type(f)
     77            <class 'sage.rings.function_field.maps.MapVectorSpaceToFunctionField'>
     78        """
    2879        self._V = V
    2980        self._K = K
    3081        self._R = K.polynomial_ring()
    3182        FunctionFieldIsomorphism.__init__(self, Hom(V, K))
    3283
    3384    def _call_(self, v):
     85        """
     86        EXAMPLES::
     87
     88            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     89            sage: V, f, t = L.vector_space()                       
     90            sage: f(x*V.0 + (1/x^3)*V.1)         # indirect doctest
     91            1/x^3*Y + x
     92        """
    3493        f = self._R(self._V(v).list())
    3594        return self._K(f)
    3695
    3796    def domain(self):
     97        """
     98        EXAMPLES::
     99
     100            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     101            sage: V, f, t = L.vector_space()                                   
     102            sage: f.domain()
     103            Vector space of dimension 2 over Rational function field in x over Rational Field
     104        """
    38105        return self._V
    39106
    40107    def codomain(self):
     108        """
     109        EXAMPLES::
     110
     111            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     112            sage: V, f, t = L.vector_space()                                   
     113            sage: f.codomain()
     114            Function field in Y defined by y^2 - x*y + 4*x^3
     115        """
    41116        return self._K
    42117
    43 class MapFunctionFieldToVectorSpace(Map):
     118
     119class MapFunctionFieldToVectorSpace(FunctionFieldIsomorphism):
     120    """
     121    An isomorphism from a function field to a vector space.
     122   
     123    EXAMPLES::
     124
     125        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     126        sage: V, f, t = L.vector_space(); t
     127        Isomorphism map:
     128          From: Function field in Y defined by y^2 - x*y + 4*x^3
     129          To:   Vector space of dimension 2 over Rational function field in x over Rational Field
     130    """
    44131    def __init__(self, K, V):
     132        """
     133        EXAMPLES::
     134
     135            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     136            sage: V, f, t = L.vector_space(); type(t)
     137            <class 'sage.rings.function_field.maps.MapFunctionFieldToVectorSpace'>
     138        """
    45139        self._V = V
    46140        self._K = K
    47141        self._zero = K.base_ring()(0)
     
    49143        FunctionFieldIsomorphism.__init__(self, Hom(K, V))
    50144
    51145    def domain(self):
     146        """
     147        EXAMPLES::
     148
     149            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     150            sage: V, f, t = L.vector_space()                                   
     151            sage: t.domain()
     152            Function field in Y defined by y^2 - x*y + 4*x^3
     153        """
    52154        return self._K
    53155
    54156    def codomain(self):
     157        """
     158        EXAMPLES::
     159
     160            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     161            sage: V, f, t = L.vector_space()                                   
     162            sage: t.codomain()
     163            Vector space of dimension 2 over Rational function field in x over Rational Field       
     164        """
    55165        return self._V
    56166
    57167    def _repr_type(self):
     168        """
     169        EXAMPLES::
     170
     171            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     172            sage: V, f, t = L.vector_space()
     173            sage: t._repr_type()
     174            'Isomorphism'
     175        """
    58176        return "Isomorphism"
    59177   
    60178    def _call_(self, x):
     179        """
     180        EXAMPLES::
     181
     182            sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<Y> = K.extension(y^2 - x*y + 4*x^3)
     183            sage: V, f, t = L.vector_space()                                   
     184            sage: t(x + (1/x^3)*Y)                       # indirect doctest
     185            (x, 1/x^3)
     186        """
    61187        y = self._K(x)
    62188        v = y.list()
    63189        w = v + [self._zero]*(self._n - len(v))
  • sage/rings/function_field/todo.txt

    diff -r c3dd4c08eaef -r 7f05bf6d613e sage/rings/function_field/todo.txt
    a b  
     1TODO:
    12
    23[ ] conversion back and forth between a free module over base
     4[ ] Docstring headers for each file with description of content of file
     5[ ] copyright headers
     6[ ] polynomial factoring of any univariate poly over a function field: reduce to bivariate over constant field?
     7[ ] checking irreducibility in FunctionField_polymod constructor
     8[ ] pickle doctests
     9[ ] TestSuite(s).run() doctests
     10[ ] ideals
     11[ ] non-monic defining polynomials
     12[ ] a command FunctionField to make a new function field from anything.
     13[ ] method function_field() on algebraic curves, that give back a corresponding function field object.
     14[ ] random element
    315
    4 [ ] Docstring headers for each file with description of content of file
    5 
    6 [ ] copyright headers
    7 
    8 [ ] polynomial factoring of any univariate poly over a function field: reduce to bivariate over constant field?
    9 
    10 [ ] checking irreducibility in FunctionField_polymod constructor
    11 
    12 [ ] pickle doctests
    13 
    14 [ ] TestSuite(s).run() doctests
    15 
    16 [ ] ideals
    17 
    18 [ ] non-monic defining polynomials
    19 
    20 [ ] 100% coverage
    21 
    22 [ ] matrix of element
    23 
    24 [ ] norm
    25 
    26 [ ] trace
    27 
    28 [ ] a command FunctionField to make a new function field from anything.
    29 
    30 [ ] method function_field() on algebraic curves, that give back a corresponding function field object.
    31 
    32 [ ]
     16DONE:
     17[x] numerator, denominator
     18[x] 100% coverage
     19[x] matrix of element
     20[x] norm
     21[x] trace