Function Fields: rational

class sage.rings.function_field.function_field_rational.RationalFunctionField(constant_field, names, category=None)[source]

Bases: FunctionField

Rational function field in one variable, over an arbitrary base field.

INPUT:

  • constant_field – arbitrary field

  • names – string or tuple of length 1

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

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

>>> from sage.all import *
>>> K = FunctionField(GF(Integer(3)), names=('t',)); (t,) = K._first_ngens(1); K
Rational function field in t over Finite Field of size 3
>>> K.gen()
t
>>> Integer(1)/t + t**Integer(3) + Integer(5)
(t^4 + 2*t + 1)/t

>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1); K
Rational function field in t over Rational Field
>>> K.gen()
t
>>> Integer(1)/t + t**Integer(3) + Integer(5)
(t^4 + 5*t + 1)/t

K.<t> = FunctionField(GF(3)); K
K.gen()
1/t + t^3 + 5
K.<t> = FunctionField(QQ); K
K.gen()
1/t + t^3 + 5

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 of Rational function field in t over Finite Field of size 7

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

>>> from sage.all import *
>>> K = FunctionField(GF(Integer(7)), names=('t',)); (t,) = K._first_ngens(1)
>>> K.base_field()
Rational function field in t over Finite Field of size 7
>>> K.field()
Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7
>>> K.constant_field()
Finite Field of size 7
>>> K.maximal_order()
Maximal order of Rational function field in t over Finite Field of size 7

>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.base_field()
Rational function field in t over Rational Field
>>> K.field()
Fraction Field of Univariate Polynomial Ring in t over Rational Field
>>> K.constant_field()
Rational Field
>>> K.maximal_order()
Maximal order of Rational function field in t over Rational Field

K.<t> = FunctionField(GF(7))
K.base_field()
K.field()
K.constant_field()
K.maximal_order()
K.<t> = FunctionField(QQ)
K.base_field()
K.field()
K.constant_field()
K.maximal_order()

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> L = FunctionField(QQ, 'tbar') # give variable name as second input
>>> 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

K.<t> = FunctionField(QQ)
L = FunctionField(QQ, 'tbar') # give variable name as second input
K.hom(L.gen())

Here are some calculations over a number field:

sage: R.<x> = FunctionField(QQ)
sage: L.<y> = R[]
sage: F.<y> = R.extension(y^2 - (x^2+1))                                        # needs sage.rings.function_field
sage: (y/x).divisor()                                                           # needs sage.rings.function_field
- Place (x, y - 1)
 - Place (x, y + 1)
 + Place (x^2 + 1, y)

sage: # needs sage.rings.number_field
sage: A.<z> = QQ[]
sage: NF.<i> = NumberField(z^2 + 1)
sage: R.<x> = FunctionField(NF)
sage: L.<y> = R[]
sage: F.<y> = R.extension(y^2 - (x^2+1))                                        # needs sage.rings.function_field
sage: (x/y*x.differential()).divisor()                                          # needs sage.rings.function_field
-2*Place (1/x, 1/x*y - 1)
 - 2*Place (1/x, 1/x*y + 1)
 + Place (x, y - 1)
 + Place (x, y + 1)
sage: (x/y).divisor()                                                           # needs sage.rings.function_field
- Place (x - i, y)
 + Place (x, y - 1)
 + Place (x, y + 1)
 - Place (x + i, y)

