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: Creating Function Field 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 (opens in a new tab)Copy input

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: Norm and Trace of Elements (ex-2d04b2)

Run in calculator (opens in a new tab)Copy input

> 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 (opens in a new tab)Copy input

Functions related to Orders and Integrality

IntegralSplit(a, O): FldFunElt, RngFunOrd -> RngFunOrdElt, RngElt

IntegralSplit(a, O): RngFunOrdElt, RngFunOrd -> RngFunOrdElt, RngElt

IntegralSplit(a, O): FldFunOrdElt, RngFunOrd -> RngFunOrdElt, RngElt

Split the element function field or order element \(a\) into a numerator and denominator with respect to the order \(O\).

Numerator(a, O): FldFunElt, RngFunOrd -> RngFunOrdElt

The numerator of the function field element \(a\) with respect to the order \(O\).

Numerator(a): FldFunOrdElt -> RngFunOrdElt

Given an element \(a\) in a field of fractions of an order \(O\) return the numerator of \(a\) with respect to \(O\).

Numerator(a, O): FldFunOrdElt, RngFunOrd -> RngElt

Given an element \(a\) in a field of fractions of an order and an order \(O\) of a function field return the numerator of \(a\) with respect to \(O\).

Denominator(a, O): FldFunElt, RngFunOrd -> RngElt

The denominator of the function field element \(a\) with respect to the order \(O\).

Denominator(a): FldFunOrdElt -> RngElt

Given an element \(a\) in a field of fractions of an order \(O\) return the denominator of \(a\) with respect to \(O\).

Denominator(a, O): FldFunOrdElt, RngFunOrd -> RngElt

Given an element \(a\) in a field of fractions of an order and an order \(O\) of a function field return the denominator of \(a\) with respect to \(O\).

Min(a, O): FldFunElt, RngFunOrd -> RngElt, RngElt

Minimum(a, O): FldFunElt, RngFunOrd -> RngElt, RngElt

Minimum(a, O): RngFunOrdElt, RngFunOrd -> RngElt, RngElt

Min(a, O): RngFunOrdElt, RngFunOrd -> RngElt, RngElt

A generator of the ideal \(R \cap (d\times a\times O)\) where \(R\) is the coefficient ring of the order \(O\) and \(d\) is the denominator of the function field or order element \(a\) wrt \(O\) (\(d\) is the second return value).

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: Minimal Polynomial and Representation Matrix (ex-0c032c)

Run in calculator (opens in a new tab)Copy input

> 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 (opens in a new tab)Copy input

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 and Relations over Relative Fields (ex-7f09fd)

Run in calculator (opens in a new tab)Copy input

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 (opens in a new tab)Copy input

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: Product Representation of Elements (ex-d8f7df)

Run in calculator (opens in a new tab)Copy input

> 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 (opens in a new tab)Copy input