Elements#

The function field \(F = k(x, \alpha_1, \ldots, \alpha_r, \alpha)\) may be viewed as \(n\)-dimensional vector space over \(k(x, \alpha_1, \ldots, \alpha_r)\), where \(n\) is the degree of the field extension \(F/k(x, \alpha_1, \ldots, \alpha_r)\). Note that \(F\) is spanned by the powers \(1, \alpha, \dots, \alpha^{n-1}\). Within Magma, function field elements are printed as linear combinations of these powers of \(\alpha\) over the coefficient field.

An order can be viewed as a free \(R\)-module of rank \(n\) where \(R\) is its coefficient ring (a polynomial ring or the degree valuation ring of \(k(x)\) or an order which is a lesser degree extension of \(k[x]\)) and \(n\) equals the degree \(F/k(x, \alpha_1, \ldots, \alpha_r)\). It has a basis consisting of \(n\) elements. Within Magma, function field order elements are printed as a sequence of coefficients of the \(R\)-linear combination of such a basis.

Elements can also be represented as a product of other function field or order elements. This is referred to as the product representation. Product representations can be useful for large elements, however, it is expensive to put such elements in a set or to test them for equality as this involves finding coefficients for the element.

Creation of Elements#

F . 1: FldFun -> FldFunElt#

F . 2: FldFun -> FldFunElt#

(i): Return the generator for the function field \(F\) over \(k(x, \alpha_1, \ldots, \alpha_r)\), that is, \(\alpha \in F\) such that \(F = k(x, \alpha_1, \ldots, \alpha_r, \alpha)\).
(ii): Return the first and second generators for the function field \(F\) over \(k\), that is, \(\alpha \in F\) and \(x \in F\) such that \(F = k(x, \alpha)\).

Name(F, i): FldFun, RngIntElt -> FldFunElt#: Given a function field \(F\), return the \(i\)-th generator, i.e. return the element F.1 or F.2 of \(F\).

O . i: RngFunOrd, RngIntElt -> FldFunOrdElt#
FF . i: FldFunOrd, RngIntElt -> FldFunOrdElt#: Return the \(i\)th basis element of the order \(O\) or its field of fractions \(FF\).

F ! a: FldFun, . -> FldFunElt#

elt<F | a>: FldFun, . -> FldFunElt#

Create the element of the function field \(F\) specified by \(a\); here \(a\) is allowed to be an element coercible into \(F\), which means that \(a\) may be:

(i): an element of \(F\),
(ii): an element of the coefficient field of \(F\),
(iii): an element of another representation of \(F\). For \(F\) an extension of \(k(x)\) we additionally have
(iv): an element of an order of \(F\),
(v): an element being coercible into \(k(x)\),
(vi): a sequence of elements being coercible into the coefficient field of \(F\) of length equal to the degree of \(F\) over its coefficient field. In this case the element \(a_0 + a_1 \alpha + \dots + a_{n-1} \alpha^{n-1}\) is created, where \(a=[a_0, \dots, a_{n-1}]\) and \(\alpha\) is the generator F.1 of \(F\) over its coefficient field.

O ! a: RngFunOrd, . -> RngFunOrdElt#

elt<O | a>: RngFunOrd, . -> RngFunOrdElt#

Create the element of the order \(O\) specified by \(a\); here \(a\) is allowed to be an element coercible into \(O\), which means that mathematically \(a \in O\) and that \(a\) may be any of:

(i): an element of the function field \(F\),
(ii): an element of an order of the function field \(F\),
(iii): an element that can be coerced into \(k(x)\),
(iv): an element that can be coerced into its coefficient field,
(v): a sequence of elements being coercible into the coefficient field of \(O\) of length equal to the rank of \(O\) over its coefficient field. In this case the element \(a_1 \omega_1 + a_2 \omega_2 + \dots + a_{n} \omega_n\) is created, where \(a=[a_1, \dots, a_{n}]\) and \(\omega_1, \omega_2, \dots, \omega_n\) is the basis of \(O\) as returned by Basis(O).

FF ! a: FldFunOrd, Any -> FldFunOrdElt#
elt<FF | a>: FldFunOrd, Any -> FldFunOrdElt#: Create the element of the field of fractions \(FF\) of an order \(O\) specified by \(a\), where \(a\) may be any of the above such that \(d*a\) is mathematically in \(O\) for some \(d \in O\).

elt< F | a₀, a₁, ..., aₙ₋₁>: FldFun, RngElt, ..., RngElt -> FldFunElt#: Create the element \(a_0 + a_1 \alpha + \dots + a_{n-1} \alpha^{n-1}\) where \(a_0, \dots, a_{n-1}\) are coercible into the coefficient field of the function field \(F\), \(n\) equals the degree of \(F\) over its coefficient field and \(\alpha\) is the generator F.1 of \(F\) over \(k(x)\).