>>> from sage.all import *
>>> R = FunctionField(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> L = R['y']; (y,) = L._first_ngens(1)
>>> F = R.extension(y**Integer(2) - (x**Integer(2)+Integer(1)), names=('y',)); (y,) = F._first_ngens(1)# needs sage.rings.function_field
>>> (y/x).divisor()                                                           # needs sage.rings.function_field
- Place (x, y - 1)
 - Place (x, y + 1)
 + Place (x^2 + 1, y)

>>> # needs sage.rings.number_field
>>> A = QQ['z']; (z,) = A._first_ngens(1)
>>> NF = NumberField(z**Integer(2) + Integer(1), names=('i',)); (i,) = NF._first_ngens(1)
>>> R = FunctionField(NF, names=('x',)); (x,) = R._first_ngens(1)
>>> L = R['y']; (y,) = L._first_ngens(1)
>>> F = R.extension(y**Integer(2) - (x**Integer(2)+Integer(1)), names=('y',)); (y,) = F._first_ngens(1)# needs sage.rings.function_field
>>> (x/y*x.differential()).divisor()                                          # needs sage.rings.function_field
-2*Place (1/x, 1/x*y - 1)
 - 2*Place (1/x, 1/x*y + 1)
 + Place (x, y - 1)
 + Place (x, y + 1)
>>> (x/y).divisor()                                                           # needs sage.rings.function_field
- Place (x - i, y)
 + Place (x, y - 1)
 + Place (x, y + 1)
 - Place (x + i, y)

R.<x> = FunctionField(QQ)
L.<y> = R[]
F.<y> = R.extension(y^2 - (x^2+1))                                        # needs sage.rings.function_field
(y/x).divisor()                                                           # needs sage.rings.function_field
# needs sage.rings.number_field
A.<z> = QQ[]
NF.<i> = NumberField(z^2 + 1)
R.<x> = FunctionField(NF)
L.<y> = R[]
F.<y> = R.extension(y^2 - (x^2+1))                                        # needs sage.rings.function_field
(x/y*x.differential()).divisor()                                          # needs sage.rings.function_field
(x/y).divisor()                                                           # needs sage.rings.function_field
Element[source]

alias of FunctionFieldElement_rational

base_field()[source]

Return the base field of the rational function field, which is just the 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

>>> from sage.all import *
>>> K = FunctionField(GF(Integer(7)), names=('t',)); (t,) = K._first_ngens(1)
>>> K.base_field()
Rational function field in t over Finite Field of size 7

K.<t> = FunctionField(GF(7))
K.base_field()
change_variable_name(name)[source]

Return a field isomorphic to this field with variable name.

INPUT:

  • name – string or tuple consisting of a single string; the name of the new variable

OUTPUT:

A triple F,f,t where F is a rational function field, f is an isomorphism from F to this field, and t is the inverse of f.

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: L,f,t = K.change_variable_name('y')
sage: L,f,t
(Rational function field in y over Rational Field,
 Function Field morphism:
  From: Rational function field in y over Rational Field
  To:   Rational function field in x over Rational Field
  Defn: y |--> x,
 Function Field morphism:
  From: Rational function field in x over Rational Field
  To:   Rational function field in y over Rational Field
  Defn: x |--> y)
sage: L.change_variable_name('x')[0] is K
True

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('x',)); (x,) = K._first_ngens(1)
>>> L,f,t = K.change_variable_name('y')
>>> L,f,t
(Rational function field in y over Rational Field,
 Function Field morphism:
  From: Rational function field in y over Rational Field
  To:   Rational function field in x over Rational Field
  Defn: y |--> x,
 Function Field morphism:
  From: Rational function field in x over Rational Field
  To:   Rational function field in y over Rational Field
  Defn: x |--> y)
>>> L.change_variable_name('x')[Integer(0)] is K
True

K.<x> = FunctionField(QQ)
L,f,t = K.change_variable_name('y')
L,f,t
L.change_variable_name('x')[0] is K
constant_base_field()[source]

Return the field of which the rational function field is a transcendental extension.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.constant_base_field()
Rational Field

K.<t> = FunctionField(QQ)
K.constant_base_field()
constant_field()[source]

Return the field of which the rational function field is a transcendental extension.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.constant_base_field()
Rational Field

K.<t> = FunctionField(QQ)
K.constant_base_field()
degree(base=None)[source]

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

INPUT:

  • base – the base field of the vector space; must be the function field itself (the default)

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.degree()
1

K.<t> = FunctionField(QQ)
K.degree()
different()[source]

Return the different of the rational function field.

For a rational function field, the different is simply the zero divisor.

EXAMPLES:

sage: K.<t> = FunctionField(QQ)
sage: K.different()                                                         # needs sage.modules
0

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.different()                                                         # needs sage.modules
0

K.<t> = FunctionField(QQ)
K.different()                                                         # needs sage.modules
equation_order()[source]

Return the maximal order of the 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]\), where \(K\) is the constant field.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.maximal_order()
Maximal order of Rational function field in t over Rational Field
>>> K.equation_order()
Maximal order of Rational function field in t over Rational Field

