|
Let K be a finite extension of the rational function field over
a finite field, the rationals or a number field.
In contrast to the number field situation, there are two different
natural notions of automorphisms here: we distinguish between
automorphisms that fix the base field and arbitrary automorphisms that
can also induce non-trivial maps of the constant field.
The first case, automorphisms fixing the base field of K, is analogous
to the number field case and was implemented by Jürgen Klüners.
The second case of more general automorphisms has been implemented by
Florian Heß along the lines of his paper [Heß04].
Here the constant field of K can, in fact, be any exact perfect field
in Magma with a few provisos.
Computes all Q(t) automorphisms of the absolute finite extension
K that fix k. The field k has to be Q(t) for this function.
Return the group of k-automorphisms of the algebraic function
field K together with the map from the group to the sequence of
automorphisms of K. The field k has to be Q(t).
We define an extension of degree 7 over Q(t) and compute the
automorphisms.
> Q:=Rationals();
> Qt<t>:=PolynomialRing(Q);
> Qtx<x>:=PolynomialRing(Qt);
> f := x^7 + (t^3 + 2*t^2 - t + 13)*x^6 + (3*t^5 - 3*t^4
> + 9*t^3 + 24*t^2 - 21*t + 54)*x^5 + (3*t^7 -
> 9*t^6 + 27*t^5 - 22*t^4 + 6*t^3 + 84*t^2 -
> 121*t + 75)*x^4 + (t^9 - 6*t^8 + 22*t^7 -
> 57*t^6 + 82*t^5 - 70*t^4 - 87*t^3 + 140*t^2 -
> 225*t - 2)*x^3 + (-t^10 + 5*t^9 - 25*t^8 +
> 61*t^7 - 126*t^6 + 117*t^5 - 58*t^4 - 155*t^3
> + 168*t^2 - 80*t - 44)*x^2 + (-t^10 + 8*t^9 -
> 30*t^8 + 75*t^7 - 102*t^6 + 89*t^5 + 34*t^4 -
> 56*t^3 + 113*t^2 + 42*t - 17)*x + t^9 - 7*t^8
> + 23*t^7 - 42*t^6 + 28*t^5 + 19*t^4 - 60*t^3 -
> 2*t^2 + 16*t - 1;
> K:=FunctionField(f);
> A:=Automorphisms(K, BaseField(K));
> #A;
7
Now we transform this list into a group to see that it is really cyclic.
We pass in special functions for equality testing and multiplication
to speed the algorithm up.
> G := GenericGroup(A: Eq := func<a,b | a`Images eq b`Images>,
> Mult := func<a,b | hom<K -> K | a`Images @ b>>);
> G;
Finitely presented group G on 2 generators
Relations
G.1 = Id(G)
G.1 * G.2 = G.2 * G.1
G.1 * G.2^2 = G.2^2 * G.1
G.1 * G.2^3 = G.2^3 * G.1
G.1 * G.2^4 = G.2^4 * G.1
G.1 * G.2^5 = G.2^5 * G.1
G.1 * G.2^6 = G.2^6 * G.1
G.1 = G.2^7
Finally, we verify that this gives the same result as
AutomorphismGroup.
> AutomorphismGroup(K, BaseField(K));
Finitely presented group on 2 generators
Relations
$.1 = Id($)
$.1 * $.2 = $.2 * $.1
$.1 * $.2^2 = $.2^2 * $.1
$.1 * $.2^3 = $.2^3 * $.1
$.1 * $.2^4 = $.2^4 * $.1
$.1 * $.2^5 = $.2^5 * $.1
$.1 * $.2^6 = $.2^6 * $.1
$.1 = $.2^7
Mapping from: GrpFP to [
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K,
Mapping from: FldFun: K to FldFun: K
] given by a rule
Given two absolute finite extensions K and L of Q(t), decide
if L is an extension of K. If this is the case, return an embedding
map from K into L.
Given two absolute finite extensions K and L of Q(t), decide
if L is Q(t)-isomorphic to K. If this is the case, return a
map from K onto L.
Subfields and IsIsomorphic are illustrated below.
> Q:=Rationals();
> Qt<t>:=PolynomialRing(Q);
> Qtx<x>:=PolynomialRing(Qt);
> K:=FunctionField(x^4-t^3);
> L:=Subfields(K);
> #L;
2
> L:=L[2][1]; L;
Algebraic function field defined over Univariate
rational function field over Rational Field
Variables: t by
x^2 - t^3
Now we will check if L is indeed a subfield of K:
> IsSubfield(L,K);
true Mapping from: FldFun: L to FldFun: K
Obviously, L can be defined using a simpler polynomial:
> LL:=FunctionField(x^2-t);
> IsIsomorphicOverQt(LL,L);
true Mapping from: FldFun: LL to FldFun: L
BaseMorphism: Map Default: false
Bound: RngIntElt Default: ∞
Strategy: MonStgElt Default: "None"
Given two function fields K and E, this function computes a list
of at most Bound field isomorphisms from K to E.
If BaseMorphism is given it should be an isomorphism f between
the constant fields of K and E. In this case only isomorphisms extending
f are considered.
The default behaviour is for all isomorphisms from K to E which
extend SOME isomorphism of the constant field of K to that of E
considered. In this case (no base morphism is specified), the constant
fields must be finite, the rationals or a number field. If the
base morphism f is specified then the constant fields can be any
exact perfect fields ( finite or characteristic 0 ).
If the base morphism f is specified, it can be defined in the natural
way for most constant field types. For example, for finite fields and
number fields, the usual hom<k->l|x>, where x gives the image
of k.1, can be used. A common situation is where the constant fields
of K and E are equal to k and f is the identity. This can be
defined very simply for any k by IdentityFieldMorphism(k) .
Several more intrinsics related to field morphisms are described
in the following subsection.
The possible choices of Strategy are "None", "Weierstrass"
or "DegOne". If Strategy is different to "None", this
determines the places that are used as the basis of the construction of
the maps. In all cases, a finite set of places of E and K which
must correspond under any isomorphism are used. All isomorphisms
are found between the canonical affine models (as defined by Heß)
obtained by omitting one of these places from each of E and K.
DegOne can only be used with finite constant fields. In this case,
isomorphisms are determined which map a fixed degree one place of K
to any one of the finite number of degree one places of E.
This function can fail in rare situations if the constant field of K
is too small and no degree one place exists. In this case an appropriate
error message is displayed.
Weierstrass uses the Weierstrass places of the fields. Isomorphisms
are determined which map a fixed Weierstrass place of K to any of
those of E with the same degree and Riemann-Roch data. This strategy
can be very fast if the residue field and Riemann-Roch data of a
particular place of K match those of only a few (or no!) Weierstrass
places of E.
In case of fields of genus <2, the constant field must be finite.
BaseMorphism: Map Default: false
Strategy: MonStgElt Default: "None"
As above, except the function only computes a single isomorphism
if one exists.
BaseMorphism: Map Default: false
Bound: RngIntElt Default: ∞
Strategy: MonStgElt Default: "None"
This function computes a list of at most Bound
automorphisms of the function field K. This is an
abbreviation for Isomorphisms(K, K) and the parameters
are as described above.
An important difference is that the BaseMorphism, if specified,
must be of field morphism type. IdentityFieldMorphism may be
used, but basic constructors for non-trivial constant field maps f
will usually cause an error if used directly. The way around this
is to use the conversion
f := FieldMorphism(f)
(see the following subsection).
Automorphisms(K,p1,p2) : FldFunG, PlcFunElt, PlcFunElt -> [Map]
Bound: RngIntElt Default: ∞
As above except that the constant field morphism is taken as
the identity and only iso/automorphisms which take function field place
p1 to p2 are computed.
BaseMorphism: Map Default: false
Strategy: MonStgElt Default: "None"
Given a function field K, this function computes that group of
automorphisms satisfying the conditions specified by the parameters
and returns it as a finitely-presented group.
The map also returned is invertible and takes a group element to the
function field isomorphism that it represents.
Strategy: MonStgElt Default: "None"
In this variation, the automorphism group of the function field
K is computed in
its permutation representation on a set of places or divisors
or in its linear representation on a space of differentials or
subspace of K.
The return values consist of the representing group G, a map
(with inverse) from G to the maps of K giving the actual
isomorphisms, and a sequence of isomorphisms of K which
consist of the kernel of the representation.
Only automorphisms fixing the constant field are considered here.
If the set/space on which the representation is to be defined
is not invariant by the automorphism group, a run-time error
will result.
The argument f should be a map defining the representation.
Its domain must be an enumerated sequence for a permutation representation
or a vector space for a linear representation.
Its codomain should be K or a space or enumerated sequence of
elements of K, places of K, divisors of K or differentials
of K. The examples below show some common ways of producing f
by using functions like DifferentialSpace and
RiemannRochSpace.
The isomorphisms returned by the functions in the last subsection are of
general Map type but contain some extra internal structure. The same
is true of the maps used to specify BaseMorphism. These objects come
in two flavours: field morphisms, that represent maps between general
fields, and the more specialised function field morphisms, representing
maps between algebraic function fields. This subsection contains
several related functions that are very useful when working with (function)
field morphisms.
Returns true, if the map is a field or function field morphism;
false otherwise.
Converts a homomorphism between fields into a field morphism.
Returns the identity automorphism of field F as a field morphism.
Returns true if f is the identity morphism; false otherwise.
Returns true, if the two maps are both field morphisms or function field
morphisms and are equal; false otherwise.
Either returns "true" and the inverse morphism for (function) field morphism
f, or "false" if inverse does not exist, or "unknown" if it cannot be computed.
The composition of the field morphisms f and g.
We illustrate the use of the general isomorphism functions
with some examples.
In the first, we have a rational function field of characteristic 5:
> k<w> := GF(5);
> kxf<x> := RationalFunctionField(k);
> kxfy<y> := PolynomialRing(kxf);
> F<a> := FunctionField(x^2+y^2-1);
> L := Isomorphisms(kxf, F);
> #L eq #PGL(2, k);
In the next example we consider the function field of a hyperelliptic
curve defined over Q(i) [i2 = - 1] and a Galois twist of it.
The fields are not isomorphic over Q(i) but they are over Q:
> k<i> := QuadraticField(-1);
> kxf<x> := RationalFunctionField(k);
> kxfy<y> := PolynomialRing(kxf);
> F1<a> := FunctionField(y^2-x^5-x^2-i);
> F2<b> := FunctionField(i*y^2-x^5-i*x^2+1);
> c := IdentityFieldMorphism(k);
> IsIsomorphic(F1,F2 : BaseMorphism := c);
false
> IsIsomorphic(F1,F2);
true Mapping from: FldFun: F1 to FldFun: F2 given by a rule
> L := Isomorphisms(F1, F2);
> [<f(a), f(x), f(i)> : f in L];
[
<-i*b, i*x, -i>,
<i*b, i*x, -i>
]
In the next example we consider the function field of the genus 3
plane curve x3 * y + y3 * z + z3 * x=0, which has full automorphism group
PGL2(F7). We compute automorphisms over different finite fields
and also compute the automorphisms group as an FP group.
> k := GF(11);
> kxf<x> := RationalFunctionField(k);
> kxfy<y> := PolynomialRing(kxf);
> K<y> := FunctionField(x^3*y+y^3+x);
> L := Automorphisms(K);
> #L;
3
> // Extend base field to get all autos
> k := GF(11^3);
> kxf<x> := RationalFunctionField(k);
> kxfy<y> := PolynomialRing(kxf);
> K<y> := FunctionField(x^3*y+y^3+x);
> L := Automorphisms(K);
> #L;
504
> // restrict to just "geometric" autos, which fix the base
> c := IdentityFieldMorphism(k);
> L := Automorphisms(K : BaseMorphism := c);
> #L;
168
> // get the automorphism group instead as an FP group
> G,mp := AutomorphismGroup(K : BaseMorphism := c);
> G;
Finitely presented group G on 2 generators
Relations
G.2^3 = Id(G)
(G.1^-1 * G.2)^3 = Id(G)
G.1^7 = Id(G)
(G.2^-1 * G.1^-3)^2 = Id(G)
(G.2^-1 * G.1^-1)^4 = Id(G)
> #G;
168
> IdentifyGroup(G); // find in small group database
<168, 42>
Finally, we give an example of a genus 1 function field over
F5 where the group of automorphisms is computed acting
on various spaces of functions and differentials.
> k<w> := GF(5);
> kxf<x> := RationalFunctionField(k);
> kxfy<y> := PolynomialRing(kxf);
> f := x^3 + y^3 + 1;
> F<a> := FunctionField(f);
> f := Numeration(Set(Places(F, 1)));
> G, h, K := AutomorphismGroup(F, f);
> #G; Type(G);
12
GrpPerm
> V, f := SpaceOfDifferentialsFirstKind(F);
> G, h, K := AutomorphismGroup(F, f);
> #G; Type(G);
2
GrpMat
> D := &+ Places(F, 1);
> V, f := DifferentialSpace( -D );
> G, h := AutomorphismGroup(F, f);
> #G;
12
> V, f := RiemannRochSpace( D );
> G, h, ker := AutomorphismGroup(F, f);
> #G; #ker;
12
1
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|