permutation group algorithms - elteweb.cs.elte.hu/summerschool/2016/egyeb/permutation_i.pdf ·...

Permutation Group Algorithms 2016 1 / 39

Permutation Group Algorithms

Zoltán Halasi

Eötvös Loránd University

2016

Permutation Group Algorithms 2016 2 / 39

Some basic algorithms for groups

Basics we need Permutation Group Algorithms 2016 3 / 39

Main areas of Computational Group Theory

Permutation groups

Matrix groups

Finitely presented groups

Polycyclic groups

Group representations


CAS, References

General Computer Algebra Systems:

Gap (http://www.gap-system.org/; free)Magma (http://magma.maths.usyd.edu.au;

to institutions for charge)

References:

D. F. Holt, B. Eick, E. O’Brien: Handbook of computationalgroup theoryA. Hulpke: Notes on Computational Group Theory (lecturenotes)Ákos Seress: Permutation Group Algorithms

http://www.gap-system.org/http://magma.maths.usyd.edu.au


Groups

Group: (G , ∗) is a group, if G is a set and∗ : G × G → G , (a, b)→ a ∗ b is a binary operation satisfying

1 Associativity: (a ∗ b) ∗ c = a ∗ (b ∗ c);2 Unit element: ∃e ∈ G such that e ∗ a = a ∗ e = a ∀a ∈ G3 Inverse: ∀a ∈ G , ∃b ∈ G such that a ∗ b = b ∗ a = e.

Remarks:

Every group is finite! (In this lecture, of course)

Notation: a ∗ b ⇒ ab, Unit element: 1, Inverse: a−1

Unit element and inverse are unique;

Cancellation laws:∀a, x , y ∈ G , ax = ay ⇐⇒ x = y ⇐⇒ xa = yaSolving equations:ax = b ⇐⇒ x = a−1b, xa = b ⇐⇒ x = ba−1

Powers, power identities

Order of an element, o(g).


Subgroups, cosets