K.<t> = FunctionField(QQ)
K.maximal_order()
K.equation_order()
equation_order_infinite()[source]

Return the maximal infinite order of the function field.

By definition, this is the valuation ring of the degree valuation of the rational function field.

EXAMPLES:

sage: K.<t> = FunctionField(QQ)
sage: K.maximal_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field
sage: K.equation_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.maximal_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field
>>> K.equation_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field

K.<t> = FunctionField(QQ)
K.maximal_order_infinite()
K.equation_order_infinite()
extension(f, names=None)[source]

Create an extension \(L = K[y]/(f(y))\) of the rational function field.

INPUT:

  • f – univariate polynomial over self

  • names – 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)                                    # needs sage.rings.function_field
Function field in y defined by y^5 + x*y - x^3 - 3*x

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('x',)); (x,) = K._first_ngens(1); R = K['y']; (y,) = R._first_ngens(1)
>>> K.extension(y**Integer(5) - x**Integer(3) - Integer(3)*x + x*y)                                    # needs sage.rings.function_field
Function field in y defined by y^5 + x*y - x^3 - 3*x

K.<x> = FunctionField(QQ); R.<y> = K[]
K.extension(y^5 - x^3 - 3*x + x*y)                                    # needs sage.rings.function_field

A nonintegral defining polynomial:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1); R = K['y']; (y,) = R._first_ngens(1)
>>> K.extension(y**Integer(3) + (Integer(1)/t)*y + t**Integer(3)/(t+Integer(1)))                                # needs sage.rings.function_field
Function field in y defined by y^3 + 1/t*y + t^3/(t + 1)

K.<t> = FunctionField(QQ); R.<y> = K[]
K.extension(y^3 + (1/t)*y + t^3/(t+1))                                # needs sage.rings.function_field

The defining polynomial need not be monic or integral:

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

>>> from sage.all import *
>>> K.extension(t*y**Integer(3) + (Integer(1)/t)*y + t**Integer(3)/(t+Integer(1)))                              # needs sage.rings.function_field
Function field in y defined by t*y^3 + 1/t*y + t^3/(t + 1)

K.extension(t*y^3 + (1/t)*y + t^3/(t+1))                              # needs sage.rings.function_field
field()[source]

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

>>> from sage.all import *
>>> K = FunctionField(GF(Integer(7)), names=('t',)); (t,) = K._first_ngens(1)
>>> K.field()
Fraction Field of Univariate Polynomial Ring in t over Finite Field of size 7

K.<t> = FunctionField(GF(7))
K.field()

See also

sage.rings.fraction_field.FractionField_1poly_field.function_field()

free_module(base=None, basis=None, map=True)[source]

Return a vector space \(V\) and isomorphisms from the field to \(V\) and from \(V\) to the field.

This function allows us to identify the elements of this field with elements of a one-dimensional vector space over the field itself. This method exists so that all function fields (rational or not) have the same interface.

INPUT:

  • base – the base field of the vector space; must be the function field itself (the default)

  • basis – (ignored) a basis for the vector space

  • map – (default: True) whether to return maps to and from the vector space

OUTPUT:

  • a vector space \(V\) over base field

  • an isomorphism from \(V\) to the field

  • the inverse isomorphism from the field to \(V\)

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: K.free_module()                                                                                       # needs sage.modules
(Vector space of dimension 1 over Rational function field in x over Rational Field,
 Isomorphism:
  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:
  From: Rational function field in x over Rational Field
  To:   Vector space of dimension 1 over Rational function field in x over Rational Field)

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('x',)); (x,) = K._first_ngens(1)
>>> K.free_module()                                                                                       # needs sage.modules
(Vector space of dimension 1 over Rational function field in x over Rational Field,
 Isomorphism:
  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:
  From: Rational function field in x over Rational Field
  To:   Vector space of dimension 1 over Rational function field in x over Rational Field)

K.<x> = FunctionField(QQ)
K.free_module()                                                                                       # needs sage.modules
gen(n=0)[source]

