Upload
others
View
6
Download
0
Embed Size (px)
Citation preview
Permutation Group Algorithms 2016 1 / 39
Permutation Group Algorithms
Zoltán Halasi
Eötvös Lorá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
Basics we need Permutation Group Algorithms 2016 4 / 39
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)Ákos Seress: Permutation Group Algorithms
http://www.gap-system.org/http://magma.maths.usyd.edu.au
Basics we need Permutation Group Algorithms 2016 5 / 39
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).
Basics we need Permutation Group Algorithms 2016 6 / 39
Subgroups, cosets
H ≤ G is a subgroup if a, b ∈ H ⇒ a−1, ab ∈ H;(If |H|
Basics we need Permutation Group Algorithms 2016 7 / 39
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 .
Basics we need Permutation Group Algorithms 2016 8 / 39
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
)
Basics we need Permutation Group Algorithms 2016 9 / 39
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)
Basics we need Permutation Group Algorithms 2016 10 / 39
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?
Basics we need Permutation Group Algorithms 2016 11 / 39
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)
Basics we need Permutation Group Algorithms 2016 12 / 39
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)
Basics we need Permutation Group Algorithms 2016 13 / 39
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
Basics we need Permutation Group Algorithms 2016 14 / 39
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.
Basics we need Permutation Group Algorithms 2016 15 / 39
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.
Basics we need Permutation Group Algorithms 2016 16 / 39
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.
Basics we need Permutation Group Algorithms 2016 17 / 39
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.)
Basics we need Permutation Group Algorithms 2016 18 / 39
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α|
Some basic algorithms Permutation Group Algorithms 2016 20 / 39
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)
Some basic algorithms Permutation Group Algorithms 2016 21 / 39
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 ∆;
Some basic algorithms Permutation Group Algorithms 2016 22 / 39
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}.
Some basic algorithms Permutation Group Algorithms 2016 23 / 39
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 ∆;
Some basic algorithms Permutation Group Algorithms 2016 24 / 39
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.
Some basic algorithms Permutation Group Algorithms 2016 25 / 39
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 ;
Some basic algorithms Permutation Group Algorithms 2016 26 / 39
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 α.
Some basic algorithms Permutation Group Algorithms 2016 27 / 39
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;
Some basic algorithms Permutation Group Algorithms 2016 28 / 39
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 〉
Some basic algorithms Permutation Group Algorithms 2016 29 / 39
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 ;
Some basic algorithms Permutation Group Algorithms 2016 30 / 39
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}.
Some basic algorithms Permutation Group Algorithms 2016 31 / 39
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 .
Some basic algorithms Permutation Group Algorithms 2016 32 / 39
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);
Some basic algorithms Permutation Group Algorithms 2016 33 / 39
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 .
Some basic algorithms Permutation Group Algorithms 2016 34 / 39
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!
Some basic algorithms Permutation Group Algorithms 2016 35 / 39
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 .
Some basic algorithms Permutation Group Algorithms 2016 36 / 39
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!)
Some basic algorithms Permutation Group Algorithms 2016 37 / 39
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 .
Some basic algorithms Permutation Group Algorithms 2016 38 / 39
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.
Some basic algorithms Permutation Group Algorithms 2016 39 / 39
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