// Automorphisms Short Documentation. // Written by Florian Hess, version 20050829 /* Remark: I intend to change the signature of Automorphisms() etc wrt to the handling of BaseMorphism, i.e. make BaseMorphism eq id the standard value. */ ============================================================================= Aim and scope ==================== The program applies to algebraic function fields F of transcendence degree one (FldFun) over perfect, exact constant fields k of genus greater than one. The genus zero and one cases are supported only when k is a finite field (there would be better methods for these cases anyway). There is also some (semi)trivial support for rational function fields (FldFunRat) of transcendence degree one and higher over infinite constant fields. Two definitions: A field morphism is just a non-zero homomorphism F1 -> F2 of two fields. A function field morphism of the function fields F1/k1 and F2/k2 consists of two field morphisms F1 -> F2 and k1 -> k2 such that F1 -> F2 | | k1 -> k2 makes a commutative square, where the vertical maps are the inclusions. The function field morphism is an isomorphism if the top and bottom field morphisms are field isomorphisms. Given two function fields F1/k1 and F2/k2, the program computes all isomorphisms from F1/k1 to F2/k2. It is possible to prescribe the bottom morphism k1 -> k2. For F1/k1 = F2/k2 this yields all automorphisms. Note that this definition of automorphism might differ a little bit from what one would expect, namely that the bottom morphisms k1 -> k2 are the identity. Those automorphisms are computed by prescribing the identity as bottom morphism. There are then also functions to compute automorphism groups in the following ways: o Compute the full automorphism group as finitely presented group (GrpFP) together with a map mapping elements of the group to actual maps. o Given a set of places which is set invariant under the automorphisms compute the permutation representation together with a map mapping permutations to actual maps. Depending on the set this might not be faithful, the actual maps corresponding to the identity permutation are also returned. o Given a k-linear subspace on which the automorphism group operates compute the linear representation as a matrix group. Depending on the subspace this might not be faithful, the actual maps corresponding to the identity matrix are also returned. The latter two cases only consider automorphisms which are the identity on the base field, because non identical bottom morphism cannot be represented by only permutations and matrices. The algorithms are implemented in a recursive way such that recursively defined fields work, e.g. relative function fields over relative number fields or relative function fields over relative function fields over relative number fields work (the latter case at least in principle, but slow). The maps are recursively defined, and the simple constituents (mostly) represented by images on generators and base maps. Since the bottom map need not be the identity it is also possible to represent Galois operations on function fields in the sense of algebraic geometry, which I think is not yet in place for curves in Magma. Method ==================== The basic method is contained in my ANTS paper. The algorithm always works when the characteristic is zero or large enough. There are certain cases in small characteristic where it does not work, an appropiate give up message is displayed for these cases. Examples ===================== Here are some simple examples. k := GF(4); kxf := RationalFunctionField(k); id := IdentityFieldMorphism(k); L := Automorphisms(kxf : BaseMorphism := id); assert #L eq #PGL(2, k); L := Automorphisms(kxf); assert #L eq 2 * #PGL(2, k); k := GF(5); kxf := RationalFunctionField(k); kxfy := PolynomialRing(kxf); f := x^3 + y^3 + 1; F := FunctionField(f); f := Numeration(Set(Places(F, 1))); G, h, K := AutomorphismGroup(F, f); assert #G eq 12; V, f := SpaceOfDifferentialsFirstKind(F); G, h, K := AutomorphismGroup(F, f); assert #G eq 2; D := &+ Places(F, 1); V, f := DifferentialSpace( -D ); G, h := AutomorphismGroup(F, f); assert #G eq 12; V, f := RiemannRochSpace( D ); G, h := AutomorphismGroup(F, f); assert #G eq 12; k := GF(7^2); kx := RationalFunctionField(k); kxy := PolynomialRing(kx); F := FunctionField(y^4 + x^7 - x); L := Automorphisms(F); assert #L eq 2688; k := GF(5); kxf := RationalFunctionField(k); kxfy := PolynomialRing(kxf); F := FunctionField(x^2 + y^2 - 1); L := Isomorphisms(kxf, F); assert #L eq #PGL(2, k); k := GF(9); kxf := RationalFunctionField(k); kxfy := PolynomialRing(kxf); f := w*y + w*y^5 + w^3*x + w^3*x^5 + 1; F1 := FunctionField(f); g := w^3*y + w^3*y^5 + w*x + w*x^5 + 1; F2 := FunctionField(g); L := Isomorphisms(F1, F2); assert #L eq 4; Intrinsics ==================== intrinsic IsMorphism(f::Map) -> Bool {True, if the map is a field or function field morphism, false otherwise} intrinsic Equality(f::Map, g::Map) -> Bool {True, if the two maps are both field morphisms or function field morphisms and are equal, false otherwise} intrinsic IdentityFieldMorphism(F::Fld) -> Map {The identity automorphism of F} intrinsic IsIdentity(f::Map) -> Map {True if f is the identity morphism, false otherwise} intrinsic HasInverse(f::Map) -> MonStgElt, Map {Either "true" and the inverse map, or "false" if inverse does not exist, or "unknown" if it cannot be computed} intrinsic Composition(f::Map, g::Map) -> Map {The composition of the morphisms f and g} intrinsic Isomorphisms(F1::FldFunG, F2::FldFunG : BaseMorphism := false, Bound := Infinity(), Strategy := "None") -> SeqEnum {Returns a sequence of isomorphisms, extending BaseMorphism if given} intrinsic IsIsomorphic(F1::FldFunG, F2::FldFunG : BaseMorphism := false, Strategy := "None") -> Bool, Map {Returns whether isomorphic (wrt BaseMorphism), and an isomorphism} intrinsic Automorphisms(F::FldFunG : BaseMorphism := false, Bound := Infinity(), Strategy := "None") -> SeqEnum {Returns a sequence of automorphisms, extending BaseMorphism if given} intrinsic AutomorphismGroup(F::FldFunG : BaseMorphism := false, Bound := Infinity(), Strategy := "None") -> GrpFP, Map {The automorphism group of the algebraic function field F, generated by automorphisms which extend BaseMorphism if given} intrinsic Numeration(S::SetEnum) -> Map {Returns a numeration of the finite set S} intrinsic AutomorphismGroup(F::FldFun, f::Map : Strategy := "None") -> Grp, Map, SeqEnum {Returns a representation of the automorphism group of F fixing the constant field through f} Additional intrinsics: ------------------------- intrinsic Conorm(f::Map, P::PlcFunElt) -> DivFunElt {Return conorm of P under f}; intrinsic Conorm(f::Map, D::DivFunElt) -> DivFunElt {Return conorm of D under f}; intrinsic Cotrace(f::Map, D::DiffFunElt) -> DiffFunElt {Return cotrace of D under f}; intrinsic Operation(f::Map, x::Any) -> Any {Return result of operation of automorphism f on object x}; intrinsic FirstPoleElement(D::DivFunElt, P::PlcFunElt) -> RngElt, RngIntElt {Return the first pole element and its pole order wrt D at P} intrinsic FirstPoleElement(P::PlcFunElt) -> RngElt, RngIntElt {Return the first pole element and its pole order at P} intrinsic HasAlmostUniqueLocalUniformizer(D::DivFunElt, P::PlcFunElt) -> Bool, FldFunElt, RngIntElt {Compute an almost unique local uniformizer wrt D at P, if it exists} intrinsic HasAlmostUniqueLocalUniformizer(P::PlcFunElt) -> Bool, FldFunElt, RngIntElt {Compute an almost unique local uniformizer at P, if it exists} intrinsic HasAlmostUniqueLocalParametrization(D::DivFunElt, P::PlcFunElt) -> Bool, UserProgram {Returns the parametrization function wrt D at P, if it exists. The function takes the desired relative precision as second argument} intrinsic HasAlmostUniqueLocalParametrization(P::PlcFunElt) -> Bool, UserProgram {Returns the parametrization function at P, if it exists. The function takes the desired relative precision as second argument} Auxiliary map support: ------------------------- intrinsic Preimage(f::Map, z::Any) -> FldElt {Return preimage of z under f}; intrinsic HasPreimage(f::Map, z::Any) -> Bool, FldElt {Return boolean and preimage of z under f if it exists}; intrinsic HasPreimageFunction(f::Map : Lazy := false) -> Bool, UserProgram {True and the preimage function of f if it cen be determined, false otherwise} intrinsic Image(f::Map, z::Any) -> FldElt {Return image of z under f}; intrinsic HasImage(f::Map, z::Any) -> Bool, FldElt {Return boolean and image of z under f if it exists}; intrinsic ImageFunction(f::Map : Lazy := false) -> UserProgram {The image function of f} Auxiliary intrinsics for field and function field morphisms ------------------------------------------------------------ This is about 78 intrinsics, two of which are intrinsic Top(f::Map) -> Map {The top morphism of the morphism f of morphisms} intrinsic Bottom(f::Map) -> Map {The bottom morphism of the morphism f of morphisms} applicable to function field morphisms. Auxiliary intrinsics fixing some omissions: -------------------------------------------- intrinsic IsPerfect(F::Fld) -> Bool {Return whether field is perfect} intrinsic Degree(F::FldFunRat) -> . {The degree of F over its base, always infinity} intrinsic BaseField(F::FldFin) -> FldFin {The ground field of F} intrinsic BaseField(F::FldFunRat) -> Fld {The base field of F} intrinsic ISABaseField(F::Fld, G::Fld) -> Bool {Whether G is among the (recursively defined) base fields of F} intrinsic Degree(F::Fld, K::Fld) -> . {The degree of F over K} intrinsic IsPrimeField(F::Fld) -> BoolElt {Whether F is a prime field} // version in Magma does not work for higher ranks intrinsic ConstantField(F::FldFunRat) -> Fld {The constant field of F} intrinsic IsSimple(F::FldFun) -> FldFun {} =============================================================================