Elements

The function field F = k(x, α1, ..., αr, α) may be viewed as n-dimensional vector space over k(x, α1, ..., αr), where n is the degree of the field extension F/k(x, α1, ..., αr). Note that F is spanned by the powers 1, α, ..., αn - 1. Within Magma, function field elements are printed as linear combinations of these powers of α 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, α1, ..., α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.

Contents

Creation of Elements

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.

F . 1 : FldFun -> FldFunElt
F . 2 : FldFun -> FldFunElt
(i)
Return the generator for the function field F over k(x, α1, ..., αr), that is, α ∈F such that F = k(x, α1, ..., αr, α).
(ii)
Return the first and second generators for the function field F over k, that is, α ∈F and x ∈F such that F = k(x, α).
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 ith 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 a0 + a1 α + ... + an - 1 αn - 1 is created, where a=[a0, ..., an - 1] and α 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 ∈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 a1 ω1 + a2 ω2 + ... + an ωn is created, where a=[a1, ..., an] and ω1, ω2, ..., ω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 ∈O.
elt< F | a0, a1, ..., an - 1> : FldFun, RngElt , ..., RngElt -> FldFunElt
Create the element a0 + a1 α + ... + an - 1 αn - 1 where a0, ..., an - 1 are coercible into the coefficient field of the function field F, n equals the degree of F over its coefficient field and α is the generator F.1 of F over k(x).
elt< O | a1, a2, ..., an> : RngFunOrd, RngElt , ..., RngElt -> RngFunOrdElt
elt< FF | a1, a2, ..., an> : FldFunOrd, RngElt , ..., RngElt -> FldFunOrdElt
Create the element a1 ω1 + a2 ω2 + ... + an ωn where a1, ..., an are coercible into the coefficient ring of the order O, n equals the rank of O over its coefficient ring and ω1, ω2, ..., ωn is the basis of O as returned by Basis(O), (where O is the ring of integers of the field of fractions FF).
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 [a1, ..., an] of elements of the coefficient field of the parent of the function field or order element a such that a = a1 ω1 + a2 ω2 + ... + an ωn where ω1, ω2, ..., ω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 ! [ a0, a1, ..., an - 1 ] : FldFun, SeqEnum -> FldFunElt
The element a = a0 + a1α + ... + an - 1αn - 1 where the function field F = k(x, α1, ..., αr, α) and the ai may be coerced into k(x, α1, ..., αr).
O ! [ a1, a2, ..., an ] : RngFunOrd, SeqEnum -> RngFunOrdElt
The element a = a1 ω1 + a2 ω2 + ... + an ωn where ω1, ω2, ..., ωn is a basis of the order O and the ai are coercible into the coefficient ring of O.

Example FldFunG_Elements (H45E28)

> 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

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 ak mod m where m is an element of k[x] or o 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 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.

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
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 ∈F or c ∈O such that a = bc and returns c as well, provided that b not=0.

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 ∈F or a ∈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 ∈Rn x n such that a (ω1, ω2, ..., ωn) = (ω1, ω2, ..., ωn) M, where ω1, ω2, ..., ω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 ∈Rn x n such that a (ω1, ω2, ..., ωn) = (ω1, ω2, ..., ωn) M, where ω1, ω2, ..., ω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 FldFunG_elements-norm-trace (H45E29)

> 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

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 ∩(d x a x 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 FldFunG_elements (H45E30)

> 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
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 a1, ..., an, V be the relation module ⊆Rn and define M := { ∑i=1m vi ai | v = (vi)i ∈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 FldFunG_module (H45E31)

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

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 nth differentiation of the function field element a with respect to the separating element x. In characteristic zero the nth differentiation equals the nth 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 Fpk is a subfield of F of index pk and F can be viewed as a Fpk-vector space. A basis is given by 1, x, ..., xpk - 1 for x a separating element. The function returns λ1, ..., λpk - 1 ∈Fpk such that a = ∑i λi xi.
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 = ∑eiαi, ei∈k[x] and some polynomial f∈k[x] find the (essentially) unique E = ∑Eiαi with Ei∈k(x) and Ei = ei mod f, where the numerator and denominator of the Ei have degree bounded by half the degree of f. If such Ei exists they are unique, the corresponding element ∑Eiα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 FldFunG_elements-other_ops (H45E32)

> 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 ] ]
V2.28, 13 July 2023