Ch12-AutomorphismGroups.html

Groups of automorphisms defined over extensions of the rationals

ŠMike May, S.J., maymk@slu.edu, Saint Louis University

When studying field theory, a standard subject is the group of automorphisms of a field. This worksheet shows how to explore field automorphisms as members of a group. In particular it lets you check relations that the group might satisfy and look at automorphisms as members of the permutaion group acing on the set of roots of a splitting polynomial.

This worksheet presumes that you have worked through the worksheet on Factoring Examples and the worksheet on generating and checking automorphisms before attempting this worksheet.

> restart;

Preliminary work I, setting up the field

As our prime example , we let K be the splitting field of . We obtain K by adjoining to Q both , a primitive third root of unity and cbrt2, a cube root of 2. (If you want to change fields, you need to modify this section and re-execute the code. You may want to look at the help file for RootOf, alias, and factor.)

> alias(omega=RootOf(x^2 + x + 1), cbrt2=RootOf(x^3 -2));
factor(x^2 + x + 1, omega);
factor(x^3 -2, {cbrt2, omega});

Automorphisms can be defined by what they do to a set of generators of the field. We want to keep track of what happens to the obvious generating set, and what happens to the roots of the splitting polynomial.

> genvector := [omega, cbrt2];
genlength := 2;
rootvector := simplify([cbrt2, omega * cbrt2, omega^2 * cbrt2]);

The method we are using to define and check automorphisms uses the fact that an automorphism is defined by its action on the vector of generators of the field. Following that convention, we define an automorphism by giving the vector of images of the generators. For our basic example, we now define our two obvious automorphisms, , which fixes the cube root of 2 and takes to , and , which fixes and takes the cube root of 2 to times the cube root of 2.

> alpha := simplify([omega^2, cbrt2]);
beta := simplify([omega, omega * cbrt2]);

Preliminary work II, Defining composition of automorphisms

We now need a procedure for applying an automorphism to a vector.

>    compose := proc(images, arguments)
     local substitutions, i, j, temp;
     if 2 < nargs then
         temp := args[nargs];
         for j from 2 to nargs do
            temp := compose(args[nargs - j + 1], temp);
         od;
     else
         substitutions := {};
         for i from 1 to genlength do
           substitutions := substitutions union {genvector[i] = images[i]};
         od;
         simplify(subs(substitutions, arguments));fi;
end:

This procedure actually lets us apply a series of automorphisms to a vector.

> compose(alpha, rootvector);
compose(beta, beta, rootvector);

It will be useful to also define a function that lets us take the power of an automorphism

>    power := proc(images, expon)
     local i, j, temp;
     if expon < 0 then
         print(`error, exponent must be a nonnegative integer`);
     elif expon = 0 then
         temp := genvector;
     elif expon = 1 then
         temp := images;
     elif expon = 2 then
         temp := compose(images, images);
    else
         temp := compose(images, images);
         for i from 3 to expon do
           temp := compose(images, temp);
         od;
   fi;
end:

>

Checking the order of an automorphism

As we start looking at automorphisms as elements of a group, the first task is to look at the order of an automorphism.

We start with the automorphism of K = Q[ , cbrt2] over Q. Recall that takes to and fixes cbrt2.

> alpha := simplify([omega^2, cbrt2]);
genvector := [omega, cbrt2]; genlength := 2;
rootvector := simplify([cbrt2, omega * cbrt2, omega^2 * cbrt2]);

The straightforward way is find the order of uses the fact that the order of a group is at least as big as the order of any element in the group. There are at most 6 automorphism for this field. We can simply look at the first 6 powers of and visually check to see which is the first power equal to the identity. We recall that the identity fixes the generators, so it will be defined by genvector.

> for i from 1 to 6 do
print(i, power(alpha, i));
od;

Thus we see that has order 2. With a little work we can get maple to find the order for us.