elt< O | a₁, a₂, ..., aₙ>: RngFunOrd, RngElt, ..., RngElt -> RngFunOrdElt#
elt< FF | a₁, a₂, ..., aₙ>: FldFunOrd, RngElt, ..., RngElt -> FldFunOrdElt#: Create the element \(a_1 \omega_1 + a_2 \omega_2 + \dots + a_{n} \omega_n\) where \(a_1, \dots, a_{n}\) are coercible into the coefficient ring of the order \(O\), \(n\) equals the rank of \(O\) over its coefficient ring and \(\omega_1, \omega_2, \dots, \omega_n\) is the basis of \(O\) as returned by Basis(O), (where \(O\) is the ring of integers of the field of fractions \(FF\)).

One(F): FldFun -> FldFunElt#
One(O): RngFunOrd -> RngFunOrdElt#
Identity(F): FldFun -> FldFunElt#
Identity(O): RngFunOrd -> RngFunOrdElt#
Zero(F): FldFun -> FldFunElt#
Zero(O): RngFunOrd -> RngFunOrdElt#
Representative(F): FldFun -> FldFunElt#
Representative(O): RngFunOrd -> RngFunOrdElt#: These generic functions (cf. Chapter Introduction to Rings) create \(1\), \(1\), \(0\), and \(0\) respectively in the function field \(F\) or order \(O\).

Random(F, m): FldFunG, RngIntElt -> FldFunElt#
Random(O, m): RngFunOrd, RngIntElt -> RngFunOrdElt#: A “random” element of the global function field \(F\) or one of its orders \(O\). The size of the coefficients of the element are determined by \(m\).

Parent and Category#

Parent(a): FldFunElt -> FldFun#

Parent(a): RngFunOrdElt -> RngFunOrd#

Category(a): FldFunElt -> Cat#

Category(a): RngFunOrdElt -> Cat#

Sequence Conversions#

The sequence conversions refer to the function field \(F\) as a vector space of dimension \(n\) over the coefficient field of \(F\) where \(F\) is a finite degree extension (degree \(n\)) of its coefficient field.

ElementToSequence(a): FldFunElt -> SeqEnum[FldElt]#
ElementToSequence(a): RngFunOrdElt -> SeqEnum[RngElt]#
ElementToSequence(a): FldFunOrdElt -> SeqEnum[RngElt]#
Eltseq(a): FldFunElt -> SeqEnum[FldElt]#
Eltseq(a): RngFunOrdElt -> SeqEnum[RngElt]#
Eltseq(a): FldFunOrdElt -> SeqEnum[RngElt]#: The sequence \([a_1, \dots, a_{n}]\) of elements of the coefficient field of the parent of the function field or order element \(a\) such that \(a = a_1 \omega_1 + a_2 \omega_2 + \dots + a_{n} \omega_n\) where \(\omega_1, \omega_2, \dots, \omega_n\) is a basis of the parent of \(a\).

Eltseq(a, R): FldFunElt, FldFunG -> [FldFunGElt]#: A sequence of coefficients of the function field element \(a\) in the coefficient field \(R\).

Flat(a): FldFunElt -> [FldFunGElt]#: A sequence of coefficients of the function field element \(a\) in the bottom coefficient field of the parent of \(a\).

F ! [ a₀, a₁, ..., aₙ₋₁ ]: FldFun, SeqEnum -> FldFunElt#: The element \(a = a_0 + a_1\alpha + \dots + a_{n-1}\alpha^{n-1}\) where the function field \(F = k(x, \alpha_1, \ldots, \alpha_r, \alpha)\) and the \(a_i\) may be coerced into \(k(x, \alpha_1, \ldots, \alpha_r)\).

O ! [ a₁, a₂, ..., aₙ ]: RngFunOrd, SeqEnum -> RngFunOrdElt#: The element \(a = a_1 \omega_1 + a_2 \omega_2 + \dots + a_{n} \omega_n\) where \(\omega_1, \omega_2, \dots, \omega_n\) is a basis of the order \(O\) and the \(a_i\) are coercible into the coefficient ring of \(O\).

Example: Elements (ex-27bc08)#

> R<x> := FunctionField(GF(5));
> P<y> := PolynomialRing(R);
> f := y^3 + (4*x^3 + 4*x^2 + 2*x + 2)*y^2 + (3*x + 3)*y + 2;
> F<alpha> := FunctionField(f);
> Evaluate(f, alpha);
0
> F.1;
alpha
> b := x + alpha + 1/x*alpha^2;
> b;
1/x*alpha^2 + alpha + x
> b eq F ! [x, 1, 1/x];
true

Run in calculator

