Recog An/Sn unknown degree: conder, holt

doc/intro.xml

@@ -85,6 +85,7 @@ in the bibliography:
 <Cite Key="NP99"/>
 <Cite Key="NP97"/>
 <Cite Key="Pra99"/>
+<Cite Key="Con12"/>
 <Cite Key="CLG97a"/>
 <Cite Key="CLG97b"/>
 <Cite Key="CLGM+95"/>

doc/recog.bib

@@ -599,6 +599,14 @@ @incollection {CLG98
       NOTE = {https://doi.org/10.1017/CBO9780511565830.007},
 }
 
+@misc {Con12,
+    AUTHOR = {Conder, Jonathan},
+     TITLE = {Algorithms for Permutation Groups},
+      YEAR = {2012},
+       URL = {https://jonathan-conder.github.io/afpg.pdf},
+      NOTE = {B.Sc. thesis},
+}
+
 @article {CLGO06,
     AUTHOR = {Conder, M. D. E. and Leedham-Green, C. R. and O'Brien, E. A.},
      TITLE = {Constructive recognition of {${\rm PSL}(2,q)$}},

gap/matrix.gi

@@ -964,6 +964,8 @@ AddMethod(FindHomDbMatrix, FindHomMethodsMatrix.DiagonalMatrices, 1100);
 
 AddMethod(FindHomDbMatrix, FindHomMethodsMatrix.KnownStabilizerChain, 1175);
 
+AddMethod(FindHomDbMatrix, FindHomMethodsGeneric.SnAnUnknownDegree, 1070);;
+
 AddMethod(FindHomDbMatrix, FindHomMethodsGeneric.FewGensAbelian, 1050);
 
 AddMethod(FindHomDbMatrix, FindHomMethodsMatrix.ReducibleIso, 1000);

gap/perm.gi

@@ -499,6 +499,8 @@ AddMethod(FindHomDbPerm, FindHomMethodsPerm.Imprimitive, 70);
 
 AddMethod(FindHomDbPerm, FindHomMethodsPerm.LargeBasePrimitive, 60);
 
+AddMethod(FindHomDbPerm, FindHomMethodsGeneric.SnAnUnknownDegree, 58);;
+
 AddMethod(FindHomDbPerm, FindHomMethodsPerm.StabilizerChainPerm, 55);
 
 AddMethod(FindHomDbPerm, FindHomMethodsPerm.StabChain, 50);

gap/projective.gi

@@ -332,6 +332,8 @@ AddMethod(FindHomDbProjective, FindHomMethodsProjective.D247, 840);
 
 AddMethod(FindHomDbProjective, FindHomMethodsProjective.AltSymBBByDegree, 810);
 
+AddMethod(FindHomDbProjective, FindHomMethodsGeneric.SnAnUnknownDegree, 805);
+
 AddMethod(FindHomDbProjective, FindHomMethodsProjective.TensorDecomposable, 800);
 
 AddMethod(FindHomDbProjective, FindHomMethodsProjective.FindElmOfEvenNormal, 700);

tst/working/quick/GenericSnAnUnknownDegree.tst

@@ -1,45 +1,64 @@
-#@local d, sets, SdOn2Sets, ri, success, x, slp, db
 #
-# HACK to insert the method
-gap> AddMethod(FindHomDbPerm, FindHomMethodsGeneric.SnAnUnknownDegree, 58);;
-gap> AddMethod(FindHomDbMatrix, FindHomMethodsGeneric.SnAnUnknownDegree, 1070);;
-gap> AddMethod(FindHomDbProjective, FindHomMethodsGeneric.SnAnUnknownDegree, 1220);;
+# For each entry (d, k) we construct Sym(d)/Alt(d) acting on k-sets.
+# For each entry (d, k), we must have 2 * k ^ 2 > d,
+# otherwise LargeBasePrimitive recognises the group instead of SnAnUnknownDegree.
+gap> dataPerm := [[5, 2], [7, 2], [8, 3], [9, 3], [10, 3], [11, 3], [12, 3], [13, 3]];;
 
-# FindHomMethodsGeneric.SnAnUnknownDegree
-# Sn
-gap> for d in [11] do
-> sets := Combinations([1 .. d], 2);;
-> SdOn2Sets := Action(SymmetricGroup(d), sets, OnSets);;
-> ri := RecogNode(SdOn2Sets);;
-> success := FindHomMethodsGeneric.SnAnUnknownDegree(ri, SdOn2Sets);
-> if not success or not Size(ri) = Factorial(d) then
->   Print("wrong result! degree ", d, "\n");
-> fi;
-> od;
+#
+# PermGroup action on k-sets
+gap> PermOnKSets := function(G, k)
+>     local sets;
+>     sets := Combinations([1 .. NrMovedPoints(G)], k);;
+>     return Action(G, sets, OnSets);;
+> end;;
+gap> AltOnKSets := function(d, k)
+>     return PermOnKSets(AlternatingGroup(d), k);
+> end;;
+gap> SymOnKSets := function(d, k)
+>     return PermOnKSets(SymmetricGroup(d), k);
+> end;;
 
-# An
-gap> for d in [11] do
-> sets := Combinations([1 .. d], 2);;
-> SdOn2Sets := Action(AlternatingGroup(d), sets, OnSets);;
-> ri := RecogNode(SdOn2Sets);;
-> success := FindHomMethodsGeneric.SnAnUnknownDegree(ri, SdOn2Sets);
-> if not success or not Size(ri) = Factorial(d)/2 then
->   Print("wrong result! degree ", d, "\n");
-> fi;
-> od;
+#
+gap> altPermGroups := List(dataPerm, entry -> AltOnKSets(entry[1], entry[2]));;
+gap> symPermGroups := List(dataPerm, entry -> SymOnKSets(entry[1], entry[2]));;
+
+#
+gap> dataMat := [[5, 4], [7, 3], [8, 5], [11, 7]];;
 
-# Check Slp function
-gap> ri := RecogNode(SdOn2Sets);;
-gap> FindHomMethodsGeneric.SnAnUnknownDegree(ri, SdOn2Sets);
-true
-gap> x := PseudoRandom(Grp(ri));;
-gap> slp := SLPforElement(ri, x);;
-gap> x = ResultOfStraightLineProgram(slp, NiceGens(ri));
-true
+#
+# Permutation Matrix Group
+gap> PermMatGroup := function(G, q) return Group(List(
+>     GeneratorsOfGroup(G),
+>     x -> ImmutableMatrix(q, PermutationMat(x, NrMovedPoints(G), GF(q)))
+> )); end;;
+gap> AltMatGroup := function(n, q) return PermMatGroup(AlternatingGroup(n), q);
+> end;;
+gap> SymMatGroup := function(n, q) return PermMatGroup(SymmetricGroup(n), q);
+> end;;
+
+#
+gap> altMatGroups := List(dataMat, entry -> AltMatGroup(entry[1], entry[2]));;
+gap> symMatGroups := List(dataMat, entry -> SymMatGroup(entry[1], entry[2]));;
 
 #
-# Remove Hacky injection of our method
-gap> for db in [FindHomDbPerm, FindHomDbMatrix, FindHomDbProjective] do
->       Remove(db,
->              PositionProperty(db, x -> Stamp(x.method) = "SnAnUnknownDegree"));;
+gap> nonAltOrSymGroups := [
+>     PSL(3, 5),
+>     SL(3, 5),
+>     Omega(1, 4, 3),
+> ];;
+
+# Test
+gap> for i in [1 .. Length(dataPerm)] do
+>     RECOG.TestGroup(altPermGroups[i], false, Factorial(dataPerm[i, 1])/2, rec());
+>     RECOG.TestGroup(symPermGroups[i], false, Factorial(dataPerm[i, 1]), rec());
+> od;
+gap> for i in [1 .. Length(dataMat)] do
+>     RECOG.TestGroup(altMatGroups[i], false, Factorial(dataMat[i, 1])/2, rec());
+>     RECOG.TestGroup(symMatGroups[i], false, Factorial(dataMat[i, 1]), rec());
+> od;
+gap> for i in [1 .. Length(nonAltOrSymGroups)] do
+>     ri := RecogNode(nonAltOrSymGroups[i]);
+>     if FindHomMethodsGeneric.SnAnUnknownDegree(ri, Grp(ri)) = Success then
+>         Print("ERROR: Recognised group [", i, "] wrongly as Sn/An!\n");
+>     fi;
 > od;

tst/working/quick/GenericSnAnUnknownDegreeHelpers.tst

@@ -0,0 +1,103 @@
+# RECOG.IsFixedPoint
+gap> ri := RecogNode(SymmetricGroup(10));;
+gap> g := (1,2,3,4,5,6,7,8);;
+gap> c := (1,2,3);;
+gap> r := (1,2)(4,5,6);;
+gap> RECOG.IsFixedPoint(ri, g,c,r);
+true
+gap> r := (2,3,4);;
+gap> RECOG.IsFixedPoint(ri, g,c,r);
+false
+
+# RECOG.AdjustCycle
+gap> ri := RecogNode(SymmetricGroup(10));;
+gap> g := (1,2,3,4,5,6,7,8);;
+gap> c := (1,2,3);;
+gap> r := (4,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5)
+gap> r := (3,4,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,4,5)
+gap> r := (2,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5)
+gap> r := (2,4,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5,4)
+gap> r := (2,3,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,4,5)
+gap> r := (1,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5)
+gap> r := (1,4,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5,4)
+gap> r := (1,3,4,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,6,4,5)
+gap> r := (1,2,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5,4)
+gap> r := (1,2,3,5);;
+gap> RECOG.AdjustCycle(ri, g, c, r, 8);
+(3,5,4,6)
+
+# RECOG.BuildCycle
+gap> ri := RecogNode(SymmetricGroup(10));;
+
+# c = (u,v,w)
+gap> c := (1,2,3);;
+
+# Form 1: x = (v,a_1,...,a_alpha) * (w,b_1,....,b_beta) * (...)
+# alpha - beta = 0
+gap> x := (2,4,5,6)* (3,7,8,9);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = -1
+gap> x := (2,4,5,6)* (3,7,8,9,10);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = 1
+gap> x := (2,4,5,6,10)* (3,7,8,9);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = -2
+gap> x := (2,4,5) * (3,7,8,9,10);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,10,9), 9 ]
+
+# alpha - beta = 2
+gap> x := (2,4,5,6,10) * (3,7,8);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,10), 9 ]
+
+# Form 2: x = (v,a_1,...,a_alpha,w,b_1,....,b_beta) * (...)
+# alpha - beta = 0
+gap> x := (2,4,5,6,3,7,8,9);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = -1
+gap> x := (2,4,5,6,3,7,8,9,10);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = 1
+gap> x := (2,4,5,6,10,3,7,8,9);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,9), 9 ]
+
+# alpha - beta = -2
+gap> x := (2,4,5,3,7,8,9,10);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,10,9), 9 ]
+
+# alpha - beta = 2
+gap> x := (2,4,5,6,10,3,7,8);;
+gap> RECOG.BuildCycle(ri, c, x, 10);
+[ (1,2,3,4,7,5,8,6,10), 9 ]