`[A5, A5] = A5`

, thereby proving that `A5`

not solvable.
This is useful for Galois theory, where we want to show tha `A5`

cannot be
built as extensions of smaller cyclic groups.
`(12);(34)`

means 'perform `(12)`

then perform `(34)`

'.
I find this notation makes permutation composition intuitive for me. The `;`

is evocative of C-style languages, where we are ending a statement. I will
be consistently using $[g, h] \equiv ghg^{-1}h^{-1}$ to denote the commutator.
`A5`

only has the `S5`

. So it can
have zero, two, four, involutions that build it up. There can't be more after
simplification, since `S5`

ony has `5`

elements --- the largest sequence
of transpositions we can do is `(12)(23)(34)(45)`

. So, in `A5`

, we have:
- The identity permutation
`()`

. - The transpositions
`(ij)(kl)`

where`{i, j}`

and`{k, l}`

do not overlap. From these, we get the 2-cycles. - The transpositions
`(ij)(kl)`

where`{i, j}`

and`{k, l}`

overlap. Here we cannot have`{i, j} = {k, l}`

since then we will just have a single transposition. So, let us assume that we have`j = k`

. If we have any other equality, we can always flip the transpositions around to get to the normal form`j = k`

:

```
(23);(12)
= (32);(12) [(23) = (32)]
= (32);(21) [(12) = (21)]
```

- In this case, we can show that such a transposition
*must*be a cycle:

```
[a b c] -(32)->
[a c b] -(21)->
[c a b]
```

- Intuitively, we are pushing the element
`c`

backward, and allowing the other elements to take its place using the permutation`(23);(12)`

.

- So, from the transpositions of the form
`(ij)(kl)`

where`{i, j}`

and`{k, l}`

intersect, we get the 3-cycles.

- Finally, we can have the transpositions of the form
`(12)(23)(34)(45)`

. It must be of this form, or some permutation of this form. Otherwise, we would have repeated elements, since these transpositions are packed "as close as possible". These generate the 5-cycles.

- The disjoint transpositions of the type
`(34)(12)`

can be written as`(34)(23)(23)(12)`

, because`(23)(23) = e`

. This can be further broken down into`((34)(23)) ((23)(12))`

which is two 2-cycles:`(234); (123)`

.

- The non-disjoint transpositions of the type
`(32)(21)`

*are*3-cycles:`(32)(21) = (123)`

.

- 3-cycles are 3-cycles.

- Any 5-cycle an be written as two 3-cycles:
`(45)(34)(23)(12)`

can be written as`((45)(34))((23)(12))`

which is two 3-cycles:`(345); (123)`

.

- We saw how we can write a 3-cycle of the form
`C = (123)`

as`(32)(21)`

. We wish to write this as the commutator of two elements`g, h`

: $C = [g, h]$.

- The idea is that we have the leftover elements
`4, 5`

that are unsused by`C`

in`A5`

[here is where`5`

is important:`3 + 2 = 5`

, and we need two leftover elements ].

- We can use these two leftover elements
`4, 5`

to build elements`g, h`

which cancel off, leaving us with`(32)(21)`

. We start with`g = (32)___`

,`h = (21)___`

where the`___`

is to be determined:

```
(32)___||(21)___||___(32)||___(21)
g h g^-1 h^-1
```

- It is important that
`g`

and`h`

contain another tuple, because they are members of`A5`

! We need them to be permutations having`2, 4, 6`

transpositions. - We insert
`(4 5)`

everywhere. These`(4 5)`

can slide over the`(2 1)`

and thereby harmlessly cancel:

```
(32)(45)||(21)(45)||(45)(32)||(45)(21)
g h g^-1 h^-1
```

- Simplify the above expression by moving the
`(45)`

over`(21), (32)`

:

```
(32)||(21)(45)(45)||(32)||(45)(45)(21)
g h g^-1 h^-1
```

- cancel the
`(45)(45) = e`

:

```
(32)||(21)||(32)||(21)
g h g^-1 h^-1
```

So we are left with `(32);(21);(32);(21)`

. This is the `C = (32);(21)`

. However, since `C`