H ≤ G is a subgroup if a, b ∈ H ⇒ a−1, ab ∈ H;(If |H|


Lagrange theorem, index, transversal

H ≤ G , x , y ∈ G ⇒ Hx = Hy or Hx ∩ Hy = ∅;G is partitioned into right cosets of H

The index of H in |G | is |G : H|=the number of different(right) cosets;

T = {g1, . . . , gk} (where |G : H| = k) is a transversal for Hin G if the list Hg1, . . .Hgk contains each coset of H exactlyonce; We also say T = {g1, . . . , gk} is a complete set of cosetrepresentatives;

∀i : |Hgi | = |H| ⇒ |G | = |H| · |G : H|;H ≤ G ⇒ |H| | |G |. In particular, o(g) = |〈g〉| | |G | for anyg ∈ G .


Permutation groups and group actions

The symmetric group:Ω is a finite set, Sym(Ω) := All Ω 7→ Ω bijections.Group operation: composition of functions

Usually, Ω = {1, 2, . . . , n},⇒ Sym(Ω) = Sn;Permutation group on Ω: G ≤ Sym(Ω).G acts on Ω if ∀g , h ∈ G , ∀ω ∈ Ω

∃ωg ∈ Ω; (The image of ω under G )(ωg )h = ωgh;ω1 = ω.

Group action ⇐⇒ G → Sym(Ω) homomorphism(product presserving map).

g ∈ G →(ω1 ω2 . . . ωnωg1 ω

g2 . . . ω

gn

)


Some important actions

Action on cosets:

Right: H ≤ G , Ω := {Hx |x ∈ G}, (Hx)g := H(xg);Left: H ≤ G , Ω := {xH |x ∈ G}, (xH)g := (g−1x)H;

Special case of the above: Regular actions (with H = 1):

Theorem (Cayley)

Every group can be wieved as a subgroup of a symmetric group

Action by conjugation:

On elements: Ω := G , xg := g−1xgOn subgroups: Ω := {H |H ≤ G}, Hg := g−1Hg

(related concepts: conjugacy classes, centraliser, normaliser)


How to handle permutation groups by computer?

From now on, Ω := {1, . . . , n}, G ≤ Sn;Representing / Storing an element ∈ Sn:

An array of length n containing each number 1, . . . , n exactlyonce in some order; (roughly n log2 n bits)Cycle decomposition (more difficult to use it in algorithms)

(Easily convertable to each other)

Memory requirement: n log2(n) bits for a permutation ∈ Sn:This means 4n bytes in practice for n = 105 (we do not carewith the 4)

Current CAS-s can calculate with permutations of degreen = 105 (even more)

If we have 2GB Memory ⇒ 2GB/4n ≈ 5000 permutations(for n = 105) can be stored.

But |S105 | = (105)! ≈ 2.8 · 10456574;How is this possible?


Some ideas

How define a permutation group?

Example Sn = 〈(12), (123 . . n)〉;More generally: Every G ≤ Sn can be generated by most n/2elements.

Input group: X = [x1, . . . , xr ] ⊂ Sn with G = 〈X 〉. Inpractice, usually |X | ≤ 10

How to plan an algorithm?

Space – Time conflict;

Store/Calculate elements only when you really need it;

Avoid long lists;

Different methods for the same problem – choose the best one(e.g. for degree n ≤ 1000 we store elements to get a fasteralgorithm, above it we always recalculate them, when weneed)


Storing elements

X → Some algorithm → g ∈ G is found. How to handle(store/compute with) g?

Explicit calculation: g can be written as a product of thegenerators, so we can calculate it explicitly ⇒ g is stored asan array of length n. (It can require both large space and longtime)

Permutation words: g is represented with an array containingpointers to the generators (and their inverses) in the sameorder as how we should multiply them to get g .Straight-line programs (SLP): g is represented with an array[w1, . . . ,wk ] such that wi is one of the following for each i :

wi ∈ X ;wi = (wj ,−1) for some 1 ≤ j < i(take the inverse of wj);wi = (wj ,wk) for some 1 ≤ j , k < i(take the product of wj ,wk).

Storing base images (later)


Example: Calculating and storing elements

Let X = [a, b] and g = abab2 · · · ab100Explicit calculation?

Stupid way – Multiply from left to right:Time: 2 + . . .+ 101− 1 = 5149 multiplication of permutationsSpace: nA bit more clever way

d := c := ab;for i ∈ [1 . . 99] do

c := cb; d := dc ;

Time: 199 multiplication of permutations in SnSpace: 2n

By a permutation word: g → [1, 2, 1, 2, 2, 1, 2, 2, 2, 1 . . .].Space: 5150 (it does not depend on n)

By SLP:

[a, b, (w1,w2), (w3,w2), (w3,w4), (w4,w2), (w5,w6), . . .]

Space: 201


Computational Complexity

big-O notation:For t, f : N→ R we say t(n) ∈ O(f (n)) if ∃n0 ∈ N, c > 0 s.t.t(n) < cf (n) if n > n0.

Input length: O(n)

An algorithm is polynomial-time if its running time (≈ thenumber of steps we need) is in O(nc) for some c > 0constant.

Example: Multiplication of two permutations ∈ O(n).Theoretical Computer Science: Fast ≈ Polynomial-timePractice is often different!

Even O(n2) running-time can be too slow;In some cases, even an exponential-time algorithm can workefficiently in practice.

Randomisation might help to find solution faster with highprobability.


Randomised algorithms

Deterministic: For the same input you always get the same(correct) output.

Randomised

Monte-Carlo (with error probability ε < 1/2):It might give a wrong answer;The probability that the answer is wrong is < ε for every input;Reliability can be improved by repeated application.One-sided Monte Carlo: A random algorithm for a decisionproblem;One of the possible answers (’yes’ or ’no’) is guaranteed to becorrect; It can be used as a ’filter’.Las Vegas:It never gives an incorrect answer;There is a probability < ε that it does not return an answer atall i.e. reports failure.


Randomised algorithms

Remarks:

Rerunning Las Vegas algorithm as long as it reports failure ⇒it always give a correct answer, but the running time israndom.

Monte Carlo algorithm + deterministic checking ⇒ Las Vegasalgorithm.

In CGT: Random event: Choose a random element from thegroup.


How to find a random element of a group?

A group G is given by a set of generators X = [x1, . . . , xr ]

Problem: Choose a “random element” of G , i.e. with uniformdistribution:∀g ∈ G : P(g has been chosen) = 1/|G |We assume we have a perfect random generator, whichprovides a uniformly random element of a listEasy cases:

|G | is small enough to list all elements of G ;G = Sn; (Homework)A base and a strong generating set is known for G ; (later)

Homework 1.

Give an algorithm, which provides a uniformly random element ofSn of running time O(n). (with the assumption that you have aperfect random generator, which can choose an element of [1 . . n]in constant time.)


The product replacement algorithm

Let X = [x1, . . . , xr ] be generators for G with r ≥ 10.Additionally, let x0 = 1.

Main step:Choose randomly: s, t ∈ [1 . . r ], s 6= t, ε ∈ {±1} and also a“side” from {left,right};Change xs to either x

εt xs or xsx

εt (depending on which “side”

was chosen);Change x0 to xsx0 or x0xs .

As an initialistion, run the main step several times. (Inpractice, 50 step is used)

After that, each time you need a new random element, runthe main step and return with the current value of x0.

Remarks:

Fast, usually works well in practice.

It is not uniformly distributed, and it is unsatisfactory in somecases.

Some basic algorithms Permutation Group Algorithms 2016 19 / 39

Orbit and stabilizer

Definition (Orbit and stabilizer)

Let G act on Ω.

The orbit of α ∈ Ω: αG := {αg | g ∈ G};α, β ∈ Ω in the same orbit if αG = βG ;Equivalence classes: Orbits of G on Ω;

G is transitive: there is just one orbit;

The stabiliser of α ∈ Ω in G : Gα := {g ∈ G |αg = α} ≤ G .

Theorem (Orbit-stabiliser theorem)

Let G ≤ Ω, α ∈ Ω and H = Gα.There is a bijective correspondence:

αG ←→ {Hg | g ∈ G}, αg ←→ Hg , ∀g ∈ G

|αG | = |G : Gα| ⇒ |G | = |αG | · |Gα|


Basic Orbit algorithm

The Orbit algorithm:

Input: X = [x1, . . , xr ] ⊂ Sym(Ω) with 〈X 〉 = G , and α ∈ ΩProblem: Find αG

Maintain an array ∆. At the first step, ∆ := [α].For any β ∈ ∆, calculate βx for every x ∈ X .Check whether βx ∈ ∆; If not, we append βx to ∆.Continue, until βx ∈ ∆ for every β ∈ ∆, x ∈ X . Then∆ = αG .

Membership testing: Use a characteristic vector for ∆ ⊂ Ω.(This can be a problem if the action is not the natural one)


Pseudocode: The Orbit algorithm

Orbit(X , α)

Input: X ⊂ Sym(Ω) with 〈X 〉 = G , α ∈ ΩOutput: ∆ = αG

1 ∆ := [α];2 for β ∈ ∆ do3 for x ∈ X do4 if βx /∈ ∆ then5 Append βx to ∆;6 return ∆;


Computing transversals

Often, we are not only interested in αG , but for some/everyβ ∈ αG also in a uβ ∈ G , which moves α to β, i.e. for whichβ = αuβ .

{uβ |β ∈ αG} is a right transversal for Gα.Modification of the Orbit algorithm:

Maintain an array ∆ containing ordered pairs (β, uβ) forβ ∈ αG , αuβ = β. Initially, ∆ = [(α, 1G )];Every time a new element γ = βx of αG if found, (i.e. whenthere is no element of (γ, ∗) ∈ ∆) choose uγ := uβ · x andappend (γ, uγ) to ∆;At the end of the algorithm, we get an array ∆ containing{(β, uβ) |β ∈ αG}.


Pseudocode: The Orbit-Transversal algorithm

Orbit-Trans(X , α)

Input: X ⊂ Sym(Ω) with 〈X 〉 = G , α ∈ ΩOutput: ∆ = {(β, uβ) |β ∈ αG , αuβ = β}

1 ∆ := [(α, 1G )];2 for (β, uβ) ∈ ∆ do3 for x ∈ X do4 if (βx , ∗) /∈ ∆ then5 Append (βx , uβ · x) to ∆;6 return ∆;


Schreier vectors

Storing a set of transversals {uβ |β ∈ αG} requires place|αG | · n. This is n2 if G is transitive.We run out of memory if n is large.

Solution: Schreier vector. We modify the Orbit algorithm asfollows.

Besides ∆, we maintain an array Sv indexed by elementsΩ = {1, 2, . . . , n}.Initalise Sv as Sv [α] = −1, Sv [β] = 0 for β 6= α.When a new element βxi /∈ ∆ found, we not only append βx to∆, but we also change Sv [βxi ] to i ;When the algorithm ends we return ∆,Sv (or just Sv)

At the end, Sv can also be used as a characteristic vector forαG , since β ∈ αG ⇐⇒ Sv [β] 6= 0.


Pseudocode: Orbit-Sv

Orbit-Sv(X , α)

Input: X = [x1, . . , xr ] ⊂ Sym(Ω) with 〈X 〉 = G , α ∈ ΩOutput: Sv for α

1 for i = [1 . . n] do Sv [i ] := 0;2 ∆ := [α]; Sv [α] := −1;3 for β ∈ ∆ do4 for i = [1 . . r ] do5 if βxi /∈ ∆ then6 Append βxi to ∆;7 Sv [βxi ] := i ;8 return Sv ;


Calculating transversal from Schreier vector

Sometimes we need to explicitly calculate an uβ ∈ G which movesα to β. We can do this from Sv for α as follows.

In general, it is worth precalculate X−1 := [x−11 , . . , x−1r ], since

we will use them.

Input: X , X−1, β ∈ Ω, Sv for αProblem: Find an uβ ∈ G with αuβ = β if β ∈ αG

First, we check whether Sv [β] = 0; If yes, then β /∈ αG andthe algorithm terminates; Otherwise, β ∈ αG .By using Sv we step back from β on αG (by applying somex−1k -s according to the vector Sv until we reach an ω ∈ Ωsatisfying Sv [ω] = −1. Then ω = α and we get uβ by takingthe product of all the xi -s according to the entries of Sv wetouched on the way to α.


Pseudocode: U-beta

U-beta(β,Sv ,X ,X−1)

Input: β ∈ Ω, a Schreier vector Sv for αand X = [x1, . . . , xr ],X

−1 ⊂ Sym(Ω) with 〈X 〉 = GOutput: uβ ∈ G with αuβ = β if β ∈ αG ; otherwise false

1 if Sv [β] = 0 then2 return false;3 ω := β; u := 1G ; k := Sv [ω];4 while k 6= −1 do5 u := xku;

6 ω := ωx−1k ;

7 k := Sv [ω];8 return u;


Calculating the stabiliser of α

Theorem (Schreier’s Lemma)

Let H ≤ G be groups, X : a set of generators for G and T 3 1: aright transversal for H in G. For any g ∈ G let g := t ∈ T ifHg = Ht. Then Y = {tx(tx)−1 | t ∈ T , x ∈ X} ⊂ H generates H.

Proof.

Y ⊂ H by definition;Let g ∈ H and write g = x1 · · · xm by a product of generators;Define recursively elements tj ∈ T and yj ∈ Y byt1 = 1, tj+1 = tjxj and yj = tjxj(tjxj)

−1; Then tjxj = yj tj+1for 1 ≤ j ≤ m. So

g = (t1x1)x2 · · · xm = y1(t2x2) · · · xm = y1y2(t3x3) · · · xm= y1y2 · · · ymtm+1 = y1y2 · · · ym ∈ 〈Y 〉


Calculating the stabiliser of α

We use the previous Orbit-Transversal algorithm, but if we get aβx which is already in ∆, then we append the Schreier generatoruβx(uβx )

−1 to Y .

Orbit-Stabiliser(X , α)

Input: X ⊂ Sym(Ω) with 〈X 〉 = G , α ∈ ΩOutput: ∆ = {(β, uβ) |β ∈ αG , αuβ = β},Y ⊂ Sym(Ω) with 〈Y 〉 = Gα

1 ∆ := [(α, 1G )];2 Y := [ ];3 for (β, uβ) ∈ ∆ do4 for x ∈ X do5 if βx /∈ ∆ then6 Append (βx , uβ · x) to ∆;7 else Append uβx(uβx )

−1 to Y ;8 return ∆,Y ;


How to reduce the number of generators?

If there is a membership test available, one can check a newlyconstructed Schreier generator whether it is already in thesubgroup generated by the current Y and append to Y ony ifit is not.

It still not provides a minimal set of generators;It requires many element tests;

We can choose a relatively small random subset of Y and“hope” that it still generates Gα; (its probability is often veryhigh)

By using random subproducts of the Schreier generators onecan find subsets of Y of moderate size which generate Gαwith high probability. Here, a random subproduct ofY = {y1, . . . , ys} is an element of the form

y ε11 yε22 · · · y

εss , ε1, . . . , εs ∈ {0, 1}.


Bases and strong generating sets (BSGS)

Definition

Let G ≤ Sym(Ω) be a permutation group acting on Ω.A sequence B = (β1, β2, . . . , βk) ⊂ Ω is a base for G if∩ki=1Gβi = 1;The stabiliser chain defined by the base B = (β1, . . . , βk) is

G = G (0) ≥ G (1) ≥ . . . ≥ G (k) = 1,

where G (i) := G(i−1)βi

= G(β1,...,βi ) is the subgroup{g ∈ G | g(βj) = βj , ∀ 1 ≤ j ≤ i};A set of generators S ⊂ G is a strong generating set for Grelative to B if S ∩ G (i) generates G (i) for every 0 ≤ i ≤ k ;If B = (β1, β2, . . . , βk) ⊂ Ω is a base for G , then the i-thfundamental orbit ∆i is the orbit of βi under the action ofG (i−1), i.e. ∆i := β

G (i−1)i .


The importance of BSGS

Almost every advanced permutation group algorithm usesthem;

Storing group elements with base images:If B = (β1, β2, . . . , βk) is a base for G , then every g ∈ G isdetermined by (βg1 , β

g2 , . . . , β

gk )

Most interesting permutation groups in practice has a base ofsize ≤ 10⇒ very efficient way to store group elements;Calculating the order of the group:

|G | = |G (0) : G (1)| · · · |G (k−1) : G (k)| = |∆1| · |∆2| · · · |∆k |.

By using the orbit algorithm for each pair (βi ,S ∩ G (i−1)) wecan calculate each fundamental orbit ∆i .

A (perfectly) random element g ∈ G can be chosen;Provides membership test (by shifting);


Finding a random element

Let Ui be a (right) transversal for G(i) in G (i−1) for every

1 ≤ i ≤ k ;(Such transversals can be find with the orbit-transversalalgorithm for input (βi , S ∩ G (i−1));)We have G = Uk × . . .× U1, i.e. every g ∈ G can be writtenof the form g = uk · · · u1 in a unique way!Generating random element g ∈ G :

For every 1 ≤ i ≤ k , calculate the i-th fundamental orbit ∆i ;Choose random elements γi ∈ ∆i ;Calculate elements ui := uγi such that β

uii = γi ;

By taking the product uk · · · u1, we get a random element of G .


Membership testing (By shifting)

Idea: For a given g ∈ Sym(Ω), we search for a decompositiong = uk · · · u1 (with ui ∈ Ui ); such ui -s can be find ⇐⇒ g ∈ G .The shifting algorithm

Check whether βg1 ∈ ∆1: If not, g /∈ G ;Otherwise, find u1 ∈ G (1) s.t. βg1 = β

u11 ;

Continue with gu−11 and β2 . . . ;

The algorithm terminate in step m < k if gu−11 · · · u−1m−1

moves βm outside of ∆m. In that case, g /∈ G ;If you reach the k-th step, then gu−11 · · · u

−1k fixes each

element of B.Then g ∈ G ⇐⇒ gu−11 · · · u

−1k = 1. (Check this!)

Note: Until the last step, you should not explicitly multiply thepermutations!


Pseudocode: Shifting

Shifting(g ,B, S ,∆∗)

Input: g ∈ Sym(Ω), B,S BSGS,and ∆∗ (reference to the orbit-transversal algorithm)

Output: m ≤ k + 1 (the step when terminated),h = gu−11 · · · u

−1m−1

1 h := g ;2 for m ∈ [1 . . k] do3 γ := βhm;4 if γ /∈ ∆m then5 return m, h;6 else h := hu−1γ ;7 Return k + 1, h

Note: g ∈ G ⇐⇒ the output is k + 1, 1G .


The Schreier–Sims algorithm

Problem: G ≤ Sym(Ω) is given as G = 〈X 〉. Find a BSGS (B,S).Initial step: B := [ ]. Extend B to B := [β1, . . . , βk ] such thatno element of X fixes B pointwise;∀1 ≤ i ≤ k let S (i) := X ∩ Gβ1,...,βi and H(i) := 〈S (i)〉. Then

G = H(0) ≥ H(1) ≥ . . . ≥ H(k) = 1.

Lemma

(B, S) is a BSGS for G ⇐⇒ H(k) = 1 and H(i−1)βi = H(i) for all i .

For i = k , k − 1, . . ., we check whether H(i−1)βi ≤ H(i). If this

holds for each i , then B, S is a BSGS by Lemma;Let us assume that this holds for every l > i . To check

whether H(i−1)βi

≤ H(i) for i we take the Schreier generatorsfor H

(i−1)βi

in H(i−1), and test whether they are in H(i);

(Remark: (βi+1, . . . , βk) and S(i) is a BSGS for H(i) by

assumption, so we can do this!)


The Schreier–Sims algorithm

If not, we found a g ∈ H(i−1)βi with g /∈ H(i).

In fact, when we checked g /∈ H(i) with algorithm Shifting, itprovided us m, h with i + 1 ≤ m ≤ k + 1 and h such that hfixes β1, . . . , βm−1 and

1 either m ≤ k and βhm /∈ ∆m;2 or m = k + 1 and h 6= 1 fixes every element of B.

In both case, we add h to each of S (i), . . . ,S (m−1).(Hence we redefine the subgroups H(i), . . . ,H(m−1) and thefundamental orbits ∆i , . . . ,∆m−1)

In the second case, we also add a new element βk+1 to B notfixed by h, and define S (k+1) = [ ], k := k + 1;

We start again to check the assumption of Lemma . . .

The algorithm must terminate after finitely many steps; Then(B,S) is a BSGS for G , where S := ∪ki=1Si .


Complexity of Schreier–Sims

The time and space need for calculating a BSGS for G = 〈X 〉 ≤ Snwith this (deterministic) algorithm:

By calculating the transversals explicitly:

Time: O(n2 log3 |G |+ |X |n2 log |G |)Space: O(n2 log |G |+ |X |n)

By using Schreier vectors:

Time: O(n3 log3 |G |+ |X |n3 log |G |)Space: O(n log2 |G |+ |X |n)

A usual situation is when B is small, and n is large. Then

Definitely use Schreier vectors;

Modify algorithms to work with permutation words or SLP-s

Slowest part: When “Shifting” returns with k + 1, h, you needto check whether h = 1G .

“Known-base version”⇒ Fast computation of SGS.


Homework 2.

Prove that if we apply the Shifting algorithm for a groupG = 〈S〉 ≤ Sn such that (B, S) is not a BSGS, then it behavessimilar to a one-sided Monte Carlo algorithm, except that theerror-probability is ε > 1/2. More precisely,

1 If g ∈ Sn is any permutation such that g /∈ G , then it stillalways recognises this fact;

2 On the other hand; if g ∈ G is chosen with uniformdistribution, then the probability that the shifting proceduregives an incorrect answer is at least 1/2.

Remark: With the help of this, one can define a “RandomSchreier–Sims method” which runs much more quickly, and finds aBSGS with prescribed high probability.

Basics we needSome basic algorithms

permutation group algorithms - elteweb.cs.elte.hu/summerschool/2016/egyeb/permutation_i.pdf ·...

Documents