Arithmetic Operators#

The following binary arithmetic operations can also be performed in the case where one operand is an element of the function field \(F\) or an order \(O\) and the other operand is a ring element which can naturally be mapped into \(F\) or \(O\).

+ a: FldFunElt -> FldFunElt#
+ a: RngFunOrdElt -> RngFunOrdElt#
+ a: FldFunOrdElt -> FldFunOrdElt#
- a: FldFunElt -> FldFunElt#
- a: RngFunOrdElt -> RngFunOrdElt#
- a: FldFunOrdElt -> FldFunOrdElt#
a + b: FldFunElt, FldFunElt -> FldFunElt#
a + b: RngFunOrdElt, RngFunOrdElt -> RngFunOrdElt#
a + b: FldFunOrdElt, FldFunOrdElt -> FldFunOrdElt#
a - b: FldFunElt, FldFunElt -> FldFunElt#
a - b: RngFunOrdElt, RngFunOrdElt -> RngFunOrdElt#
a - b: FldFunOrdElt, FldFunOrdElt -> FldFunOrdElt#
a * b: FldFunElt, FldFunElt -> FldFunElt#
a * b: RngFunOrdElt, RngFunOrdElt -> RngFunOrdElt#
a * b: FldFunOrdElt, FldFunOrdElt -> FldFunOrdElt#
a div b: FldFunElt, FldFunElt -> FldFunElt#
a div b: FldFunElt, RngElt -> FldFunElt#
a div b: RngFunOrdElt, RngFunOrdElt -> RngFunOrdElt#
a div b: RngFunOrdElt, RngElt -> RngFunOrdElt#
a / b: FldFunElt, FldFunElt -> FldFunElt#
a / b: RngFunOrdElt, RngFunOrdElt -> FldFunGElt#
a / b: FldFunOrdElt, FldFunOrdElt -> FldFunOrdElt#
a ^ k: FldFunElt, RngIntElt -> FldFunElt#
a ^ k: RngFunOrdElt, RngIntElt -> RngFunOrdElt#
a ^ k: FldFunOrdElt, RngIntElt -> FldFunOrdElt#
Modexp(a, k, m): RngFunOrdElt, RngIntElt, RngUPolElt -> RngFunOrdElt#
Modexp(a, k, m): RngFunOrdElt, RngIntElt, RngValElt -> RngFunOrdElt#: Return \(a^k\ mod\ m\) where \(m\) is an element of \(k[x]\) or \(o_{\infty}\) according to whether the parent of \(a\) is a finite or infinite order.

a mod I: RngFunOrdElt, RngFunOrdIdl -> RngFunOrdElt#: Return the element \(a\) belonging to the order \(O\) as an element of \(O/I\).

Modinv(a, m): RngFunOrdElt, RngFunOrdIdl -> RngFunOrdElt#
Modinv(a, m): RngFunOrdElt, RngUPolElt -> RngFunOrdElt#
Modinv(a, m): RngFunOrdElt, RngValElt -> RngFunOrdElt#: Return the inverse of the element \(a\) of an order of a function field modulo \(m\) where \(m\) is an element of \(k[x]\) or \(o_{\infty}\) according to whether the order of \(a\) is a finite or infinite order or an ideal of the order of \(a\).

Equality and Membership#

The following binary arithmetic operations can also be performed in the case where one operand is an element of the function field \(F\) or an order \(O\) and the other operand is a ring element which can naturally be mapped into \(F\) or \(O\).

a eq b: FldFunElt, FldFunElt -> BoolElt#

a eq b: RngFunOrdElt, RngFunOrdElt -> BoolElt#

a eq b: FldFunOrdElt, FldFunOrdElt -> BoolElt#

a ne b: FldFunElt, FldFunElt -> BoolElt#

a ne b: RngFunOrdElt, RngFunOrdElt -> BoolElt#

a ne b: FldFunOrdElt, FldFunOrdElt -> BoolElt#

a in F: RngElt, FldFun -> BoolElt#

a in O: RngElt, RngFunOrd -> BoolElt#

a in FF: RngElt, FldFunOrd -> BoolElt#

a notin F: RngElt, FldFun -> BoolElt#

a notin O: RngElt, RngFunOrd -> BoolElt#

a notin FF: RngElt, FldFunOrd -> BoolElt#

Predicates on Elements#

The functions in this section list the general ring element predicates that apply to function fields and orders of a function field.

IsDivisibleBy(a, b): FldFunElt, FldFunElt -> BoolElt, FldFunElt#
IsDivisibleBy(a, b): RngFunOrdElt, RngFunOrdElt -> BoolElt, RngFunOrdElt#: Given elements \(a\) and \(b\) belonging to a function field \(F\) or an order \(O\), returns true if there exists \(c \in F\) or \(c \in O\) such that \(a = bc\) and returns \(c\) as well, provided that \(b\not=0\).

