### Navigation

- index
- modules |
- next |
- previous |
- Algebraic Function Fields »

# Function Fields

AUTHORS:

- William Stein (2010): initial version
- Robert Bradshaw (2010-05-30): added is_finite()
- Julian Rueth (2011-06-08, 2011-09-14, 2014-06-23): fixed hom(), extension(); use @cached_method; added derivation()
- Maarten Derickx (2011-09-11): added doctests
- Syed Ahmad Lavasani (2011-12-16): added genus(), is_RationalFunctionField()

EXAMPLES:

We create an extension of a rational function fields, and do some simple arithmetic in it:

    sage: K.<x> = FunctionField(GF(5^2,'a')); K
    Rational function field in x over Finite Field in a of size 5^2
    sage: R.<y> = K[]
    sage: L.<y> = K.extension(y^3 - (x^3 + 2*x*y + 1/x)); L
    Function field in y defined by y^3 + 3*x*y + (4*x^4 + 4)/x
    sage: y^2
    y^2
    sage: y^3
    2*x*y + (x^4 + 1)/x
    sage: a = 1/y; a
    (4*x/(4*x^4 + 4))*y^2 + 2*x^2/(4*x^4 + 4)
    sage: a * y
    1

We next make an extension of the above function field, illustrating that arithmetic with a tower of 3 fields is fully supported:

    sage: S.<t> = L[]
    sage: M.<t> = L.extension(t^2 - x*y)
    sage: M
    Function field in t defined by t^2 + 4*x*y
    sage: t^2
    x*y
    sage: 1/t
    ((1/(x^4 + 1))*y^2 + 2*x/(4*x^4 + 4))*t
    sage: M.base_field()
    Function field in y defined by y^3 + 3*x*y + (4*x^4 + 4)/x
    sage: M.base_field().base_field()
    Rational function field in x over Finite Field in a of size 5^2

TESTS:

    sage: TestSuite(K).run()
    sage: TestSuite(L).run()  # long time (8s on sage.math, 2012)
    sage: TestSuite(M).run()  # long time (52s on sage.math, 2012)

The following two test suites do not pass `_test_elements` yet since `R.an_element()` has a `_test_category` method wich it should not have. It is not the fault of the function field code so this will be fixed in another ticket:

    sage: TestSuite(R).run(skip = '_test_elements')
    sage: TestSuite(S).run(skip = '_test_elements')

