# Chapter 11: Software and Calculations
# 
# 
# The function  Orbit(G,x)  will compute the orbit of x under the
# permutation group or
# linear group G. Here x is a positive natural number or a vector. For
# example, 
# 
> A5 := Group( [[1, 2, 3]] , [[3, 4, 5]] ):
# 
# So the orbit of 2 under A5 can be computed by
# 
> Orbit( A5, 2);

                           {1, 2, 3, 4, 5}

# 
# Similarly, if you set 
# 
> ChoosePrime(5);

                                  5

# 
# and take
# 
> F20 := Group( L([[1, 1], [0, 1]]) , L([[2, 0], [0, 3]]) ):
# 
# then the orbit of the vector (2,3) is
# 
> Orbit( F20, [2,3] );

  {[3, 1], [0, 1], [1, 2], [0, 3], [2, 2], [3, 2], [2, 1], [4, 1],

        [1, 4], [4, 2], [0, 4], [1, 1], [4, 3], [2, 3], [3, 4],

        [3, 3], [4, 4], [0, 2], [2, 4], [1, 3]}

# 
# (see exercise 4.4). Stabilizer[G,x] will compute the stabilizer of x
# in the group G . So for example
# 
> Elements( Stabilizer( A5, 3 ) );

  {[], [[1, 4, 5]], [[2, 4, 5]], [[1, 2], [4, 5]], [[1, 5, 4]],

        [[1, 2, 5]], [[1, 2, 4]], [[2, 5, 4]], [[1, 4], [2, 5]],

        [[1, 4, 2]], [[1, 5, 2]], [[1, 5], [2, 4]]}

# 
# The conjugacy class of an element can be calculated with the function 
# ConjugacyClass. Let's use it to compute the conjugacy classes in A5. 
# To begin, we know that the conjugacy classes in S5 correspond to the
# cycle types of permutations of degree 5. The even cycle types are
# 
# {1}, {2,2}, {5}, {3} .
# 
# The function  CycleTypes computes the number of permutations in each
# cycle type:
# 
> CycleTypes( Elements(A5) );

                     [[]    [2, 2]    [5]    [3]]
                     [                          ]
                     [1       15      24     20 ]

# 
# Now two elements in A5 may be conjugate by an element in S5 but not by
# an element in A5. So a conjugacy class of S5 may break up into more
# than one conjugacy class in A5. We begin with a 3-cycle:
# 
> ConjugacyClass( A5, [[1, 2, 3]] );

  {[[1, 4, 5]], [[3, 5, 4]], [[2, 4, 5]], [[1, 5, 4]], [[1, 2, 5]],

        [[1, 2, 4]], [[1, 3, 4]], [[1, 3, 5]], [[2, 5, 4]],

        [[2, 3, 5]], [[1, 4, 2]], [[1, 5, 2]], [[3, 4, 5]],

        [[1, 2, 3]], [[1, 3, 2]], [[2, 3, 4]], [[2, 5, 3]],

        [[1, 5, 3]], [[2, 4, 3]], [[1, 4, 3]]}

# 
# These are all 20 3-cycles. Next we look at the conjugacy class of a
# 5-cycle:
# 
> ConjugacyClass( A5, [[1, 2, 3, 4, 5]] );

  {[[1, 5, 4, 3, 2]], [[1, 2, 4, 5, 3]], [[1, 3, 2, 5, 4]],

        [[1, 4, 5, 2, 3]], [[1, 4, 3, 5, 2]], [[1, 5, 2, 4, 3]],

        [[1, 3, 5, 4, 2]], [[1, 2, 5, 3, 4]], [[1, 5, 3, 2, 4]],

        [[1, 4, 2, 3, 5]], [[1, 3, 4, 2, 5]], [[1, 2, 3, 4, 5]]}

# 
# This is only half of the 5-cycles! One that is missing is  (1 2 3 5 4)
# . So let's compute its conjugacy class:
# 
> ConjugacyClass( A5, [[1, 2, 3, 5, 4]] );

  {[[1, 4, 5, 3, 2]], [[1, 4, 2, 5, 3]], [[1, 2, 5, 4, 3]],

        [[1, 3, 2, 4, 5]], [[1, 2, 4, 3, 5]], [[1, 3, 4, 5, 2]],

        [[1, 2, 3, 5, 4]], [[1, 4, 3, 2, 5]], [[1, 3, 5, 2, 4]],

        [[1, 5, 2, 3, 4]], [[1, 5, 4, 2, 3]], [[1, 5, 3, 4, 2]]}

# 
# These are the remaining 5-cycles. Lastly we look at the conjugacy
# class of a product of two transpositions:
# 
> ConjugacyClass( A5, [[1, 2], [3, 4]] );

  {[[1, 5], [3, 4]], [[1, 3], [4, 5]], [[2, 3], [4, 5]],

        [[1, 2], [4, 5]], [[1, 3], [2, 4]], [[2, 5], [3, 4]],

        [[1, 5], [2, 3]], [[1, 3], [2, 5]], [[1, 4], [2, 5]],

        [[1, 4], [2, 3]], [[1, 4], [3, 5]], [[2, 4], [3, 5]],

        [[1, 5], [2, 4]], [[1, 2], [3, 5]], [[1, 2], [3, 4]]}

# 
# These are all 15 permutations of type {2, 2}. So these four sets
# together with {(1)} are the conjugacy classes of A5.
# 
#      The centre of a group can be computed with the function  Centre .
# For example,
# 
> D4 := Group( [[1, 2, 3, 4]], [[1, 3]] ):
# 
# and
# 
> Elements( Centre(D4) );

                        {[], [[1, 3], [2, 4]]}

# 
# For a matrix in GL(2,F(p)) the corresponding fracional linear
# transformation is computed by the function FLTPermutation. Let's
# repeat the calculation of
# 
# f : GL(2, F(3)) -> S4
# 
# using this function.
# 
> ChoosePrime(3);

                                  3

> a := L([[2, 1], [0, 1]]);

                      a := [[[2, 1], [0, 1]], 3]

> b := L([[2,2],[0,1]]);

                      b := [[[2, 2], [0, 1]], 3]

> c := L([[0,1],[1,0]]);

                      c := [[[0, 1], [1, 0]], 3]

> FLTPermutation(a);

                               [[0, 1]]

> FLTPermutation(b);

                               [[0, 2]]

> FLTPermutation(c);

                           [[0, infinity]]