Magma tutorial
Thursday, February 22, 2007
Dave Swinarski

Thanks for coming today.  I'll show you how I use Magma to study representations of automorphisms of curves.  (So I guess at the outset I'm revealing that Magma has a lot of functions for dealing with number fields, function fields, commutative algebra, algebraic geometry, group theory, and representation theory!)  To me, the punchline to is that there are some calculations that should never be done by hand again, but I'll leave you to draw your own conclusions.  

Getting started: First, find the Magma webpage (google magma computer algebra).  The instructions are generally pretty clear and there are lots of mini-tutorials along the way.  

Opening the program: we only have four licenses for the latest version of Magma (the one that includes packages for automorphisms of curves).  It's available on cpw (don't run it there though), fifthave (Danny's computer), neo2 (I have no idea where that one is), and video (the fastest computer with the most memory in our department).  The old version of Magma is available on every Linux computer.  To start it up:

On video, fifthave or neo2: magma
On cpw (only for short tests!): magma-p3
All others only run old version: magma-2.11

Log in to video and start it up.  The opening screen tells you what version you're running.  You should see V2.13-9.  

Let's start with some algebraic geometry.  You can cut and paste the commands listed below into the terminal shell to run them:

Let's build P^2_Q with coordinates x,y,z:

Q:=RationalField();
PQ<x,y,z>:=ProjectiveSpace(Q,2);

Generally Magma commands are pretty self-explanatory.  Note the syntax.  Declarations are made using := and statements must end with a semicolon or else Magma thinks you're not done yet.  

First let's study the curve 48b) from the list of genus 3 curves with automorphisms:

C:=Curve(PQ,y^3*z-x^4+z^4);
ArithmeticGenus(C);
IsNonsingular(C);

Next let's study the automorphism group:
AutC:=AutomorphismGroup(C);
Order(AutC);

Let's change our field to one where we can see all the automorphism groups.  It turns out that we need i and a third root of unity.

K<w>:=CyclotomicField(12);
Notice I've assigned the name w to exp^(2 pi i/12)

C:=BaseChange(C,K);
In case you're ever wondering what you've got, just ask:
C;


AutC:=AutomorphismGroup(C);
This doesn't take too long, but be warned--for the Fermat quartic x^4+y^4+z^4 defined over CyclotomicField(4) this would have taken 10 minutes!

Type(AutC);

Notice that AutC is currently of type GrpAutCrv.  There aren't very many functions available for studying groups like this, you can get the order
Order(AutC);
Generators(AutC);
and that's about it (and do you really even understand the output of Generators, apart from the fact that there are two of them?), so let's promote it to another type.  

PermAutC,p:=PermutationRepresentation(AutC);

Note this command took two arguments, and it constructed a group PermAutC an isomorphism p: AutC -> PermAutC.

Let's study the group a little more:

IsAbelian(PermAutC);
IsIsomorphic(PermAutC,DirectProduct(SymmetricGroup(4),CyclicGroup(2)));
Generators(AutC);
Center(PermAutC);

OK so it's not an "obvious" group of order 48 (turns out it's a semidirect product of smaller things...)  Let's get its character table:

CharacterTable(PermAutC);

Now we see more details about the structure of the group, namely the number of conjugacy classes and their orders, and all the irreducible characters.  

Note I and J in the character table are not ambiguous.  But what is Z1?  Let's ask Magma.  Note I had to add a colon to the line I saw on the screen to make it a declaration.

Z1 := (CyclotomicField(12: Sparse := true)) ! [ RationalField() | 0, 1, 0, 1 ];
Modulus(Z1);
Argument(Z1);
Z1^12;
Argument(Z1)*12/(2*3.14159);

So Z1 is really exp^{10 pi i /12}.  Real mathematicians could have probably worked that out by understanding what the command defining Z1 actually says, but I've never bothered to do this.  

Now that we understand AutC and its character theory, let's study its representation on H^0(K).  Unfortunately, Magma doesn't already do this when we construct AutC--the maps displayed when we did Generators(AutC) were not linear automorphisms of P^2.  

I'll be nice and just give you the right answer:

GL3K:=GeneralLinearGroup(3,K);
g:=elt<GL3K| w^5,0,0, 0,1-w^10,0, w^3,0,w^9>;
h:=elt<GL3K | w^2-1, 0,1, 0,1,0, w^2-1, 0, -w^2+1>;
G:=sub<GL3K | g,h>;
Order(G);
IsIsomorphic(G,PermAutC);

Note how much fun we can have playing with matrix groups in Magma.  
Determinant(g);
Trace(g);
Order(g);

X:=CharacterTable(G);

Magma also has lots of functions for studying representations of finite groups.  Let's do a little of this now:

GMod:=GModule(G);
chi:=Character(GMod);
Decomposition(X,chi);
Comparing the output to the character table, we see that actually the representation decomposes as a sum of a one dimensional irreducible and a two dimensional irreducible.  
What is the basis with respect to which H^0(K) decomposes as a direct sum of irreducibles?  For this we use the projection formula (Fulton-Harris Representation Theory 2.32 page 23).  

A few notes before I go into the formula:

It's useful to index the elements of the group.  We can use NumberingMap to do this.

The character table is stored as an array, so X[4][7] is the value of the irreducible X[4] on conjugacy class 7, that is, -1.  

Note that so far, all of our matrices are elements of a general linear group; in particular, Magma thinks they're group elements, and doesn't realize they also live in a ring and can be added.  The command Matrix jolts Magma into figuring out what ring it can add them in (here, M_3x3).      

Now we can write a little program to get an element of H^0(K) which generates the irreducible X4.  Copy and paste these lines one at a time

  

f:=Inverse(NumberingMap(G));
M:=ZeroMatrix(K,3,3);

for i:=1 to 48 do
M:=M + ComplexConjugate(KnownIrreducibles(G)[4](f(i)))*Matrix(f(i));
end for;

M;
 






This ends the cut and paste commands.  Here are some exercises for you, or create your own depending on your own taste and interests!

1. Which conjugacy classes do the generators g and h of G belong to, as given by the character table of G? 

2. Find basis elements of H^0(K) that give the irreducible representation X[12].  

3. How many nonabelian groups of 48 are there?  Write a function to search the library of small groups and count them.  This is a little evil since I didn't teach you how to write functions, but give it a try for 5 minutes and then ask me.  Which of these are automorphism groups of genus 3 curves?  (Think back to my talk last week...)

4. Study the curve given by the following equation, which is hyperelliptic and has 16 automorphisms:   y^2 = x^8 + 6x^4 + 1.  What is the field of definition?  Get the group and the character table.  What are all the irreducible representations?  (Hint: look at the manual under "action generators")

5.  In his first of many papers Kuribayashi does not give nice matrix generators for representations of the automorphism groups.  For instance, the generators for the Fermat quartic actually give a group of order 384; when you quotient out by homotheties, you get a group of order 96, which is correct.  Show that just taking the det = 1 elements in their list gives the correct representation (i.e. the extension is trivial).  

The situation is worse for the curve 48b).  Try to decipher what they claim are the generators, and then observe that these give a nontrivial Z/3Z extension of the true automorphism group.  When you quotient by homotheties, you get the automorphism group; this tells you the order of the automorphism group, but not (? I think) the representation.  

6.  In Magma you can create a vector space of holomorphic differentials, and a basis for it.  If you have the automorphism group, do you automatically get an action on it?  Can you use this to work out the representation of AutC on H^0(K)?  What about on H^0(2K)?  (I tried this, but I can't remember whether I got it to work.)