class `sage.rings.function_field.function_field.``FunctionField`

  Bases: `sage.rings.ring.Field`

  The abstract base class for all function fields.

  EXAMPLES:

      sage: K.<x> = FunctionField(QQ)
      sage: isinstance(K, sage.rings.function_field.function_field.FunctionField)
      True

  `characteristic`()

    Return the characteristic of this function field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ)
        sage: K.characteristic()
        0
        sage: K.<x> = FunctionField(GF(7))
        sage: K.characteristic()
        7
        sage: R.<y> = K[]
        sage: L.<y> = K.extension(y^2-x)
        sage: L.characteristic()
        7

  `extension`(f, names=None)

    Create an extension L = K[y]/(f(y)) of a function field, defined by a univariate polynomial in one variable over this function field K.

    INPUT:

    > - `f` – a univariate polynomial over self
    > - `names` – None or string or length-1 tuple

    OUTPUT:

    > - a function field

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: K.extension(y^5 - x^3 - 3*x + x*y)
        Function field in y defined by y^5 + x*y - x^3 - 3*x

    A nonintegral defining polynomial:

        sage: K.<t> = FunctionField(QQ); R.<y> = K[]
        sage: K.extension(y^3 + (1/t)*y + t^3/(t+1))
        Function field in y defined by y^3 + 1/t*y + t^3/(t + 1)

    The defining polynomial need not be monic or integral:

        sage: K.extension(t*y^3 + (1/t)*y + t^3/(t+1))
        Function field in y defined by t*y^3 + 1/t*y + t^3/(t + 1)

  `is_finite`()

    Return whether this function field is finite, which it is not.

    EXAMPLES:

        sage: R.<t> = FunctionField(QQ)
        sage: R.is_finite()
        False
        sage: R.<t> = FunctionField(GF(7))
        sage: R.is_finite()
        False

  `is_perfect`()

    Return whether this field is perfect, i.e., its characteristic is \(p=0\) or every element has a \(p\)-th root.

    EXAMPLES:

        sage: FunctionField(QQ, 'x').is_perfect()
        True
        sage: FunctionField(GF(2), 'x').is_perfect()
        False

  `order`(x, check=True)

    Return the order in this function field generated over the maximal order by x or the elements of x if x is a list.

    INPUT:

    > - `x` – element of self, or a list of elements of self
    > - `check` – bool (default: True); if True, check that x really generates an order

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<y> = K.extension(y^3 + x^3 + 4*x + 1)
        sage: O = L.order(y); O
        Order in Function field in y defined by y^3 + x^3 + 4*x + 1
        sage: O.basis()
        (1, y, y^2)

        sage: Z = K.order(x); Z
        Order in Rational function field in x over Rational Field
        sage: Z.basis()
        (1,)

    Orders with multiple generators, not yet supported:

        sage: Z = K.order([x,x^2]); Z
        Traceback (most recent call last):
        ...
        NotImplementedError

  `order_with_basis`(basis, check=True)

    Return the order with given basis over the maximal order of the base field.

    INPUT:

    > - `basis` – a list of elements of self
    > - `check` – bool (default: True); if True, check that the basis is really linearly independent and that the module it spans is closed under multiplication, and contains the identity element.

    OUTPUT:

    > - an order in this function field

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]; L.<y> = K.extension(y^3 + x^3 + 4*x + 1)
        sage: O = L.order_with_basis([1, y, y^2]); O
        Order in Function field in y defined by y^3 + x^3 + 4*x + 1
        sage: O.basis()
        (1, y, y^2)

    Note that 1 does not need to be an element of the basis, as long it is in the module spanned by it:

        sage: O = L.order_with_basis([1+y, y, y^2]); O
        Order in Function field in y defined by y^3 + x^3 + 4*x + 1
        sage: O.basis()
        (y + 1, y, y^2)

    The following error is raised when the module spanned by the basis is not closed under multiplication:

        sage: O = L.order_with_basis([1, x^2 + x*y, (2/3)*y^2]); O
        Traceback (most recent call last):
        ...
        ValueError: The module generated by basis [1, x*y + x^2, 2/3*y^2] must be closed under multiplication

    and this happens when the identity is not in the module spanned by the basis:

        sage: O = L.order_with_basis([x, x^2 + x*y, (2/3)*y^2])
        Traceback (most recent call last):
        ...
        ValueError: The identity element must be in the module spanned by basis [x, x*y + x^2, 2/3*y^2]

  `some_elements`()

    Return a list of elements in the function field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ)
        sage: elements = K.some_elements()
        sage: elements # random output
        [(x - 3/2)/(x^2 - 12/5*x + 1/18)]
        sage: False in [e in K for e in elements]
        False