Return the n-th generator of the function field. If n is not 0, then an :class:` 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.

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1); K.gen()
t
>>> K.gen().parent()
Rational function field in t over Rational Field
>>> K.gen(Integer(1))
Traceback (most recent call last):
...
IndexError: Only one generator.

K.<t> = FunctionField(QQ); K.gen()
K.gen().parent()
K.gen(1)
genus()[source]

Return the genus of the function field, namely 0.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('x',)); (x,) = K._first_ngens(1)
>>> K.genus()
0

K.<x> = FunctionField(QQ)
K.genus()
hom(im_gens, base_morphism=None)[source]

Create a homomorphism from self to another ring.

INPUT:

  • im_gens – exactly one element of some ring. It must be invertible and transcendental over the image of base_morphism; this is not checked.

  • base_morphism – a homomorphism from the base field into the other ring; if None, try to use a coercion map

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

>>> from sage.all import *
>>> K = FunctionField(GF(Integer(7)), names=('x',)); (x,) = K._first_ngens(1)
>>> K.hom((x**Integer(4) + Integer(2))/x)
Function Field endomorphism of Rational function field in x over Finite Field of size 7
  Defn: x |--> (x^4 + 2)/x

K.<x> = FunctionField(GF(7))
K.hom((x^4 + 2)/x)

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

sage: # needs sage.rings.function_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

>>> from sage.all import *
>>> # needs sage.rings.function_field
>>> K = FunctionField(GF(Integer(7)), names=('x',)); (x,) = K._first_ngens(1); R = K['y']; (y,) = R._first_ngens(1)
>>> L = K.extension(y**Integer(3) + Integer(6)*x**Integer(3) + x, names=('y',)); (y,) = L._first_ngens(1)
>>> f = K.hom(y**Integer(2) + y  + Integer(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
>>> f(x)
y^2 + y + 2
>>> f(x**Integer(2))
5*y^2 + (x^3 + 6*x + 4)*y + 2*x^3 + 5*x + 4

# needs sage.rings.function_field
K.<x> = FunctionField(GF(7)); R.<y> = K[]
L.<y> = K.extension(y^3 + 6*x^3 + x)
f = K.hom(y^2 + y  + 2); f
f(x)
f(x^2)
maximal_order()[source]

Return the maximal order of the 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]\), where \(K\) is the constant field.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.maximal_order()
Maximal order of Rational function field in t over Rational Field
>>> K.equation_order()
Maximal order of Rational function field in t over Rational Field

K.<t> = FunctionField(QQ)
K.maximal_order()
K.equation_order()
maximal_order_infinite()[source]

Return the maximal infinite order of the function field.

By definition, this is the valuation ring of the degree valuation of the rational function field.

EXAMPLES:

sage: K.<t> = FunctionField(QQ)
sage: K.maximal_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field
sage: K.equation_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.maximal_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field
>>> K.equation_order_infinite()
Maximal infinite order of Rational function field in t over Rational Field

K.<t> = FunctionField(QQ)
K.maximal_order_infinite()
K.equation_order_infinite()
ngens()[source]

Return the number of generators, which is 1.

EXAMPLES:

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('t',)); (t,) = K._first_ngens(1)
>>> K.ngens()
1

K.<t> = FunctionField(QQ)
K.ngens()
polynomial_ring(var='x')[source]

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

INPUT:

  • var – string; name of the variable

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

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('x',)); (x,) = K._first_ngens(1)
>>> K.polynomial_ring()
Univariate Polynomial Ring in x over Rational function field in x over Rational Field
>>> K.polynomial_ring('T')
Univariate Polynomial Ring in T over Rational function field in x over Rational Field

K.<x> = FunctionField(QQ)
K.polynomial_ring()
K.polynomial_ring('T')
random_element(*args, **kwds)[source]

Create a random element of the 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)

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

FunctionField(QQ,'alpha').random_element()   # random
residue_field(place, name=None)[source]

Return the residue field of the place along with the maps from and to it.

INPUT:

  • place – place of the function field

  • name – string; name of the generator of the residue field

EXAMPLES:

sage: F.<x> = FunctionField(GF(5))
sage: p = F.places_finite(2)[0]                                             # needs sage.libs.pari
sage: R, fr_R, to_R = F.residue_field(p)                                    # needs sage.libs.pari sage.rings.function_field
sage: R                                                                     # needs sage.libs.pari sage.rings.function_field
Finite Field in z2 of size 5^2
sage: to_R(x) in R                                                          # needs sage.libs.pari sage.rings.function_field
True

>>> from sage.all import *
>>> F = FunctionField(GF(Integer(5)), names=('x',)); (x,) = F._first_ngens(1)
>>> p = F.places_finite(Integer(2))[Integer(0)]                                             # needs sage.libs.pari
>>> R, fr_R, to_R = F.residue_field(p)                                    # needs sage.libs.pari sage.rings.function_field
>>> R                                                                     # needs sage.libs.pari sage.rings.function_field
Finite Field in z2 of size 5^2
>>> to_R(x) in R                                                          # needs sage.libs.pari sage.rings.function_field
True

F.<x> = FunctionField(GF(5))
p = F.places_finite(2)[0]                                             # needs sage.libs.pari
R, fr_R, to_R = F.residue_field(p)                                    # needs sage.libs.pari sage.rings.function_field
R                                                                     # needs sage.libs.pari sage.rings.function_field
to_R(x) in R                                                          # needs sage.libs.pari sage.rings.function_field
class sage.rings.function_field.function_field_rational.RationalFunctionField_char_zero(constant_field, names, category=None)[source]

Bases: RationalFunctionField

Rational function fields of characteristic zero.

higher_derivation()[source]

Return the higher derivation for the function field.

This is also called the Hasse-Schmidt derivation.

EXAMPLES:

sage: F.<x> = FunctionField(QQ)
sage: d = F.higher_derivation()                                             # needs sage.libs.singular sage.modules
sage: [d(x^5,i) for i in range(10)]                                         # needs sage.libs.singular sage.modules
[x^5, 5*x^4, 10*x^3, 10*x^2, 5*x, 1, 0, 0, 0, 0]
sage: [d(x^9,i) for i in range(10)]                                         # needs sage.libs.singular sage.modules
[x^9, 9*x^8, 36*x^7, 84*x^6, 126*x^5, 126*x^4, 84*x^3, 36*x^2, 9*x, 1]

>>> from sage.all import *
>>> F = FunctionField(QQ, names=('x',)); (x,) = F._first_ngens(1)
>>> d = F.higher_derivation()                                             # needs sage.libs.singular sage.modules
>>> [d(x**Integer(5),i) for i in range(Integer(10))]                                         # needs sage.libs.singular sage.modules
[x^5, 5*x^4, 10*x^3, 10*x^2, 5*x, 1, 0, 0, 0, 0]
>>> [d(x**Integer(9),i) for i in range(Integer(10))]                                         # needs sage.libs.singular sage.modules
[x^9, 9*x^8, 36*x^7, 84*x^6, 126*x^5, 126*x^4, 84*x^3, 36*x^2, 9*x, 1]

F.<x> = FunctionField(QQ)
d = F.higher_derivation()                                             # needs sage.libs.singular sage.modules
[d(x^5,i) for i in range(10)]                                         # needs sage.libs.singular sage.modules
[d(x^9,i) for i in range(10)]                                         # needs sage.libs.singular sage.modules
class sage.rings.function_field.function_field_rational.RationalFunctionField_global(constant_field, names, category=None)[source]

Bases: RationalFunctionField

Rational function field over finite fields.

get_place(degree)[source]

Return a place of degree.

INPUT:

  • degree – positive integer

EXAMPLES:

sage: F.<a> = GF(2)
sage: K.<x> = FunctionField(F)
sage: K.get_place(1)                                                        # needs sage.libs.pari
Place (x)
sage: K.get_place(2)                                                        # needs sage.libs.pari
Place (x^2 + x + 1)
sage: K.get_place(3)                                                        # needs sage.libs.pari
Place (x^3 + x + 1)
sage: K.get_place(4)                                                        # needs sage.libs.pari
Place (x^4 + x + 1)
sage: K.get_place(5)                                                        # needs sage.libs.pari
Place (x^5 + x^2 + 1)

>>> from sage.all import *
>>> F = GF(Integer(2), names=('a',)); (a,) = F._first_ngens(1)
>>> K = FunctionField(F, names=('x',)); (x,) = K._first_ngens(1)
>>> K.get_place(Integer(1))                                                        # needs sage.libs.pari
Place (x)
>>> K.get_place(Integer(2))                                                        # needs sage.libs.pari
Place (x^2 + x + 1)
>>> K.get_place(Integer(3))                                                        # needs sage.libs.pari
Place (x^3 + x + 1)
>>> K.get_place(Integer(4))                                                        # needs sage.libs.pari
Place (x^4 + x + 1)
>>> K.get_place(Integer(5))                                                        # needs sage.libs.pari
Place (x^5 + x^2 + 1)

F.<a> = GF(2)
K.<x> = FunctionField(F)
K.get_place(1)                                                        # needs sage.libs.pari
K.get_place(2)                                                        # needs sage.libs.pari
K.get_place(3)                                                        # needs sage.libs.pari
K.get_place(4)                                                        # needs sage.libs.pari
K.get_place(5)                                                        # needs sage.libs.pari
higher_derivation()[source]

Return the higher derivation for the function field.

This is also called the Hasse-Schmidt derivation.

EXAMPLES:

sage: F.<x> = FunctionField(GF(5))
sage: d = F.higher_derivation()                                             # needs sage.rings.function_field
sage: [d(x^5,i) for i in range(10)]                                         # needs sage.rings.function_field
[x^5, 0, 0, 0, 0, 1, 0, 0, 0, 0]
sage: [d(x^7,i) for i in range(10)]                                         # needs sage.rings.function_field
[x^7, 2*x^6, x^5, 0, 0, x^2, 2*x, 1, 0, 0]

>>> from sage.all import *
>>> F = FunctionField(GF(Integer(5)), names=('x',)); (x,) = F._first_ngens(1)
>>> d = F.higher_derivation()                                             # needs sage.rings.function_field
>>> [d(x**Integer(5),i) for i in range(Integer(10))]                                         # needs sage.rings.function_field
[x^5, 0, 0, 0, 0, 1, 0, 0, 0, 0]
>>> [d(x**Integer(7),i) for i in range(Integer(10))]                                         # needs sage.rings.function_field
[x^7, 2*x^6, x^5, 0, 0, x^2, 2*x, 1, 0, 0]

F.<x> = FunctionField(GF(5))
d = F.higher_derivation()                                             # needs sage.rings.function_field
[d(x^5,i) for i in range(10)]                                         # needs sage.rings.function_field
[d(x^7,i) for i in range(10)]                                         # needs sage.rings.function_field
place_infinite()[source]

Return the unique place at infinity.

EXAMPLES:

sage: F.<x> = FunctionField(GF(5))
sage: F.place_infinite()
Place (1/x)

>>> from sage.all import *
>>> F = FunctionField(GF(Integer(5)), names=('x',)); (x,) = F._first_ngens(1)
>>> F.place_infinite()
Place (1/x)

F.<x> = FunctionField(GF(5))
F.place_infinite()
places(degree=1)[source]

Return all places of the degree.

INPUT:

  • degree – (default: 1) a positive integer

EXAMPLES:

sage: F.<x> = FunctionField(GF(5))
sage: F.places()                                                            # needs sage.libs.pari
[Place (1/x),
 Place (x),
 Place (x + 1),
 Place (x + 2),
 Place (x + 3),
 Place (x + 4)]

>>> from sage.all import *
>>> F = FunctionField(GF(Integer(5)), names=('x',)); (x,) = F._first_ngens(1)
>>> F.places()                                                            # needs sage.libs.pari
[Place (1/x),
 Place (x),
 Place (x + 1),
 Place (x + 2),
 Place (x + 3),
 Place (x + 4)]

F.<x> = FunctionField(GF(5))
F.places()                                                            # needs sage.libs.pari
places_finite(degree=1)[source]

Return the finite places of the degree.

INPUT:

  • degree – (default: 1) a positive integer

EXAMPLES:

sage: F.<x> = FunctionField(GF(5))
sage: F.places_finite()                                                     # needs sage.libs.pari
[Place (x), Place (x + 1), Place (x + 2), Place (x + 3), Place (x + 4)]

>>> from sage.all import *
>>> F = FunctionField(GF(Integer(5)), names=('x',)); (x,) = F._first_ngens(1)
>>> F.places_finite()                                                     # needs sage.libs.pari
[Place (x), Place (x + 1), Place (x + 2), Place (x + 3), Place (x + 4)]

F.<x> = FunctionField(GF(5))
F.places_finite()                                                     # needs sage.libs.pari