[Next][Prev] [Right] [Left] [Up] [Index] [Root]
Subsections
ext< K | f > : FldFun, RngUPolElt -> FldFun
FunctionField(f : parameters) : RngUPolElt -> FldFun
Check: BoolElt Default: true
Let k be a field and K = k(x) or K = k(x, α1, ..., αr)
some finite extension of k(x).
Given an irreducible and
separable polynomial f ∈K[y] of degree greater than zero with
coefficients within K, create the
algebraic function field F= K[y] / < f > = k(x, α1, ...,
αr, α)
obtained by adjoining a root αof f to K. F will be
viewed as a (finite) extension of K. The polynomial f is also
allowed to be ∈k[x][y].
The optional parameter Check may be used to prevent some conditions
from being tested. The default is Check := true,
so that f is verified to be irreducible and separable.
The angle bracket notation may be used to assign the root
αto an identifier: F<a> := FunctionField(f).
Check: BoolElt Default: true
Let k be a field. Given an irreducible polynomial f ∈k[x, y] of
degree greater than zero, create the algebraic function field F which
is the
field of fractions of k[x, y] / < f >.
The polynomial f must be
separable in at least one variable. F will be viewed as (infinite) extension
of k.
The optional parameter Check may be used to prevent some
conditions from being tested. The default is Check := true, so
that f is verified to be irreducible and separable in at least one
variable.
The angle bracket notation may be used to assign the images of
x, y in F to identifiers: F<a, b> := FunctionField(f).
Check: BoolElt Default: true
Return the function field F whose defining polynomials are the polynomials
in the sequence S. If Check is set to false then it will
not be checked the polynomials actually define a field.
sub<F | s1, ..., sr > : FldFun, [] -> FldFun
The subfield of the function field F containing the elements in the
sequence S or the elements si.
HermitianFunctionField(q) : RngIntElt -> FldFun
Create the Hermitian function field F = GF(q2)(x, α) defined by
αq + α= xq + 1, where q is the d-th power of the
prime number p.
AssignNames(~a, s) : FldFunElt, [ MonStgElt ] ->
Procedure to change the name of the generating element(s) in the
function field F (a in F) to the contents of the sequence of strings s,
which must have length 1 or 2 in this case.
This procedure only changes the name(s) used in printing the elements of F.
It does not assign to any identifier(s)
the value(s) of the generator(s) in F; to do this, use an
assignment statement, or use angle brackets when creating the field.
Note that since this is a procedure that modifies F,
it is necessary to have a reference ~F to F (or a)
in the call to this function.
Global: BoolElt Default: true
Type: Cat Default: {hbox FldFunRat}
Return the rational function field over R in one variable. If Global
is false then create a new copy of the field, otherwise reuse any
globally created field which already exists. If Type is FldFun
create the field as an algebraic function field,
otherwise create as a rational function field.
Let GF(5) be the finite field of five elements.
To create the function field extension GF(5)(x, α) / GF(5)(x),
where αsatisfies α2 = 1/x, one may proceed in the
following, equivalent ways:
> R<x> := FunctionField(GF(5));
> P<y> := PolynomialRing(R);
> F<alpha> := FunctionField(y^2 - 1/x);
> F;
Algebraic function field defined over Univariate rational function field over
GF(5)
Variables: x by
y^2 + 4/x
or
> R<x> := PolynomialRing(GF(5));
> P<y> := PolynomialRing(R);
> F<alpha> := FunctionField(x*y^2 - 1);
> F;
Algebraic function field defined over Univariate rational function field over
GF(5)
Variables: x by
x*y^2 + 4
or
> R<x> := FunctionField(GF(5));
> P<y> := PolynomialRing(R);
> F<alpha> := ext< R | y^2 - 1/x >;
> F;
Algebraic function field defined over Univariate rational function field over
GF(5)
Variables: x by
y^2 + 4/x
An extension of F may be created as follows.
> R<y> := PolynomialRing(F);
> FF<beta> := FunctionField(y^3 - x/alpha : Check := false);
> FF;
Algebraic function field defined over F by
y^3 + 4*x^2*alpha
To create a non--simple extension:
> R<x> := FunctionField(GF(5));
> P<y> := PolynomialRing(R);
> FF<alpha, beta> := FunctionField([y^2 - 1/x, y^3 + x]);
> FF;
Algebraic function field defined over Univariate rational function field over
GF(5) by
y^2 + 4/x
y^3 + x
or
> P<y> := PolynomialRing(F);
> FF<beta, gamma> := FunctionField([y^2 - x/alpha, y^3 + x]);
> FF;
Algebraic function field defined over F by
y^2 + 4*x^2*alpha
y^3 + x
The creation of an Hermitian function field:
> F := HermitianFunctionField(9);
> F;
Algebraic function field defined over GF(3^4) by
y^9 + y + 2*x^10
Equation orders, maximal orders and other orders
of algebraic function fields can be
created.
Create the `finite' equation order of the function field
F/k(x, α1, ..., αr), i.e.
k[x, d1 α1, ..., dr αr, d α]
where dj, d ∈k[x] is chosen such that dj αj, d αare
integral over k[x].
Create the `finite' maximal order of the function field
F/k(x, α1, ..., αr).
This is the integral closure of k[x, d1 α1, ..., dr αr]
in F.
Create the `infinite' equation order of the function field
F/k(x, α1, ..., αr), i.e.
o∞[α1, ..., αr, β]
where o∞ denotes the valuation ring of
the degree valuation in k(x) and βis a primitive element of
F/k(x, α1, ..., αr) which is integral over o∞.
Create the `infinite' maximal order of the function field
F/k(x, α1, ..., αr).
This is the integral closure of o∞ in F.
The integral closure of the subring R of the function field F
in itself.
The equation order of the order O. An order whose basis is a transformation
of that of O and is a power basis.
MaximalOrder(O) : RngFunOrd -> RngFunOrd
Discriminant: Any Default:
Ramification: SeqEnum Default:
SetVerbose("MaximalOrder", n): Maximum: 5
The maximal order of the order O of an algebraic function field.
If O is a Kummer extension then specific code is
used to calculate each p-maximal order, rather than the Round 2
method. In this case we know 1 or 2 elements (suggested in the proof of
Proposition III.7.3 of [Sti93]) which generate the p-maximal
order and can write the order down.
If O is an Artin--Schreier extension then the maximal order can be computed
directly without computing the p-maximal orders. The proof of
Proposition III.7.8 of [Sti93] gives us a start on some elements
which are a basis for the maximal order.
If the Discriminant or Ramification parameters are supplied an
algorithm ([Bj94], Theorems 1.2 and 7.6) which can compute the maximal order given
the discriminant of the
maximal order will be used. Discriminant must be an element of
the coefficient ring of O if O
is a non relative order and must be an ideal of O
if O is a relative order. Ramification
must contain elements of the coefficient ring if O is a non relative order and
must contain ideals of O if O is a relative order.
The ramification sequence is taken to contain prime
factors of the discriminant. Only one of these parameters can be specified
and if one of them is then Al cannot be specified.
Set the order O of a function field to be maximal if b is true
and to be non--maximal if b is false.
Check: Bool Default: true
The order O with a root of f adjoined.
Creation of orders is shown below.
> PR<x> := PolynomialRing(Rationals());
> P<y> := PolynomialRing(PR);
> FR1<a> := FunctionField(y^3 - x*y^2 + y + x^4);
> P<y> := PolynomialRing(FR1);
> FR2<c> := FunctionField(y^2 + y - a/x^5);
> EFR1F := EquationOrderFinite(FR1);
> MFR1F := MaximalOrderFinite(FR1);
> EFR1I := EquationOrderInfinite(FR1);
> MFR1I := MaximalOrderInfinite(FR1);
> EFR2F := EquationOrderFinite(FR2);
> MFR2F := MaximalOrderFinite(FR2);
> EFR2I := EquationOrderInfinite(FR2);
> MFR2I := MaximalOrderInfinite(FR2);
> MaximalOrder(EFR2I);
>> MaximalOrder(EFR2I);
^
Runtime error in 'MaximalOrder': Order must be defined over a maximal order
> MFR2I;
Maximal Order of FR2 over MFR1I
> P<y> := PolynomialRing(FR1);
> MaximalOrder(ext<MFR1F | y^2 + y - a*x^5>); MFR2F;
Maximal Equation Order of Algebraic function field defined over FR1 by
y^2 + y - x^5*a over EFR1F
Maximal Order of FR2 over EFR1F
> MaximalOrder(ext<MFR1I | y^2 - 1/a>);
Maximal Order of Algebraic function field defined over FR1 by
y^2 + 1/x^4*a^2 - 1/x^3*a + 1/x^4 over MFR1I
> 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);
> IntegralClosure(R, F);
Algebraic function field defined over GF(5) by
y^3 + (4*x^3 + 4*x^2 + 2*x + 2)*y^2 + (3*x + 3)*y + 2
> IntegralClosure(PolynomialRing(GF(5)), F);
Maximal Order of F over Univariate Polynomial Ring in x over GF(5)
> IntegralClosure(ValuationRing(R), F);
Maximal Order of F over Valuation ring of Rational function field of
rank 1 over GF(5)
Variables: x with generator 1/x
Check: BoolElt Default: true
Create the order whose basis is that of the order O multiplied by the matrix
T over the coefficient ring of O divided by the scalar d. If
the parameter Check is set to false then it will not be checked
that the result is actually an order (potentially expensive).
Check: BoolElt Default: true
Create the order whose basis is that of the order O multiplied by
the dedekind module M. If the parameter
Check is set to false then it will not be checked that the result
is actually an order (potentially expensive).
Verify: BoolElt Default: true
Order: BoolElt Default: false
Given a sequence S of elements in an algebraic function field F create the
minimal order R of F which contains all elements of S.
The order O may be an order of F
which will be used as the suborder of R, in which case its
coefficient ring should be maximal, or O may be a maximal order of the
coefficient field of F.
If Verify is true, it is verified that the elements of S are integral
algebraic numbers. This can be a lengthy process if the field is of large
degree.
Setting Order to true, when the order is large will avoid verifying
that the module generated by the elements of S is closed under multiplication.
By default, products of the generators will be added until the module is closed
under multiplication.
Return the order O as a direct transformation of its equation order, instead
of a composition of transformations.
The smallest common over order of O1 and O2 where O1 and O2 have the
same equation order.
The intersection of orders O1 and O2 which must have the same equation
order.
Return the order O1 as an transformation of the order O2 where O1
and O2 have the same coefficient ring.
Some of the above order creations are shown below.
> P<x> := PolynomialRing(GF(5));
> P<y> := PolynomialRing(P);
> F<a> := FunctionField(y^3 - x^4);
> O := Order(EquationOrderFinite(F), MatrixAlgebra(Parent(x), 3)!1, Parent(x)!3);
> O;
Order of F over Univariate Polynomial Ring in x over GF(5)
> Basis(O);
[
2,
2*a,
2*a^2
]
> P<y> := PolynomialRing(O);
> EO := ext<MaximalOrder(O) | y^2 + O!(2*a)>;
> V := KModule(F, 2);
> M := Module([V | [1, 0], [4, 3], [9, 2]]);
> M;
Module over Maximal Order of F over Univariate Polynomial Ring in x over GF(5)
Ideal of Maximal Order of F over Univariate Polynomial Ring in x over GF(5)
Generator:
1 car Ideal of Maximal Order of F over Univariate Polynomial Ring in x over
GF(5)
Generator:
2
> O2 := Order(EO, M);
> O2;
Order of Algebraic function field defined over F by
$.1^2 + 2*a over Maximal Order of F over Univariate Polynomial Ring in x over
GF(5)
Transformation of EO
Transformation Matrix:
[[ 1, 0, 0 ] [ 0, 0, 0 ]]
[[ 0, 0, 0 ] [ 1, 0, 0 ]]
> Basis(O2);
[ 1, $.1 ]
Orders may be created using ideals of other orders. Ideals are discussed in
Section Ideals.
Returns the multiplicator ring of the ideal I of the order O, that is,
the subring of elements of the field of fractions of O that multiply
I into itself.
pMaximalOrder(O, p) : RngFunOrd, RngElt -> RngFunOrd
The p-maximal over order of O where p is a prime polynomial or ideal
of the coefficient ring of O or an element of valuation 1 of the valuation
ring.
If O is a Kummer extension then specific code is
used to calculate each p-maximal order, rather than the Round 2
method. In this case we know 1 or 2 elements which generate the p-maximal
order and can write the order down.
If O is an Artin--Schreier extension then we can also write down a basis
for the p-maximal order and avoid the Round 2 algorithm. We use
[Sti93] Proposition III.7.8 to get a start on computing these
elements.
pRadical(O, p) : RngFunOrd, RngElt -> RngFunOrdIdl
Returns the p-radical of an order O for a prime p (polynomial or ideal
of the coefficient ring or element of valuation 1 of the valuation ring),
defined as
the ideal consisting of elements of O for which some power lies in the
ideal pO.
It is possible to call this function even if p is not prime. In this case
the p-trace-radical will be computed, i.e.
{ x∈F | Tr(xO)⊆C} for F the field of fractions of O
and C the order of p (if p is an ideal) or the parent of p otherwise.
If p is square free and all divisors are larger than the field
degree, this is the intersection of the radicals for all l dividing
p.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