class `sage.rings.function_field.function_field.``FunctionField_polymod`(polynomial, names, element_class=<type 'sage.rings.function_field.function_field_element.FunctionFieldElement_polymod'>, category=Category of function fields)

  Bases: `sage.rings.function_field.function_field.FunctionField`

  A function field defined by a univariate polynomial, as an extension of the base field.

  EXAMPLES:

  We make a function field defined by a degree 5 polynomial over the rational function field over the rational numbers:

      sage: K.<x> = FunctionField(QQ)
      sage: R.<y> = K[]
      sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
      Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x

  We next make a function field over the above nontrivial function field L:

      sage: S.<z> = L[]
      sage: M.<z> = L.extension(z^2 + y*z + y); M
      Function field in z defined by z^2 + y*z + y
      sage: 1/z
      ((x/(-x^4 - 1))*y^4 - 2*x^2/(-x^4 - 1))*z - 1
      sage: z * (1/z)
      1

  We drill down the tower of function fields:

      sage: M.base_field()
      Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
      sage: M.base_field().base_field()
      Rational function field in x over Rational Field
      sage: M.base_field().base_field().constant_field()
      Rational Field
      sage: M.constant_base_field()
      Rational Field

  Warning

  It is not checked if the polynomial used to define this function field is irreducible Hence it is not guaranteed that this object really is a field! This is illustrated below.

      sage: K.<x>=FunctionField(QQ)
      sage: R.<y> = K[]
      sage: L.<y>=K.extension(x^2-y^2)
      sage: (y-x)*(y+x)
      0
      sage: 1/(y-x)
      1
      sage: y-x==0; y+x==0
      False
      False

  `base_field`()

    Return the base field of this function field. This function field is presented as L = K[y]/(f(y)), and the base field is by definition the field K.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.base_field()
        Rational function field in x over Rational Field

  `constant_base_field`()

    Return the constant field of the base rational function field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
        Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
        sage: L.constant_base_field()
        Rational Field
        sage: S.<z> = L[]
        sage: M.<z> = L.extension(z^2 - y)
        sage: M.constant_base_field()
        Rational Field

  `constant_field`()

    Return the algebraic closure of the constant field of the base field in this function field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.constant_field()
        Traceback (most recent call last):
        ...
        NotImplementedError

  `degree`()

    Return the degree of this function field over its base function field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ)
        sage: R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
        Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
        sage: L.degree()
        5

  `equation_order`()

    If we view self as being presented as K[y]/(f(y)), then this function returns the order generated by the class of y. If f is not monic, then `_make_monic_integral()` is called, and instead we get the order generated by some integral multiple of a root of f.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: O = L.equation_order()
        sage: O.basis()
        (1, x*y, x^2*y^2, x^3*y^3, x^4*y^4)

    We try an example, in which the defining polynomial is not monic and is not integral:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(x^2*y^5 - 1/x); L
        Function field in y defined by x^2*y^5 - 1/x
        sage: O = L.equation_order()
        sage: O.basis()
        (1, x^3*y, x^6*y^2, x^9*y^3, x^12*y^4)

  `gen`(n=0)

    Return the `n`-th generator of this function field. By default `n` is 0; any other value of `n` leads to an error. The generator is the class of y, if we view self as being presented as K[y]/(f(y)).

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.gen()
        y
        sage: L.gen(1)
        Traceback (most recent call last):
        ...
        IndexError: Only one generator.

  `genus`()

    Return the genus of this function field For now, the genus is computed using singular

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^3 - (x^3 + 2*x*y + 1/x))
        sage: L.genus()
        3

  `hom`(im_gens, base_morphism=None)

    Create a homomorphism from self to another function field.

    INPUT:

    > - `im_gens` – a list of images of the generators of self and of successive base rings.
    > - `base_morphism` – (default: None) a homomorphism of the base ring, after the im_gens are used. Thus if im_gens has length 2, then base_morphism should be a morphism from self.base_ring().base_ring().

    EXAMPLES:

    We create a rational function field, and a quadratic extension of it:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^2 - x^3 - 1)

    We make the field automorphism that sends y to -y:

        sage: f = L.hom(-y); f
        Function Field endomorphism of Function field in y defined by y^2 - x^3 - 1
          Defn: y |--> -y

    Evaluation works:

        sage: f(y*x - 1/x)
        -x*y - 1/x

    We try to define an invalid morphism:

        sage: f = L.hom(y+1)
        Traceback (most recent call last):
        ...
        ValueError: invalid morphism

    We make a morphism of the base rational function field:

        sage: phi = K.hom(x+1); phi
        Function Field endomorphism of Rational function field in x over Rational Field
          Defn: x |--> x + 1
        sage: phi(x^3 - 3)
        x^3 + 3*x^2 + 3*x - 2
        sage: (x+1)^3-3
        x^3 + 3*x^2 + 3*x - 2

    We make a morphism by specifying where the generators and the base generators go:

        sage: L.hom([-y, x])
        Function Field endomorphism of Function field in y defined by y^2 - x^3 - 1
          Defn: y |--> -y
                x |--> x

    The usage of the keyword base_morphism is not implemented yet:

        sage: L.hom([-y, x-1], base_morphism=phi)
        Traceback (most recent call last):
        ...
        NotImplementedError: Function field homorphisms with optional argument base_morphism are not implemented yet. Please specify the images of the generators of the base fields manually.

    We make another extension of a rational function field:

        sage: K2.<t> = FunctionField(QQ); R2.<w> = K2[]
        sage: L2.<w> = K2.extension((4*w)^2 - (t+1)^3 - 1)

    We define a morphism, by giving the images of generators:

        sage: f = L.hom([4*w, t+1]); f
        Function Field morphism:
          From: Function field in y defined by y^2 - x^3 - 1
          To:   Function field in w defined by 16*w^2 - t^3 - 3*t^2 - 3*t - 2
          Defn: y |--> 4*w
                x |--> t + 1

    Evaluation works, as expected:

        sage: f(y+x)
        4*w + t + 1
        sage: f(x*y + x/(x^2+1))
        (4*t + 4)*w + (t + 1)/(t^2 + 2*t + 2)

    We make another extension of a rational function field:

        sage: K3.<yy> = FunctionField(QQ); R3.<xx> = K3[]
        sage: L3.<xx> = K3.extension(yy^2 - xx^3 - 1)

    This is the function field L with the generators exchanged. We define a morphism to L:

        sage: g = L3.hom([x,y]); g
        Function Field morphism:
          From: Function field in xx defined by -xx^3 + yy^2 - 1
          To:   Function field in y defined by y^2 - x^3 - 1
          Defn: xx |--> x
                yy |--> y

  `maximal_order`()

    Return the maximal_order of self. If we view self as L = K[y]/(f(y)), then this is the ring of elements of L that are integral over K.

    EXAMPLES:

    This is not yet implemented...:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.maximal_order()
        Traceback (most recent call last):
        ...
        NotImplementedError

  `monic_integral_model`(names)

    Return a function field isomorphic to self, but with defining polynomial that is monic and integral over the base field.

    INPUT:

    > - `names` – name of the generator of the new field this function constructs

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(x^2*y^5 - 1/x); L
        Function field in y defined by x^2*y^5 - 1/x
        sage: A, from_A, to_A = L.monic_integral_model('z')
        sage: A
        Function field in z defined by y^5 - x^12
        sage: from_A
        Function Field morphism:
          From: Function field in z defined by y^5 - x^12
          To:   Function field in y defined by x^2*y^5 - 1/x
          Defn: z |--> x^3*y
        sage: to_A
        Function Field morphism:
          From: Function field in y defined by x^2*y^5 - 1/x
          To:   Function field in z defined by y^5 - x^12
          Defn: y |--> 1/x^3*z
        sage: to_A(y)
        1/x^3*z
        sage: from_A(to_A(y))
        y
        sage: from_A(to_A(1/y))
        x^3*y^4
        sage: from_A(to_A(1/y)) == 1/y
        True

  `ngens`()

    Return the number of generators of this function field over its base field. This is by definition 1.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.ngens()
        1

  `polynomial`()

    Return the univariate polynomial that defines this function field, i.e., the polynomial f(y) so that this function field is of the form K[y]/(f(y)).

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.polynomial()
        y^5 - 2*x*y + (-x^4 - 1)/x

  `polynomial_ring`()

    Return the polynomial ring used to represent elements of this function field. If we view this function field as being presented as K[y]/(f(y)), then this function returns the ring K[y].

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x))
        sage: L.polynomial_ring()
        Univariate Polynomial Ring in y over Rational function field in x over Rational Field

  `random_element`(*args, **kwds)

    Create a random element of this function field. Parameters are passed onto the random_element method of the base_field.

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^2 - (x^2 + x))
        sage: L.random_element() # random
        ((x^2 - x + 2/3)/(x^2 + 1/3*x - 1))*y^2 + ((-1/4*x^2 + 1/2*x - 1)/(-5/2*x + 2/3))*y + (-1/2*x^2 - 4)/(-12*x^2 + 1/2*x - 1/95)

  `vector_space`()

    Return a vector space V and isomorphisms self –> V and V –> self.

    This function allows us to identify the elements of self with elements of a vector space over the base field, which is useful for representation and arithmetic with orders, ideals, etc.

    OUTPUT:

    > - `V` – a vector space over base field
    > - `from_V` – an isomorphism from V to self
    > - `to_V` – an isomorphism from self to V

    EXAMPLES:

    We define a function field:

        sage: K.<x> = FunctionField(QQ); R.<y> = K[]
        sage: L.<y> = K.extension(y^5 - (x^3 + 2*x*y + 1/x)); L
        Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x

    We get the vector spaces, and maps back and forth:

        sage: V, from_V, to_V = L.vector_space()
        sage: V
        Vector space of dimension 5 over Rational function field in x over Rational Field
        sage: from_V
        Isomorphism morphism:
          From: Vector space of dimension 5 over Rational function field in x over Rational Field
          To:   Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
        sage: to_V
        Isomorphism morphism:
          From: Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
          To:   Vector space of dimension 5 over Rational function field in x over Rational Field

    We convert an element of the vector space back to the function field:

        sage: from_V(V.1)
        y

    We define an interesting element of the function field:

        sage: a = 1/L.0; a
        (-x/(-x^4 - 1))*y^4 + 2*x^2/(-x^4 - 1)

    We convert it to the vector space, and get a vector over the base field:

        sage: to_V(a)
        (2*x^2/(-x^4 - 1), 0, 0, 0, -x/(-x^4 - 1))

    We convert to and back, and get the same element:

        sage: from_V(to_V(a)) == a
        True

    In the other direction:

        sage: v = x*V.0 + (1/x)*V.1
        sage: to_V(from_V(v)) == v
        True

    And we show how it works over an extension of an extension field:

        sage: R2.<z> = L[]; M.<z> = L.extension(z^2 -y)
        sage: M.vector_space()
        (Vector space of dimension 2 over Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x, Isomorphism morphism:
          From: Vector space of dimension 2 over Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x
          To:   Function field in z defined by z^2 - y, Isomorphism morphism:
          From: Function field in z defined by z^2 - y
          To:   Vector space of dimension 2 over Function field in y defined by y^5 - 2*x*y + (-x^4 - 1)/x)