IsZero(a): FldFunElt -> BoolElt#
IsZero(a): RngFunOrdElt -> BoolElt#
IsZero(a): FldFunOrdElt -> BoolElt#
IsOne(a): FldFunElt -> BoolElt#
IsOne(a): RngFunOrdElt -> BoolElt#
IsOne(a): FldFunOrdElt -> BoolElt#
IsMinusOne(a): FldFunElt -> BoolElt#
IsMinusOne(a): RngFunOrdElt -> BoolElt#
IsMinusOne(a): FldFunOrdElt -> BoolElt#
IsNilpotent(a): FldFunElt -> BoolElt#
IsNilpotent(a): RngFunOrdElt -> BoolElt#
IsIdempotent(a): FldFunElt -> BoolElt#
IsIdempotent(a): RngFunOrdElt -> BoolElt#
IsUnit(a): FldFunElt -> BoolElt#
IsUnit(a): RngFunOrdElt -> BoolElt#
IsUnit(a): FldFunOrdElt -> BoolElt#
IsZeroDivisor(a): FldFunElt -> BoolElt#
IsZeroDivisor(a): RngFunOrdElt -> BoolElt#
IsRegular(a): FldFunElt -> BoolElt#
IsRegular(a): RngFunOrdElt -> BoolElt#
IsIrreducible(a): FldFunElt -> BoolElt#
IsIrreducible(a): RngFunOrdElt -> BoolElt#
IsPrime(a): FldFunElt -> BoolElt#
IsPrime(a): RngFunOrdElt -> BoolElt#
IsSeparating(a): FldFunGElt -> BoolElt#: Returns true if the function field element \(a\) is a separating element (has a non zero differential).

IsConstant(a): FldFunGElt -> BoolElt, RngElt#
IsConstant(a): RngFunOrdElt -> BoolElt, RngElt#: Whether the algebraic function \(a\) is constant; if so it is returned as an element of the exact constant field.

IsGlobalUnit(a): FldFunElt -> BoolElt#: Whether the function field element \(a\) is a global unit, i.e. a constant (equivalent to IsConstant)

IsGlobalUnitWithPreimage(a): FldFunElt -> BoolElt, GrpAbElt#: Returns true and the preimage of the function field element \(a\) in the global unit group, false otherwise. The function field must be global.

IsUnitWithPreimage(a): RngFunOrdElt -> BoolElt, GrpAbElt#: Returns true and the preimage of the order element \(a\) in the unit group of \(O\) if \(a\) is a unit, false otherwise. The function field has to be global.

Functions related to Norm and Trace#

Multiplication by \(a \in F\) or \(a \in O\) defines a linear map of the vector space \(F\) over its coefficient field where \(F\) is a finite extension of its coefficient field. The following functions work with respect to this mapping.

Trace(a): FldFunGElt -> FldFunGElt#
Trace(a): RngFunOrdElt -> RngElt#
Norm(a): FldFunGElt -> FldFunGElt#
Norm(a): RngFunOrdElt -> RngElt#
MinimalPolynomial(a): FldFunElt -> RngUPolElt#
MinimalPolynomial(a): RngFunOrdElt -> RngUPolElt#
MinimalPolynomial(a): FldFunOrdElt -> RngUPolElt#
CharacteristicPolynomial(a): FldFunElt -> RngUPolElt#
CharacteristicPolynomial(a): RngFunOrdElt -> RngUPolElt#
RepresentationMatrix(a): FldFunGElt -> AlgMatElt#
RepresentationMatrix(a): RngFunOrdElt -> AlgMatElt#: Returns the matrix \(M \in R^{n \times n}\) such that \(a\,(\omega_1, \omega_2, \dots, \omega_{n}) = (\omega_1, \omega_2, \dots, \omega_{n}) \, M\), where \(\omega_1, \omega_2, \dots, \omega_n\) is a \(R\)-basis of the parent of the function field or order element \(a\) and \(R\) is the coefficient ring of the parent of \(a\).

Trace(a, R): FldFunElt, Rng -> RngElt#
Trace(a, R): RngFunOrdElt, Rng -> RngElt#: The trace of the function field or order element \(a\) over \(R\), a coefficient ring or field of the parent of \(a\).

Norm(a, R): FldFunElt, Rng -> RngElt#
Norm(a, R): RngFunOrdElt, Rng -> RngElt#: The norm of the order or algebraic function field element \(a\) over \(R\), a coefficient ring or field of the parent of \(a\).

