Ch13-DefiningAutomorphisms.html

Defining and Checking Automorphisms

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

> restart;

As we move through Galois theory, we will be looking at the group, G, of automorphisms of a field extension, K/F. Unfortunately, for students learning field theory, it is often hard to identify what the allowable automorphisms are. This makes looking at properties of the group of automorphisms a near impossible task.

This worksheet uses Maple to test proposed automorphisms for finite extensions of the rationals. You should probably have worked through the worksheet on Factoring Examples before attempting this worksheet.

Set up

For this worksheet, we will restrict to the case where F is the field of rationals and K is a finite extension of F. Then K = F[ , ..., ] with algebraic over F. To each generator , we associate its minimal polynomial . An automorphism in G can be defined by giving the images , ..., of the field generators , ..., . The question of listing automorphisms in G then reduces to finding the acceptable sets of images of the generators.

Our prime examples will look at the fields obtained by adjoining roots to the polynomial . We will focus first on the particular case when p is 3 and q is 2. Thus we look at the field obtained by adjoining , a primitive cube root of unity, and cbrt2, a cube root of 2, to the rationals.

To check if proposed image sets define an automorphism we will need the Maple commands factor, alias, RootOf, and subs. You may want to look at the help files for these commands.

Factoring and Aliases

We start by defining and cbrt2, then factoring the polynomials and over a number of fields.

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

> factor(x^3 - 1);
factor(x^3 - 2);

> factor(x^3 - 1, omega);
factor(x^3 - 2, omega);

> factor(x^3 - 1, cbrt2);
factor(x^3 - 2, cbrt2);

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

Notice that Maple will factor over extension fields, using the second argument of the factor command as a list of algebraic expressions to be adjoined to the base field of the rationals.

>

Substitution with a factored polynomial

We start by redefining the polynomials in out example.

> f[1] := x^2 + x + 1;
f[2] := x^3 -2;

To use a proposed automorphism, we want to be able to replace a generator with an arbitrary image. The command

subs( = , expression);
replaces with in expression. We are particularly interested in doing this when is one of the field generators and the expression is the minimum polynomial of .

> g[1] := factor(f[1], {omega, cbrt2});
g[2] := factor(f[2], {omega, cbrt2});

> h[1] := subs(omega = -(1 + omega), g[1]);
h[2] := subs(omega = -(1 + omega), g[2]);

It is clear that the substitution process has left unchanged. The substitution simply switched the factors. Straightforward algebra verifies that the same is true for . Unfortunately, it is not true that the algebra will always be straightforward. Thus we want Maple to simplify and refactor for us.

> factor(simplify(h[1]), {omega, cbrt2});
factor(simplify(h[2]), {omega, cbrt2});

>

Choosing images for an automorphism

In the example above we noted that the substitution left the polynomials over F unchanged. To do that we needed to send each to an element of K that is a root of the same irreducible polynomial. (We factored the polynomials over K so that we could see the possible images for our generators.)

Consider the case of our favorite example. The field K is obtained by adjoining and cbrt2, roots of and , to the rationals. (In fact, these polynomials split over K.) Sin ce has 2 roots in K and has 3 roots in K, we have 6 possible automorphisms of K over F.

Exercises:

1) List the 6 possible automorphisms of K over Q when K = Q[ , cbrt2].

2) Let K be the splitting field of . K is obtained by adjoining roots of and to Q. Describe the 20 possible automorphisms of K over Q.

3) In contrast, the splitting field of does not have 12 automorphisms over Q. Explain why.

Working through a particular case

Let us focus on the potential automorphism that takes to and takes cbrt2 to cbrt2. We want to verify that this substitution simply permutes the factors of the factored forms of the minimal polynomials.

> h[1] := subs(omega = -(1 + omega), cbrt2 = cbrt2 * omega, g[1]);
h[2] := subs(omega = -(1 + omega), cbrt2 = cbrt2 * omega, g[2]);

> h[2] := factor(simplify(h[2]), {omega, cbrt2});

> rootarray := [1, omega, omega^2, cbrt2, cbrt2 * omega, cbrt2 * omega^2];
rootarray2 := subs(cbrt2=omega*cbrt2, omega=omega^2, rootarray);
rootarray3 := simplify(rootarray2);

> g[1] := factor(f[1], {omega, cbrt2});
g[2] := factor(f[2], {omega, cbrt2});

Once again we need to simplify the second equation.

The same sequence of commands, subs followed by simplify, lets us check the action of an automorphism on particular elements of a field. Consider the action on rootarray, an array of the roots of and .

To make the comparison easier, apply simplify to rootarray as well.

> rootarray1 := simplify(rootarray);