class `sage.rings.function_field.function_field.``RationalFunctionField`(constant_field, names, element_class=<type 'sage.rings.function_field.function_field_element.FunctionFieldElement_rational'>, category=Category of function fields)

  Bases: `sage.rings.function_field.function_field.FunctionField`

  A rational function field K(t) in one variable, over an arbitrary base field.

  EXAMPLES:

      sage: K.<t> = FunctionField(GF(3)); K
      Rational function field in t over Finite Field of size 3
      sage: K.gen()
      t
      sage: 1/t + t^3 + 5
      (t^4 + 2*t + 1)/t

  There are various ways to get at the underlying fields and rings associated to a rational function field:

      sage: K.<t> = FunctionField(GF(7))
      sage: K.base_field()
      Rational function field in t over Finite Field of size 7
      sage: K.field()
      Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7
      sage: K.constant_field()
      Finite Field of size 7
      sage: K.maximal_order()
      Maximal order in Rational function field in t over Finite Field of size 7

  We define a morphism:

      sage: K.<t> = FunctionField(QQ)
      sage: L = FunctionField(QQ, 'tbar') # give variable name as second input
      sage: K.hom(L.gen())
      Function Field morphism:
        From: Rational function field in t over Rational Field
        To:   Rational function field in tbar over Rational Field
        Defn: t |--> tbar

  `base_field`()

    Return the base field of this rational function field, which is just this function field itself.

    EXAMPLES:

        sage: K.<t> = FunctionField(GF(7))
        sage: K.base_field()
        Rational function field in t over Finite Field of size 7

  `constant_base_field`()

    Return the field that this rational function field is a transcendental extension of.

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.constant_field()
        Rational Field

  `constant_field`()

    Return the field that this rational function field is a transcendental extension of.

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.constant_field()
        Rational Field

  `degree`()

    Return the degree over the base field of this rational function field. Since the base field is the rational function field itself, the degree is 1.

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.degree()
        1

  `derivation`()

    Return a generator of the space of derivations over the constant base field of this function field.

    A derivation on \(R\) is a map \(R \to R\) with \(D(\alpha + \beta) = D(\alpha) + D(\beta)\) and \(D(\alpha \beta) = \beta D(\alpha)+\alpha D(\beta)\) for all \(\alpha, \beta \in R\). For a function field \(K(x)\) with \(K\) perfect, the derivations form a one-dimensional \(K\)-vector space generated by the extension of the usual derivation on \(K[x]\) (cf. Proposition 10 in [GT1996].)

    OUTPUT:

    An endofunction on this function field.

    REFERENCES:

    [GT1996] | Gianni, P., & Trager, B. (1996). Square-free algorithms in positive characteristic. Applicable Algebra in Engineering, Communication and Computing, 7(1), 1-14.

    EXAMPLES:

        sage: K.<x> = FunctionField(GF(3))
        sage: K.derivation()
        Derivation map:
          From: Rational function field in x over Finite Field of size 3
          To:   Rational function field in x over Finite Field of size 3

    TESTS:

        sage: L.<y> = FunctionField(K)
        sage: L.derivation()
        Traceback (most recent call last):
        ...
        NotImplementedError: not implemented for non-perfect base fields

  `equation_order`()

    Return the maximal order of this function field. Since this is a rational function field it is of the form K(t), and the maximal order is by definition K[t].

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.maximal_order()
        Maximal order in Rational function field in t over Rational Field
        sage: K.equation_order()
        Maximal order in Rational function field in t over Rational Field

  `field`()

    Return the underlying field, forgetting the function field structure.

    EXAMPLES:

        sage: K.<t> = FunctionField(GF(7))
        sage: K.field()
        Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7

  `gen`(n=0)

    Return the `n`-th generator of this function field. If `n` is not 0, then an IndexError is raised.

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ); K.gen()
        t
        sage: K.gen().parent()
        Rational function field in t over Rational Field
        sage: K.gen(1)
        Traceback (most recent call last):
        ...
        IndexError: Only one generator.

  `genus`()

    Return the genus of this function field This is always equal 0 for a rational function field

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ);
        sage: K.genus()
        0

  `hom`(im_gens, base_morphism=None)

    Create a homomorphism from self to another function field.

    INPUT:

    > - `im_gens` – exactly one element of some function field
    > - `base_morphism` – ignored

    OUTPUT:

    > - a map between function fields

    EXAMPLES:

    We make a map from a rational function field to itself:

        sage: K.<x> = FunctionField(GF(7))
        sage: K.hom( (x^4 + 2)/x)
        Function Field endomorphism of Rational function field in x over Finite Field of size 7
          Defn: x |--> (x^4 + 2)/x

    We construct a map from a rational function field into a non-rational extension field:

        sage: K.<x> = FunctionField(GF(7)); R.<y> = K[]
        sage: L.<y> = K.extension(y^3 + 6*x^3 + x)
        sage: f = K.hom(y^2 + y  + 2); f
        Function Field morphism:
          From: Rational function field in x over Finite Field of size 7
          To:   Function field in y defined by y^3 + 6*x^3 + x
          Defn: x |--> y^2 + y + 2
        sage: f(x)
        y^2 + y + 2
        sage: f(x^2)
        5*y^2 + (x^3 + 6*x + 4)*y + 2*x^3 + 5*x + 4

  `maximal_order`()

    Return the maximal order of this function field. Since this is a rational function field it is of the form K(t), and the maximal order is by definition K[t].

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.maximal_order()
        Maximal order in Rational function field in t over Rational Field
        sage: K.equation_order()
        Maximal order in Rational function field in t over Rational Field

  `ngens`()

    Return the number of generators, which is 1.

    EXAMPLES:

        sage: K.<t> = FunctionField(QQ)
        sage: K.ngens()
        1

  `polynomial_ring`(var='x')

    Return a polynomial ring in one variable over this rational function field.

    INPUT:

    > - `var` – a string (default: ‘x’)

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ)
        sage: K.polynomial_ring()
        Univariate Polynomial Ring in x over Rational function field in x over Rational Field
        sage: K.polynomial_ring('T')
        Univariate Polynomial Ring in T over Rational function field in x over Rational Field

  `random_element`(*args, **kwds)

    Create a random element of this rational function field.

    Parameters are passed to the random_element method of the underlying fraction field.

    EXAMPLES:

        sage: FunctionField(QQ,'alpha').random_element()   # random
        (-1/2*alpha^2 - 4)/(-12*alpha^2 + 1/2*alpha - 1/95)

  `vector_space`()

    Return a vector space V and isomorphisms self –> V and V –> self.

    OUTPUT:

    > - `V` – a vector space over the rational numbers
    > - `from_V` – an isomorphism from V to self
    > - `to_V` – an isomorphism from self to V

    EXAMPLES:

        sage: K.<x> = FunctionField(QQ)
        sage: K.vector_space()
        (Vector space of dimension 1 over Rational function field in x over Rational Field, Isomorphism morphism:
          From: Vector space of dimension 1 over Rational function field in x over Rational Field
          To:   Rational function field in x over Rational Field, Isomorphism morphism:
          From: Rational function field in x over Rational Field
          To:   Vector space of dimension 1 over Rational function field in x over Rational Field)

`sage.rings.function_field.function_field.``is_FunctionField`(x)

  Return True if `x` is of function field type.

  EXAMPLES:

      sage: from sage.rings.function_field.function_field import is_FunctionField
      sage: is_FunctionField(QQ)
      False
      sage: is_FunctionField(FunctionField(QQ,'t'))
      True

`sage.rings.function_field.function_field.``is_RationalFunctionField`(x)

  Return True if `x` is of rational function field type.

  EXAMPLES:

      sage: from sage.rings.function_field.function_field import is_RationalFunctionField
      sage: is_RationalFunctionField(QQ)
      False
      sage: is_RationalFunctionField(FunctionField(QQ,'t'))
      True

### Navigation

- index
- modules |
- next |
- previous |
- Algebraic Function Fields »