CharacteristicPolynomial(a, R): FldFunElt, Rng -> RngUPolElt#
CharacteristicPolynomial(a, R): RngFunOrdElt, Rng -> RngUPolElt#: The characteristic polynomial of the order or algebraic function field element \(a\) over \(R\), a coefficient ring or field of the parent of \(a\).

MinimalPolynomial(a, R): FldFunElt, Rng -> RngUPolElt#
MinimalPolynomial(a, R): RngFunOrdElt, Rng -> RngUPolElt#: The minimal polynomial of the order or algebraic function field element \(a\) over \(R\), a coefficient ring or field of the parent of \(a\).

AbsoluteMinimalPolynomial(a): FldFunElt -> RngUPolElt#: The minimal polynomial of the function field element \(a\) over the rational function field.

RepresentationMatrix(a, R): FldFunGElt, Rng -> AlgMatElt#
RepresentationMatrix(a, R): RngFunOrdElt, Rng -> AlgMatElt#: Returns the matrix \(M \in R^{n \times n}\) such that \(a\,(\omega_1, \omega_2, \dots, \omega_{n}) = (\omega_1, \omega_2, \dots, \omega_{n}) \, M\), where \(\omega_1, \omega_2, \dots, \omega_n\) is a \(R\)-basis of the parent of the function field or order element \(a\) and \(R\) is a coefficient ring of the parent of \(a\).

Example: Elements Norm Trace (ex-2d04b2)#

> P<x> := PolynomialRing(Integers());
> N<n> := NumberField(x^6 - 6);
> P<x> := PolynomialRing(N);
> P<y> := PolynomialRing(P);
> F<c> := FunctionField(y^8 - x^3*N.1^5);
> P<y> := PolynomialRing(F);
> F2<d> := FunctionField(y^3 + N.1*F!x - c);
> d^10;
(c^3 - 3*n*x*c^2 + 3*n^2*x^2*c - n^3*x^3)*d
> Norm(d^10);
-120*n^3*x^3*c^7 + 210*n^4*x^4*c^6 - 252*n^5*x^5*c^5 + 1260*x^6*c^4 -
    720*n*x^7*c^3 + (270*n^2*x^8 + n^5*x^3)*c^2 + (-60*n^3*x^9 - 60*x^4)*c +
    6*n^4*x^10 + 270*n*x^5
> Norm(d^10, CoefficientField(F));
13060694016*n^2*x^80 - 21767823360*n^5*x^75 + 97955205120*n^2*x^70 -
    43535646720*n^5*x^65 + 76187381760*n^2*x^60 - 15237476352*n^5*x^55 +
    12697896960*n^2*x^50 - 1209323520*n^5*x^45 + 453496320*n^2*x^40 -
    16796160*n^5*x^35 + 1679616*n^2*x^30
> Trace(d^10, CoefficientField(F));
0
> Trace(d^10);
0

Run in calculator

Functions related to Places and Divisors#

Evaluate(a, P): FldFunElt, PlcFunElt -> RngElt#
Evaluate(a, P): RngFunOrdElt, PlcFunElt -> RngElt#: Evaluate the algebraic function \(a\) at the place \(P\). If it is not defined at \(P\), infinity is returned.

Lift(a, P): RngElt, PlcFunElt -> FldFunElt#: Lift the element \(a\) of the residue class field of the place \(P\) (including infinity) to an algebraic function.

Valuation(a, P): FldFunElt, PlcFunElt -> RngIntElt#
Valuation(a, P): RngFunOrdElt, PlcFunElt -> RngIntElt#: The valuation of the function field or order element \(a\) at the place \(P\).

Expand(a, P): FldFunGElt, PlcFunElt -> RngSerElt, FldFunGElt#

RelPrec: RngIntElt                    Default: 10
AbsPrec: RngIntElt                    Default: 

Expand the algebraic function \(a\) to a series of given precision at the place \(P\) and return also the local parameter.

Development(a, P): FldFunGElt, PlcFunElt -> RngSerElt#

RelPrec: RngIntElt                    Default: 10
AbsPrec: RngIntElt                    Default: 

The algebraic function \(a\) expressed as a combination of powers of the local parameter of the place \(P\).

Divisor(a): FldFunGElt -> DivFunElt#
Divisor(a): RngFunOrdElt -> DivFunElt#
PrincipalDivisor(a): FldFunGElt -> DivFunElt#
PrincipalDivisor(a): RngFunOrdElt -> DivFunElt#: The (principal) divisor \((a)\) of the function field or order element \(a\).

Zeros(a): FldFunGElt -> [PlcFunElt]#
Zeros(a): RngFunOrdElt -> [PlcFunElt]#
Zeroes(a): FldFunGElt -> [PlcFunElt]#
Zeroes(a): RngFunOrdElt -> [PlcFunElt]#: A sequence containing the zeros of the algebraic function \(a\).