is a 3-cycle, we know
that $C = C^{-2}$. So, we can start with $C^{-1}$, use our trick to generate
$C^{-2}$ which is equal to $C$. Since this works for any $C$, we have shown
that we can generate 3-cycles from commutators of `A5`

.
`s = (a b c)`

. We first first a square root `t`

such
that `t*t=s`

. To do this, we make `t`

have the cycles of `s`

spread out
in gaps of 2:
```
t = (a _ _)
t = (a _ b) [+2]
t = (a c b) [+2, modulo]
```

It is hopefully clear that `t*t = s`

:
```
t = (a c b)
t*t: apply the cycle twice.
t*t = a -(skip c) -> b
b -(skip a) -> c
c ->(skip b) -> a
= (a b c) = s
```

Now, we will write `s = t*t`

and then find the commutator decomposition from
it:
```
s = t*t
= (abc)(abc)
= (cb)(ba)(cb)(ba)
= (cb)|(ba)|(cb)|(ba)
= (cb)|(ba)|(cb)|(ba)
g h g-1 h-1
```

But there's a problem: this `g`

and `h`

do not belong to `A5`

, they belong
to `S5`

. This is fixed by using a random `(pq)`

which we know - 3-cycles can be written as $[g, h]$ for $g, h \in A_5$. Alternatively, we can say that 3-cycles belong to the commutator subgroup of $A_5$, since they can be written as commutators.
- any element in $A5$ can be written as the composition of 3-cycles.
- Hence, any element in $A5$ can be written as the composition of commutators.

```
arbitrary g
= (3-cycle-1)(3-cycle-2)....(3-cycle-n)
= [g, h][g2, h2]....[gn, hn]
= member of [A5, A5]
```

Recall that $[A5, A5]$ is - If we want the quotient $G/N$ to be abelian, then we need the commutator subgroup $[G, G]$ to be a a subset of $N$.

- In our case, $[A_5, A_5] = A_5$. So if we want to remove the non-abelian-ness of A5, we need to quotient by the
*whole*of $A5$.

- This means that any such chain will immediately collapse to $e$.

- So, it's impossible to build $A5$ using 'cycling components' starting from $\{e\}$. Viewed from the field theoretic perspective, this means that it's impossible to reach a polynomial whose splitting field has galois group A5 by simply appending cycles.

`C = (123)`

will break down for `D = (321)`

. Fear not!
- We will show that all 3-cycles are conjugate to each other. So, we can always relabel a 3-cycle within A5.
- It is easy to note that $g[k, l]g^{-1} = [gkg^{-1}, glg^{-1}]$. This shows that the commutator subgroup is closed under conjugation. It better be, because it ought to be normal for us to take quotients from it.
- Combining these facts, if we show that
`(123)`

is in`[A5, A5]`

, then some other cycle`(ijk)`

can be conjugated to`(123)`

. Since the commutator subgroup is closed under conjugation, we have that`(ijk)`

is a member of`[A5, A5]`

.

- Given two 3-cycles
`C=(abc)`

and`D=(pqr)`

, at least one of`a, b, c`

must be equal to one of`p, q, r`

. Since each`a, b, c`

is unique, and each`p, q, r`

is unique, for them to not overlap, we would need 6 elements. But we only have 5, so there must be some overlap:

```
a b c
1 2 3 4 5
p q r
```

So, we will perform our proof assuming there is 1 overlap, 2 overlap, 3 overlap.
Recall that if `C = (a b c)`

is a cycle and `s`

is a permutation, then the action
of conjugating `C`

with `s`

produces a permutation `(s(a) s(b) s(c))`

. We will
prove our results by finding an `s`

, and then `s`

even `s`

as two distinct transpositions, which will
guarantee that it belongs to `A5`

.
- Case 1:
`(abx)`

and`(pqx)`

have a single element`x`

in common:

```
C = (abx)
D = (pqx)
s: send a to p, b to q
s = (ap)(bq)
C = (abx) -conj s-> (pqx) = D
```

- Case 2:
`(axy)`

and`(pxy)`

have two elements in common,`x`

and`y`

. Naively, we would pick`s: send x to y`