>    i := 0: temp := genvector:
  print(i, temp);
  for i from 1 to 6 do
      temp := power(alpha, i):
      print(i, temp);
      if temp = genvector then
         print (`The order if alpha is `||i);
         break fi:
  od:

Exercises

1) Find the order of and .

2) Let L be the splitting field of . L can be defined by adjoining , a primitive fifthe root of unity, and fifthrt3, a fifth root of 3, to Q. Define a nontrivial automorphism on L over Q. Use modifications of the code about to find the order of your automorphism.

Exploring the galois group

Using the procedures defined above, consider the compositions.

>    print('alpha','alpha',compose(alpha, alpha));
  print('beta','beta',compose(beta, beta));
  print('beta','beta', 'beta', compose(beta, compose(beta, beta)));
  print('beta','beta', 'beta',compose(beta, beta, beta));
  print('beta','alpha',compose(beta, alpha));
  print('beta', 'beta', 'alpha',compose(beta, beta, alpha));
  print('alpha','beta', 'alpha',compose(alpha, beta, alpha));
  print('alpha','beta',compose(alpha, beta));

It is clear from the above results that the order of is 2, the order of is 3, and that is the same as . That is enough to let us deduce that the

Galois group of Q [ , cbrt2] over Q is = < | e = = , >.

Exercise:

3) Change the field above to, L = Q [ fifthrt3], the splitting field of x^5 -3. Let be the automorphism the sends to and fixes fifthrt3. Let be the automorphism that fixes and sends fifthrt3 to fifthrt3. Find the a set of relations satisfied by and that let you define the galois group in terms of those relations. (You will be done if you find the orders of alpha and beta and a rule to commute alpha with beta. Remember to reset the field when you are done.)

>

Automorphisms as permutations of roots

If we are to look at the group of automorphisms of a field, we may want to represent them as permutations acing on the vector of roots of a splitting polynomial. For our example we recall the splitting polynomial x^3 -2, and its vector of roots.

>    factor(x^3 -2, {cbrt2, omega});
  genvector := [omega, cbrt2]; genlength := 2;
  rootvector := simplify([cbrt2, omega * cbrt2, omega^2 * cbrt2]);
  rootlength := 3;

We also recall our generating automorphisms

> alpha := simplify([omega^2, cbrt2]);
beta := simplify([omega, omega * cbrt2]);

Finally we produce a procedure to convert an automorphism into a group permutaion.
The procedure assumes that rootvector, rootlength, and compose from above are all defined.

>    makeperm := proc(auto, rootvector)
  local temp, destin, i, j, rtlength;
  temp := expand(compose(auto, rootvector));
  rtlength := linalg[vectdim](rootvector);
  destin := array(1 .. rtlength);
  for i from 1 to rtlength do
    for j from 1 to rtlength do
      if temp[i] = expand(rootvector[j]) then
        destin[i] := j;
        break;
      fi;
    od;
    if j = rtlength + 1 then
        print(`Error, The automorphism did not permute the given roots`);
        print(rootvector[i], ` was sent to `, temp[i]);
        break;
    fi;
  od;
  convert(destin, list);
  end:

> permrepa := makeperm(alpha, rootvector);
permrepb := makeperm(beta, rootvector);

Notice that if we try a nonisomophism, the procedure will give an error message because we are not permuting the roots. Consider the potential map that sends to and fixes cbrt2. This map is not a homomorphism.

> makeperm([omega + 1, cbrt2], rootvector);

We can convert from permlist notation to disjoint cycle notatio n, and use Maple's group package to look at the group more closely.

> with(group):
cyclerepa := convert(permrepa, 'disjcyc');
cyclerepb := convert(permrepb, 'disjcyc');
GalGrp := permgroup(5, {cyclerepa, cyclerepb});
grouporder(GalGrp);

Exercise:

4) Represent the Galois group of L, the splitting field of over Q as a group of permutations on the roots of .