Zeros(F, a): FldFunG, FldFunGElt -> [PlcFunElt]#
Zeroes(F, a): FldFunG, FldFunGElt -> [PlcFunElt]#: The zeros of the function field element \(a\) in the function field \(F\).

Poles(a): FldFunGElt -> SeqEnum[PlcFunElt]#
Poles(a): RngFunOrdElt -> SeqEnum[PlcFunElt]#: A sequence containing the poles of the algebraic function \(a\).

Poles(F, a): FldFun, FldFunGElt -> [PlcFunElt]#: A sequence containing the poles of the function field element \(a\) in the function field \(F\).

Degree(a): FldFunElt -> RngIntElt#
Degree(a): RngFunOrdElt -> RngIntElt#: The degree of the algebraic function \(a\), being defined as the degree of the pole (or zero) divisor of \(a\).

CommonZeros(L): [FldFunGElt] -> [PlcFunElt]#: Return the common zeros of the function field elements in the sequence \(L\).

CommonZeros(F, L): FldFunG, SeqEnum[ FldFunGElt ] -> SeqEnum[ PlcFunElt ]#: Return the common zeros in the function field \(F\) of the function field elements in the sequence \(L\).

Example: elements (ex-0c032c)#

> R<x> := FunctionField(GF(9));
> P<y> := PolynomialRing(R);
> f := y^3 + y + x^5 + x + 1;
> F<a> := FunctionField(f);
> MinimalPolynomial(a);
y^3 + y + x^5 + x + 1
> RepresentationMatrix(a);
[                  0                   1                   0]
[                  0                   0                   1]
[    2*x^5 + 2*x + 2                   2                   0]
> O := IntegralClosure(ValuationRing(R), F);
> Denominator(a, O);
1/x^2
> O := IntegralClosure(PolynomialRing(GF(9)), F);
> Denominator(a, O);
1
> Zeros(a);
[ (x + 2, a), (x^3 + 2*x^2 + 1, a + x^3 + 2*x^2 + 1) ]
> Degree(a);
5
> P := RandomPlace(F, 2);
> P;
(x^2 + $.1^2*x + $.1^6, a + x^2 + $.1^5*x + 1)
> b := Evaluate(a, P);
> b;
$.1^3*$.1 + $.1^3
> c := Lift(b, P);
> c;
$.1^3*x + $.1^3
> Valuation(a, P);
0
> Valuation(a-c, P);
1

Run in calculator

Module(L, R): SeqEnum[ FldFunGElt ], Rng -> Mod, Map, SeqEnum[ ModElt ]#

IsBasis  : BoolElt                    Default: false
PreImages: BoolElt                    Default: false

The \(R\)-module generated by the function field elements in the sequence \(L\) as an abstract module, together with the map into the algebraic function field. The resulting modules can be used for intersection and inner sum computations.

If the optional parameter IsBasis is set true the function assumes that the given elements form a basis of the module to be computed.

If the optional parameter PreImages is set true then the preimages of the given elements under the map are returned as the third return value.

Both optional parameters are mainly used to save computation time.

Relations(L, R): SeqEnum[ FldFunElt ], Rng -> ModTupRng#
Relations(L, R, m): SeqEnum[ FldFunElt ], Rng, RngIntElt -> ModTupRng#: The module of \(R\)-linear relations between the function field elements of the sequence \(L\). The integer \(m\) is used for the following: Let the elements of \(L\) be \(a_1, \dots, a_n\), \(V\) be the relation module \(\subseteq R^n\) and define \(M := \{\, \sum_{i=1}^m v_i a_i \,|\, v = (v_i)_i \in V \,\}\). The function tries to compute a generating system of \(V\) such that the corresponding generating system of \(M\) consists of “small” elements.

Roots(f, D): RngUPolElt, DivFunElt -> SeqEnum[ FldFunElt ]#: Compute the roots of the polynomial \(f\) which lie in the Riemann-Roch space of the divisor \(D\).

Example: module (ex-7f09fd)#

This example shows the capability of Module and Relations with relative function fields.

> PR<x> := PolynomialRing(Rationals());
> P<y> := PolynomialRing(PR);
> FR1<a> := FunctionField(y^3 - x);
> P<y> := PolynomialRing(FR1);
> FR2<c> := FunctionField(y^2 - a);
> MFR1F := MaximalOrderFinite(FR1);
> m, f := Module([c, c + a], MFR1F);
> f(m.1);
1
> f(m.2);
c
> m, f := Module([c, c + a], FR1);
> f(m.1);
c
> f(m.2);
1
> m;
KModule m of dimension 2 over FR1
> Relations([c, c + a], FR1, 1);
Vector space of degree 2, dimension 0 over FR1
User basis:
Matrix with 0 rows and 2 columns

