AATA 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
 
1
def all_sylow(G, p):
2
    '''Form the set of all distinct Sylow p-subgroups of G'''
3
    scriptP = []
4
    P = G.sylow_subgroup(p)
5
    for x in G:
6
        H = P.conjugate(x)
7
        if not(H in scriptP):
8
            scriptP.append(H)
9
    return scriptP

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
G = DihedralGroup(18)
2
S2 = G.sylow_subgroup(2); S2

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
uniqS2 = all_sylow(G, 2)
2
uniqS2

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
len(uniqS2)

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

The Third Sylow Theorem tells us that for

p = 2

we would expect

1, 3

or

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
 
1
G = DihedralGroup(18)
2
S3 = G.sylow_subgroup(3); S3

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
uniqS3 = all_sylow(G, 3)
2
uniqS3

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
len(uniqS3)

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

What does the Third Sylow Theorem predict? Just

1

or

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
 
1
S3.is_normal(G)

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
S3.is_cyclic()

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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

6 = 2 \cdot 3

in

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
 
1
G = DihedralGroup(18)
2
S2 = G.sylow_subgroup(2)
3
S3 = G.sylow_subgroup(3)
4
N2 = G.normalizer(S2); N2

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
N3 = G.normalizer(S3); N3

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
N = G.normalizer(H)
2
N

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
H.is_normal(G)

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
H.is_normal(N)

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
DC=DiCyclicGroup(16)
2
DC.order()

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
DC.is_simple()

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


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

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


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

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages


    
        
xxxxxxxxxx
 
1
HS.is_simple()

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
gap.version()

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
G = gap('Group( (1,2,3,4,5,6), (1,3,5) )')
2
G

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
G.Centralizer('(1, 3, 5)')

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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.


    
        
xxxxxxxxxx
 
1
%gap
2
G := Group( (1,2,3,4,5,6), (1,3,5) );
3
Centralizer(G, (1,3,5));

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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
 
1
print(gap.help('SymmetricGroup', pager=False))

    
    
    
    
        
            
                Language:
                
            
        
    
    




    
    
        
        Messages

🔗

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 ¹⁴ to learn how to get the most out of GAP.

Abstract Algebra: Theory and Applications

Search Results:

Section 15.7 Sage

Subsection Sylow Subgroups

Subsection Normalizers

Subsection Finite Simple Groups

Subsection GAP Console and Interface