AATA Sage

Section 15.7 Sage

Subsection Sylow Subgroups

The Sage permutation group method .sylow_subgroup(p) will return a single Sylow

p

-subgroup. If the prime is not a proper divisor of the group order it returns a subgroup of order

p^{0},

in other words, a trivial subgroup. So be careful about how you construct your primes. Sometimes, you may only want one such Sylow subgroup, since any two Sylow

p

-subgroups are conjugate, and hence isomorphic (Theorem 15.7). This also means we can create other Sylow

p

-subgroups by conjugating the one we have. The permutation group method .conjugate(g) will conjugate the group by g.

🔗

With repeated conjugations of a single Sylow

p

-subgroup, we will always create duplicate subgroups. So we need to use a slightly complicated construction to form a list of just the unique subgroups as the list of conjugates. This routine that computes all Sylow

p

-subgroups can be helpful throughout this section. It could be made much more efficient by conjugating by just one element per coset of the normalizer, but it will be sufficient for our purposes here. Be sure to execute the next cell if you are online, so the function is defined for use later.

xxxxxxxxxx
 
def all_sylow(G, p):
    '''Form the set of all distinct Sylow p-subgroups of G'''
    scriptP = []
    P = G.sylow_subgroup(p)
    for x in G:
        H = P.conjugate(x)
        if not(H in scriptP):
            scriptP.append(H)
    return scriptP

🔗

Lets investigate the Sylow subgroups of the dihedral group

D_{18} .

As a group of order

36 = 2^{2} \cdot 3^{2},

we know by the First Sylow Theorem that there is a Sylow

2

-subgroup of order

4

and a Sylow

3

-subgroup of order

9 .

First for

p = 2,

we obtain one Sylow

2

-subgroup, form all the conjugates, and form a list of non-duplicate subgroups. (These commands take a while to execute, so be patient.)

xxxxxxxxxx
 
G = DihedralGroup(18)
S2 = G.sylow_subgroup(2); S2

xxxxxxxxxx
 
uniqS2 = all_sylow(G, 2)
uniqS2

xxxxxxxxxx
 
len(uniqS2)

🔗

The Third Sylow Theorem tells us that for

p = 2

we would expect

1, 3

9

Sylow

2

-subgroups, so our computational result of

9

subgroups is consistent with what the theory predicts. Can you visualize each of these subgroups as symmetries of an

18

-gon? Notice that we also have many subgroups of order

2

inside of these subgroups of order

4 .

🔗

Now for the case of

p = 3 .

xxxxxxxxxx
 
G = DihedralGroup(18)
S3 = G.sylow_subgroup(3); S3

xxxxxxxxxx
 
uniqS3 = all_sylow(G, 3)
uniqS3

xxxxxxxxxx
 
len(uniqS3)

🔗

What does the Third Sylow Theorem predict? Just

1

4

Sylow

3

-subgroups. Having found just one subgroup computationally, we know that all of the conjugates of the lone Sylow

3

-subgroup are equal. In other words, the Sylow

3

-subgroup is normal in

D_{18} .

Let us check anyway.

xxxxxxxxxx
 
S3.is_normal(G)

🔗

At least one of the subgroups of order

3

contained in this Sylow

3

-subgroup should be obvious by looking at the orders of the generators, and then you may even notice that the generators given could be reduced, and one is a power of the other.

xxxxxxxxxx
 
S3.is_cyclic()

🔗

Remember that there are many other subgroups, of other orders. For example, can you construct a subgroup of order

6 = 2 \cdot 3

D_{18} ?

🔗

Subsection Normalizers

🔗

A new command that is relevant to this section is the construction of a normalizer. The Sage command G.normalizer(H) will return the subgroup of G containing elements that normalize the subgroup H. We illustrate its use with the Sylow subgroups from above.

xxxxxxxxxx
 
G = DihedralGroup(18)
S2 = G.sylow_subgroup(2)
S3 = G.sylow_subgroup(3)
N2 = G.normalizer(S2); N2

xxxxxxxxxx
 
N2 == S2

xxxxxxxxxx
 
N3 = G.normalizer(S3); N3

xxxxxxxxxx
 
N3 == G

🔗

The normalizer of a subgroup always contains the whole subgroup, so the normalizer of S2 is as small as possible. We already knew S3 is normal in G, so it is no surprise that its normalizer is as big as possible — every element of G normalizes S3. Let us compute a normalizer in

D_{18}

that is more “interesting.”

xxxxxxxxxx
 
G = DihedralGroup(18)
a = G("(1,7,13)(2,8,14)(3,9,15)(4,10,16)(5,11,17)(6,12,18)")
b = G("(1,5)(2,4)(6,18)(7,17)(8,16)(9,15)(10,14)(11,13)")
H = G.subgroup([a, b])
H.order()

xxxxxxxxxx
 
N = G.normalizer(H)
N

xxxxxxxxxx
 
N.order()

🔗

So for this subgroup of order

6,

the normalizer is strictly bigger than the subgroup, but still strictly smaller than the whole group (and hence not normal in the dihedral group). Trivially, a subgroup is normal in its normalizer:

xxxxxxxxxx
 
H.is_normal(G)

xxxxxxxxxx
 
H.is_normal(N)

🔗

Subsection Finite Simple Groups

🔗

We saw earlier Sage’s permutation group method .is_simple(). Example 15.16 tells us that a group of order