Run in calculator

Other Operations on Elements#

ProductRepresentation(a): FldFunGElt -> [FldFunGElt], [RngIntElt]#
ProductRepresentation(a): RngFunOrdElt -> [RngElt], [RngIntElt]#: Return a product representation for the function field or order element \(a\).

ProductRepresentation(Q, S): [FldFunGElt], [RngIntElt] -> FldFunGElt#
PowerProduct(Q, S): [FldFunGElt], [RngIntElt] -> FldFunGElt#: Return the element given by the product representation of function field elements in the sequence \(Q\) and exponents in the sequence \(S\). It is expensive to put large elements in product representation into sets or to test for them for equality.

RationalFunction(a): FldFunGElt -> RngElt#

RationalFunction(a, R): FldFunGElt, Rng -> RngElt#

Return the algebraic function \(a\) as a rational function in free variables with respect to the defining polynomial over the coefficient field.

If the ring \(R\) is provided it must appear in the tower of coefficient fields of the parent of \(a\) and the result is a polynomial over \(R\) with respect to all the defining polynomials of the extensions in between.

Differentiation(x, a): FldFunGElt, FldFunGElt -> FldFunGElt#: The first differentiation resp. derivative of the function field element \(a\) with respect to the separating element \(x\).

Differentiation(x, n, a): FldFunGElt, RngIntElt, FldFunGElt -> FldFunGElt#: The \(n\)th differentiation of the function field element \(a\) with respect to the separating element \(x\). In characteristic zero the \(n\)th differentiation equals the \(n\)th derivative times \(1/n!\).

DifferentiationSequence(x, n, a): FldFunGElt, RngIntElt, FldFunGElt -> SeqEnum#: The \(0\)-th up to the \(n\)-th differentiation of the function field element \(a\) with respect to the separating element \(x\).

PrimePowerRepresentation(x, k, a): FldFunGElt, RngIntElt, FldFunGElt -> SeqEnum#: Return the coefficients of the representation of the function field element \(a\) as a linear combination of \(k\)-th prime powers and powers of the function field element \(x\). More precisely, let \(p > 0\) be the characteristic of \(F\). Then \(F^{p^k}\) is a subfield of \(F\) of index \(p^k\) and \(F\) can be viewed as a \(F^{p^k}\)-vector space. A basis is given by \(1, x, \dots, x^{p^k-1}\) for \(x\) a separating element. The function returns \(\lambda_1, \dots, \lambda_{p^k-1} \in F^{p^k}\) such that \(a = \sum_i \lambda_i x^i\).

Different(a): RngFunOrdElt -> RngFunOrdElt#: The different of the element \(a\) of an order of an algebraic function field.

RationalReconstruction(e, f): FldFunElt, RngUPolElt -> BoolElt, FldFunElt#: For an element \(e\) of some function field \(K\) with integral coefficients \(e = \sum e_i\alpha^i\), \(e_i\in k[x]\) and some polynomial \(f\in k[x]\) find the (essentially) unique \(E = \sum E_i\alpha_i\) with \(E_i\in k(x)\) and \(E_i = e_i \bmod f\), where the numerator and denominator of the \(E_i\) have degree bounded by half the degree of \(f\). If such \(E_i\) exists they are unique, the corresponding element \(\sum E_i\alpha^i\) for the function field will be returned as a second return value, the first being true to indicate success. If no such element exists, false will be returned.

CoefficientHeight(a): RngFunOrdElt -> RngIntElt#
CoefficientHeight(a): FldFunElt -> RngIntElt#: The (naive) height of the element as defined as the largest degree of any coefficient or denominator polynomial occurring in the coefficients of \(a\).

CoefficientLength(a): RngFunOrdElt -> RngIntElt#
CoefficientLength(a): FldFunElt -> RngIntElt#: The (naive) length or size of the element, defined as the sum of the degrees of all polynomials occurring as coefficients or denominators in the coefficient representation of \(a\).

Example: Elements Other Ops (ex-d8f7df)#

> F<z> := GF(13, 3);
> PF<x> := PolynomialRing(F);
> P<y> := PolynomialRing(PF);
> FF1<b> := ext<FieldOfFractions(PF) | y^2 - x>;
> P<y> := PolynomialRing(FF1);
> FF2<d> := ext<FF1 | y^3 - ConstantField(FF1).1>;
> ProductRepresentation([Random(FF2, 2) : i in [1 .. 3]], [2, 3, 2]);
(((z^476*x + z^319)*b + (z^1861*x + z^439))*d^2 + ((z^348*x + z^931)*b +
    (z^328*x + z^2076))*d + (z^152*x + z^1723)*b + z^1044*x + z^1119)^2 *