It is now clear that our action automorphism simply rearranged rootarray, as expected.

Exercises:

4) Pick another nontrivial automorphism of K = Q[ , cbrt2] over Q. Show that your automorphism simply rearranges the roots of and .

5) Define a nontrivial automorphism on the splitting field of x^5 - 3. Verify that the map permutes the roots of and of .

>

Verifying that a map is a ring homomorphism

The method we have been using to "define automorphisms", actually defines a homomorphsim of the additive group of the field. (It is defined on products of the generators and extended by linearity.) To check that we are defining a field automorphism, we need to check that the map respects multiplication. (We need to check that we get the same answer whether we simplify a product before or after performing the map. ) Since the map is defined to respect addition, it suffices to check this with the products of the powers of the generators, with the power of each generator less than or equal to its degree.

In our case, with K = Q[ , cbrt2], the degree of each generator is the same whether or not the other generators have been adjoined to the field. This means that we only need to consider powers of generators and not products.

We want to set up a procedure to systematically check if a proposed map respects multiplication and is this an automorphism.

To define the map we need the generators of the field and their images. That lets us define the substitutions. We also want a list of the powers of the generators.

> gens := [omega, cbrt2];
imgens := [omega^2, omega*cbrt2];
substitutions := {gens[1] = imgens[1], gens[2] = imgens[2]};
genarray := [omega, omega^2, cbrt2, cbrt2^2, cbrt2^3];

$substitutions := {omega = omega^2, cbrt2 = cbrt2*omega}$

Next, we want 2 functions, one that simplifies only after substituting, and one that simplifies, then substitutes, then simplifies.

> phi1 := (a, b) -> simplify(subs(a, b)):
phi2 := (a, b) -> simplify(subs(a, simplify(b))):

Finally we want to apply the substitutions to the list of elements and compare the results. If the 2 lists agree we have an automorphism.

>    genarray1 := phi1(substitutions, genarray);
  genarray2 := phi2(substitutions, genarray);
  print (`Using the substitutions`);
  print (substitutions);
  if genarray1 = genarray2
     then print (`phi is an automorphism`);
     else print (`phi is NOT an automorphism`);
         fi:

${omega = omega^2, cbrt2 = cbrt2*omega}$

It is useful to note that if we change the substitutions beyond the 6 canditdates, we see that we have not defined an automorphism.

>    gens := [omega, cbrt2];
imgens := [omega^3, omega*cbrt2];
substitutions := {gens[1] = imgens[1], gens[2] = imgens[2]};
genarray1 := phi1(substitutions, genarray);
  genarray2 := phi2(substitutions, genarray);
  print (`Using the substitutions`);
  print (substitutions);
  if genarray1 = genarray2
     then print (`phi is an automorphism`);
     else print (`phi is NOT an automorphism`);
         fi:

$substitutions := {omega = omega^3, cbrt2 = cbrt2*omega}$

${omega = omega^3, cbrt2 = cbrt2*omega}$

>

Non-examples, Traps, and Warnings

1) We pointed out above that we only get an automorphism when we send roots to roots. It should be noted that the subs command works with any image. If we define an the image of a root to be anything other than a root of the same minimum polynomial, the map cannot be extended to a ring homomorphism.

2) The procedure defined above properly checks to see if the map defined by sending the generators to specified images can be extended to a homomorphism. It does not check that the map is to the same field. In particular we can define the obvious map from Q[cbrt2] to Q[ cbrt2]. It will be an isomorphism of fields but not an automorphism. Note that (x - cbrt2) is not a linear factor of over Q[cbrt2].

> factor(x^3 -2, cbrt2);

3) Maple's subs command is easily confused by defining substitutions that do no use the generators, even if they define equivalent homorphisms. Our procedure will not reliably check an action on the field generated by w if the action is defined in terms of even though the field generated by is also the field generated by . To check that action, we need to define the field of coeficients in terms of .

Notice that the substitution taking to 12 is not an isomorphism, and that, the field generated by is the same as the field generated by .

>
f1 := x^2 + x + 1;
g1 := factor(f1, {omega});
h1 := subs(omega=12, g1);
g2 := factor(f1, {(-3)^(1/2)});
h2 := subs(omega=12, g2);

4) We obtained the splitting field of x^3 -2 by adjoining a root for each of 2 polynomials. The other approach is to adjoin several roots to x^3-2. We can do that by adjoining a root to the irreducible part left over after adjoining the first part and factoring.

> f := x^3 -2;
alias(alpha=RootOf(f));
factor(f, alpha);
g := simplify(f/(x-alpha));
alias(beta = RootOf(g));
factor(f, [alpha, beta]);