64

is never simple. The dicyclic group DiCyclicGroup(16) is a non-abelian group of

64,

so we can test this method on this group. It turns out this group has many normal subgroups — the list will always contain the trivial subgroup and the group itself, so any number exceeding

2

indicates a non-trivial normal subgroup.

xxxxxxxxxx
 
DC=DiCyclicGroup(16)
DC.order()

xxxxxxxxxx
 
DC.is_simple()

xxxxxxxxxx
 
ns = DC.normal_subgroups()
len(ns)

🔗

Here is a rather interesting group, one of the

26

sporadic simple groups, known as the Higman-Sims group,

H S .

The generators used below come from the representation on 100 points in GAP format, available off of web.mat.bham.ac.uk/atlas/v2.0/spor/HS/

¹³

web.mat.bham.ac.uk/atlas/v2.0/spor/HS

. Two generators of just order

2

and order

5

(as you can esily see), generating exactly

44 352 000

elements, but no normal subgroups. Amazing.

xxxxxxxxxx
 
G = SymmetricGroup(100)
a = G([(1,60),  (2,72),  (3,81),  (4,43),  (5,11),  (6,87),
        (7,34),  (9,63),  (12,46), (13,28), (14,71), (15,42),
        (16,97), (18,57), (19,52), (21,32), (23,47), (24,54),
        (25,83), (26,78), (29,89), (30,39), (33,61), (35,56),
        (37,67), (44,76), (45,88), (48,59), (49,86), (50,74),
        (51,66), (53,99), (55,75), (62,73), (65,79), (68,82),
        (77,92), (84,90), (85,98), (94,100)])
b = G([(1,86,13,10,47),  (2,53,30,8,38),
        (3,40,48,25,17),  (4,29,92,88,43),   (5,98,66,54, 65),
        (6,27,51,73,24),  (7,83,16,20,28),   (9,23,89,95,61),
        (11,42,46,91,32), (12,14, 81,55,68), (15,90,31,56,37),
        (18,69,45,84,76), (19,59,79,35,93),  (21,22,64,39,100),
        (26,58,96,85,77), (33,52,94,75,44),  (34,62,87,78,50),
        (36,82,60,74,72), (41,80,70,49,67),  (57,63,71,99,97)])
a.order(), b.order()

xxxxxxxxxx
 
HS = G.subgroup([a, b])
HS.order()

xxxxxxxxxx
 
HS.is_simple()

🔗

We saw this group earlier in the exercises for Chapter 14 on group actions, where it was the single non-trivial normal subgroup of the automorphism group of the Higman-Sims graph, hence its name.

🔗

Subsection GAP Console and Interface

🔗

This concludes our exclusive study of group theory, though we will be using groups some in the subsequent sections. As we have remarked, much of Sage’s computation with groups is performed by the open source program, “Groups, Algorithms, and Programming,” which is better know as simply GAP. If after this course you outgrow Sage’s support for groups, then learning GAP would be your next step as a group theorist. Every copy of Sage includes a copy of GAP and is easy to see which version of GAP is included:

xxxxxxxxxx
 
gap.version()

🔗

You can interact with GAP in Sage in several ways. The most direct is by creating a permutation group via Sage’s gap() command.

xxxxxxxxxx
 
G = gap('Group( (1,2,3,4,5,6), (1,3,5) )')
G

🔗

Now we can use most any GAP command with G, via the convention that most GAP commands expect a group as the first argument, and we instead provide the group by using the object-orientedG. syntax. If you consult the GAP documentation you will see that Center is a GAP command that expects a group as its lone argument, and Centralizer is a GAP command that expects two arguments — a group and then a group element.

xxxxxxxxxx
 
G.Center()

xxxxxxxxxx
 
G.Centralizer('(1, 3, 5)')

🔗

If you use the Sage Notebook interface you can set the first line of a compute cell to %gap and the entire cell will be interpreted as if you were interacting directly with GAP. This means you would now use GAP’s syntax, which you can see above is slightly different than Sage’s universal syntax. You can also use the drop-down box at the top of a worksheet, and select gap as the system (rather than sage) and your whole worksheet will be interpreted as GAP commands. Here is one simple example, which you should be able to evaluate in your current worksheet. This particular example will not run properly in a Sage Cell in a web page version of this section.

🔗

Notice that

We do not need to wrap the individual permutations in as many quotation marks as we do in Sage.
Assignment is := not =. If you forget the colon, you will get an error message such as Variable: 'G' must have a value
A line must end with a semi-colon. If you forget, several lines will be merged together.

🔗

You can get help about GAP commands with a command such as the following, though you will soon see that GAP assumes you know a lot more algebra than Sage assumes you know.

xxxxxxxxxx
 
print(gap.help('SymmetricGroup', pager=False))

🔗

In the command-line version of Sage, you can also use the GAP “console.” Again, you need to use GAP syntax, and you do not have many of the conveniences of the Sage notebook. It is also good to know in advance that quit; is how you can leave the GAP console and get back to Sage. If you run Sage at the command-line, use the command gap_console() to start GAP running.

🔗

It is a comfort to know that with Sage you get a complete copy of GAP, installed and all ready to run. However, this is not a tutorial on GAP, so consult the documentation available at the main GAP website: www.gap-system.org

¹⁴

/www.gap-system.org

to learn how to get the most out of GAP.

Prev Top Next