(((z^1024*x + z^2085)*b + (z^798*x + z^335))*d^2 + ((z^310*x + z^932)*b +
    (z^281*x + z^1393))*d + (z^1844*x + z^66)*b + z^2127*x + z^1788)^3 *
(((z^1478*x + z^1782)*b + (z^687*x + z^1898))*d^2 + ((z^560*x + z^425)*b +
    (z^2081*x + z^164))*d + (z^60*x + z^890)*b + z^258*x + z^1739)^2
> ProductRepresentation($1);
[
    ((z^476*x + z^319)*b + (z^1861*x + z^439))*d^2 + ((z^348*x + z^931)*b +
        (z^328*x + z^2076))*d + (z^152*x + z^1723)*b + z^1044*x + z^1119,
    ((z^1024*x + z^2085)*b + (z^798*x + z^335))*d^2 + ((z^310*x + z^932)*b +
        (z^281*x + z^1393))*d + (z^1844*x + z^66)*b + z^2127*x + z^1788,
    ((z^1478*x + z^1782)*b + (z^687*x + z^1898))*d^2 + ((z^560*x + z^425)*b +
        (z^2081*x + z^164))*d + (z^60*x + z^890)*b + z^258*x + z^1739
]
[ 2, 3, 2 ]
> r := Random(FF2, 3);
> RationalFunction(r);
((z^1568*x^2 + z^1591*x + z^1260)*b + (z^746*x^2 + z^1405*x + z^1721))*y^2 +
    ((z^990*x^2 + z^689*x + z^470)*b + (z^1324*x^2 + z^195*x + z^1082))*y +
    (z^331*x^2 + z^1995*x + z^1521)*b + z^1323*x^2 + z^852*x + z^2162
> RationalFunction(r, CoefficientField(FF2));
((z^1568*x^2 + z^1591*x + z^1260)*b + (z^746*x^2 + z^1405*x + z^1721))*$.1^2 +
    ((z^990*x^2 + z^689*x + z^470)*b + (z^1324*x^2 + z^195*x + z^1082))*$.1 +
    (z^331*x^2 + z^1995*x + z^1521)*b + z^1323*x^2 + z^852*x + z^2162
> RationalFunction(r, PF);
(z^1568*x^2 + z^1591*x + z^1260)*$.1^2*$.2 + (z^746*x^2 + z^1405*x +
    z^1721)*$.1^2 + (z^990*x^2 + z^689*x + z^470)*$.1*$.2 + (z^1324*x^2 +
    z^195*x + z^1082)*$.1 + (z^331*x^2 + z^1995*x + z^1521)*$.2 + z^1323*x^2 +
    z^852*x + z^2162
> Differentiation(FF2!x, r);
((z^836*x^2 + z^2140*x + z^1077)/x*b + (z^929*x + z^1405))*d^2 + ((z^258*x^2 +
    z^1238*x + z^287)/x*b + (z^1507*x + z^195))*d + (z^1795*x^2 + z^348*x +
    z^1338)/x*b + z^1506*x + z^852
> Differentiation(FF2!b, r);
((z^1112*x + z^1588)*b + (z^1019*x^2 + z^127*x + z^1260))*d^2 + ((z^1690*x +
    z^378)*b + (z^441*x^2 + z^1421*x + z^470))*d + (z^1689*x + z^1035)*b +
    z^1978*x^2 + z^531*x + z^1521
> Differentiation(FF2!d, r);
>> Differentiation(FF2!d, r);
                  ^
Runtime error in 'Differentiation': First element must be a separating element
> MFR2I := MaximalOrderInfinite(FF2);
> Different(Numerator(r, MFR2I));
[ [ (z^1095*x^5 + z^849*x^4 + z^111*x^3 + z^853*x^2 + z^224*x + z^1340)/x^6,
    (z^666*x^4 + z^1902*x^3 + z^2086*x^2 + z^1119*x + z^1973)/x^5 ], [
    (z^1673*x^5 + z^699*x^4 + z^1465*x^3 + z^1060*x^2 + z^761*x + z^1979)/x^6,
    (z^1034*x^4 + z^1185*x^3 + z^833*x^2 + z^2044*x + z^1701)/x^5 ], [
    (z^516*x^5 + z^1545*x^4 + z^509*x^3 + z^832*x^2 + z^606*x + z^700)/x^6,
    (z^1033*x^4 + z^983*x^3 + z^1375*x^2 + z^89*x + z^271)/x^5 ] ]

Run in calculator

Elements#

Creation of Elements#

Parent and Category#

Sequence Conversions#

Arithmetic Operators#

Equality and Membership#

Predicates on Elements#

Functions related to Norm and Trace#

Functions related to Orders and Integrality#

Functions related to Places and Divisors#

Other Operations on Elements#