. But this is odd, so this isn't a member of`A5`

. To make it even, we rearrange`D = (pxy)`

as`D = (yxp)`

. This lets us go from`C`

to`D`

by relabelling`a`

to`y`

,`y`

to`p`

. This permutation is even since it has two distinct transpositions.

```
C = (axy)
D = (pxy) = (yxp) [cyclic property]
s: send a to y, y to p
s = (ay)(yp)
C = (axy) -conj s-> (yxp) = D
```

- Case 3:
`(xyz)`

and`(xyz)`

have all three elements in common,`x`

,`y`

,`z`

. Here we can conjugate by identity and we are done.

- Roughly, we can look at the solvability criterion as giving us a way to build our group $G$ from a series of extensions $N[1], N[2], \dots$. This extension is special, because at each step, we are adding a cyclic group.

- When we want to write a solution using nth roots, we can only add the nth roots of unity, a "cyclic" component. So, any element we can reach by using nth roots ought to be able to be written down as an extension of cyclic elements.

`A5`

: - Create a dictionary
`m`

which maps each element of`A5`

to the commutators that create it.

```
from collections import defaultdict
m = defaultdict(set)
A5 = AlternatingGroup(5)
S5 = SymmetricGroup(5) # if necessary
for g in A5:
for h in A5:
m[g * h * g^(-1) * h^(-1)] |= { (g, h) }
# all 60 elem can be written in terms of commutators
print("number of elem generated as commutator: " + str(len(m.keys())))
# Show how to access elements of A5 and their commutator representation
cyc5 = A5("(1, 2, 3, 4, 5)")
cyc3 = A5("(1, 2, 3)")
cyc2disj = A5("(1, 2) (3, 4)")
print(m[cyc5])
print(m[cyc3])
print(m[cyc2disj])
```

`A5`

directly as a commutator ```
s = (12)(34)
```

Note that if we choose `t = (abcd)`

, then `t*t`

will exchange the first
and third elements `a <-> c`

, and the second and fourth elements `b <-> d`

.
So, if we choose:
```
t = (1324)
t*t = (12) (34)
```

Next, we need to write this `t*t`

as `[g, h]`

for `g, h`

from `A5`

.
```
t*t = (1324)(1324)
= (42)(23)(31);(42)(23)(31)
= (42)(23)(31);(42)(23)(31)
= (42)(23)(31);(23)(23);(42)(23)(31)
^^^^^^^^ inserted
= (42)(23)|(31)(23)|(23)(42)|(23)(31)
g | h | g' | h'
= [(42)(23), (31)(23)]
```

Where both `(42)(23)`

, and `(31)(23)`

are members of `A5`

.
`s = (1 2 3 4 5)`

. we once again find a square root of `s`

. To build
this, we will build an element with the elements of `s`

written with
gaps of `2`

:
```
t = (1 _ _ _ _)
= (1 _ 2 _ _) [+2 index]
= (1 _ 2 _ 3) [+2 index, wrap]
= (1 4 2 _ 3) [+2 index, wrap]
= (1 4 2 5 3) [+2 index, wrap]
```

It should be clear how `t*t = s`

: When we take `s = t*t`

, the resulting permutation `s`

will move an element `j = t[i]`

to `k = t[i+2]`

. But we have built `t`

such
that `t[i+2] = s[i+1]`

. So we will move the element according to how `s`

pleases:
```
t = (1 4 2 5 3)
t*t = 1 -> (4 skip) -> 2
2 -> (5 skip) -> 3
3 -> (1 skip) -> 4
3 -> (2 skip) -> 5
5 -> (3 skip) -> 1
t*t = (1 2 3 4 5) = s
```

We will now use `t*t`

to write the commutator:
```
s = t*t
= (35)(52)(24)(41);(35)(52)(24)(41)
=
=
=
= (1, 2)(3, 5)|(1, 5)(2, 4)|(3, 5)(1, 2)|(2, 4)(1, 5)
= (1, 2)(3, 5)|(1, 5)(2, 4)|(3, 5)(1, 2)|(2, 4)(1, 5)
g h g^{-1} h^{-1}
```