From 027618ea6d392fe1dd32014d0ba7c3fde3690c65 Mon Sep 17 00:00:00 2001 From: Pranav Date: Thu, 30 May 2024 01:09:13 +0530 Subject: [PATCH 1/9] MinimalFaithfulPermutationDegreeOfSimpleGroup --- lib/grplatt.gi | 133 ++++++++++++++++++ ...FaithfulPermutationDegreeOfSimpleGroup.tst | 52 +++++++ 2 files changed, 185 insertions(+) create mode 100644 tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst diff --git a/lib/grplatt.gi b/lib/grplatt.gi index 4f7a0d5569..aac6480a56 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3654,6 +3654,139 @@ function(G) return DoMinimalFaithfulPermutationDegree(G,true); end); +BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroup", +function (G) + local + series, # series of simple groups + parameter, # parameters of G in series + info, # information regarding type of simple group + d, # mostly the dimension of vector space for classical groups + q, # elements in the field over which group is define + m, # first parameter + b, + name, + SporDegs, # The Minimal Permutation Degrees for sporadic groups + deg; + + info := IsomorphismTypeInfoFiniteSimpleGroup(G); + series := info.series; + + if series = "Spor" then + name := info.shortname; + SporDegs := [ + ["M11",11], + ["M12",12], + ["M22",22], + ["M23",23], + ["M24",24], + ["Co1",98280], + ["Co2",2300], + ["Co3",276], + ["McL",275], + ["HS",100], + ["Suz",1782], + ["Fi22",3510], + ["Fi23",31671], + ["Fi24",306936], + ["M",97239461142009186000], + ["B",13571955000], + ["Th",143127000], + ["HN",1140000], + ["He",2058], + ["J1",266], + ["J2",100], + ["J3",6156], + ["J4",173067389], + ["ON",122760], + ["Ly",8835156], + ["Ru",4060] + ]; + for deg in SporDegs do + if deg[1] = name then return deg[2]; fi; + od; + else + parameter := info.parameter; + if IsList(parameter) then + q := parameter[2]; + m := parameter[1]; + else q := parameter; fi; + fi; + if series = "Z" then + return q; + elif series = "A" then # Alt + return q; + elif series = "L" then # PSL + d := m; + if (d = 4 and q = 2) then return 8; fi; + if d = 2 then + if q = 9 then return 6; fi; + if q in [5,7,11] then return q; fi; + fi; + return (q^d-1)/(q-1); + elif series = "2A" then # PSU + d := m + 1; + if d = 3 and q = 5 then return 50; fi; + if d = 3 then return q^3 + 1; fi; + if d = 4 then return (q+1)*(q^3 + 1); fi; + if d mod 2 = 0 and q = 2 then return (2^(d-1)*(2^d - 1))/3; fi; + return ((q^d - (-1)^d)*(q^(d-1) + (-1)^d))/(q^2-1); + elif series = "B" then # P\Omega or O + d := 2*m +1; + if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; fi; + if q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); fi; + #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) + if q = 3 and m = 2 then return 27;fi; + # B(2,2) is not a simple group. + #Special case : B(2,q) ~ C(2,q) = PSp(4,q) + if m=2 then return (q^(2*m) -1)/(q-1);fi; + #Special case : B(m,2) ~ C(m,2) = PSp(2*m,2) + if q = 2 then return (2^(m-1))*(2^m -1); fi; + elif series = "2B" then # Sz or _2 B^2 + if 2^(Log2Int(q)) = q and Log2Int(q) mod 2 = 1 then + return q^2 + 1; + fi; + elif series = "C" then # PSp + d := 2*m; + if d=4 and q=2 then return 6;fi; + if d=4 and q=3 then return 27;fi; + if m>2 and q=2 then return (2^(m-1))*(2^m -1);fi; + if m>1 and q>2 then return (q^d -1)/(q-1);fi; + elif series = "D" then # P\Omega ^+ or O+ + d := 2*m; + if m > 3 then + if q < 4 then return q^(m-1)*(q^m -1)/(q-1); + else return (q^(m-1) + 1)*(q^m-1)/(q-1); fi; + fi; + elif series = "2D" then # P\Omega ^- or O- + d := 2*m; + if m > 3 then return (q^m+1)*(q^(m-1)-1)/(q-1);fi; + elif series = "3D" then # ^3 D_4 + return (q^8 + q^4 + 1)*(q+1); + elif series = "E" then #E_n(q) + d := m; + if d = 6 then return (q^9 - 1)*(q^8 + q^4 + 1)/(q-1); + elif d = 7 then return (q^14 - 1)*(q^9 + 1)*(q^5 -1)/(q-1); + elif d = 8 then return (q^30 - 1)*(q^12 + 1)*(q^10 + 1)*(q^6 + 1)/(q-1); + fi; + elif series = "2E" then #2E(6,q) + return (q^12 -1)*(q^6 - q^3 + 1)^(q^4 +1)/(q-1); + elif series = "F" then #F(4,q) + return (q^12 -1)*(q^4 + 1)/(q-1); + elif series = "2F" then #2F(4,q) + #special case : 2F4(2) ~ Tits + if q = 2 then return 1600; fi; + return (q^6 + 1)*(q^3 + 1)*(q+1); + elif series = "G" then #G(2,q) + if q = 3 then return 351; fi; + if q = 4 then return 416; fi; + return (q^6 -1)/(q-1); + elif series = "2G" then #2G(2,q) + b := Int(Log(Float(q)) / Log(3.0)); + if 3^(b+1) = q then b := b+1; fi; #just a safety net + if q = 3^b and b mod 2 = 1 then return q^3 + 1; fi; + fi; + return Concatenation("Couldn't fit", info.name,"aka",StructureDescriptionForFiniteSimpleGroups(G), "into a type","\n"); +end); # utility function: Find a subgroup $S$ of $G\le P$, with $G'\le S\le G$ such # that $[G:S]<=limit$ and that $S\lhd N_P(G)$. diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst new file mode 100644 index 0000000000..57d121dc24 --- /dev/null +++ b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst @@ -0,0 +1,52 @@ +gap> START_TEST("MinimalFaithfulPermutationDegreeOfSimpleGroup.tst"); +gap> checksimple := function(maxsize) +> local i,mu,mu2,info,G; +> i := 1; +> for G in SimpleGroupsIterator(1,maxsize) do +> mu := MinimalFaithfulPermutationDegree(G); +> mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroup(G); +> if mu2 <> mu then +> info := IsomorphismTypeInfoFiniteSimpleGroup(G); +> return Concatenation("Failed on simple group ",String(i)," i.e. ",info.name,"\n"); +> fi; +> i := i + 1; +> od; +> return "Passed"; +> end; +function( maxsize ) ... end +gap> checksimple(300000); +"Passed" +gap> LightChecknonabelianSimple := function(maxsize) +> local size,series,info,G,mu,mu2,mu3; +> for info in SIMPLEGPSNONL2 do +> size := info[1]; +> if size > maxsize then break; fi; +> series := info[2]; +> mu := Last(info); +> if IsString(info[3]) then #Spor +> G := SimpleGroup(info[3]); +> elif Length(info) = 5 then +> if info[4] = 0 then +> G := SimpleGroup(series,info[3]); +> else +> G := SimpleGroup(series,info[3],info[4]); +> fi; +> else +> Print(info,"\n"); +> continue; +> fi; +> mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroup(G); +> if mu < mu2 then +> return Concatenation("failed on",String(info),". From table :",String(mu),", Computed :",String(mu2),"\n"); +> elif mu > mu2 then +> mu3 := MinimalFaithfulPermutationDegree(G); +> if mu2 <> mu3 then +> return Concatenation("failed on",String(info),". From MinimalFaithfulPermutationDegree :",String(mu3),", Computed :",String(mu2),"\n"); +> fi; +> fi; +> od; +> return "PASS"; +> end; +function( maxsize ) ... end +gap> LightChecknonabelianSimple(1000000000); +"PASS" \ No newline at end of file From d6d67bf4030a129e5eccd1de56fdbf3be55ea8c0 Mon Sep 17 00:00:00 2001 From: Pranav Date: Sun, 2 Jun 2024 23:09:23 +0530 Subject: [PATCH 2/9] Added documentation --- doc/ref/groups.xml | 1 + lib/grplatt.gd | 25 +++++++++++++++++++++++++ lib/grplatt.gi | 5 ++--- 3 files changed, 28 insertions(+), 3 deletions(-) diff --git a/doc/ref/groups.xml b/doc/ref/groups.xml index 6638a8b9ad..9afbc9b51c 100644 --- a/doc/ref/groups.xml +++ b/doc/ref/groups.xml @@ -481,6 +481,7 @@ the series without destroying the properties of the series. <#Include Label="ContainedConjugates"> <#Include Label="ContainingConjugates"> <#Include Label="MinimalFaithfulPermutationDegree"> +<#Include Label="MinimalFaithfulPermutationDegreeOfSimpleGroup"> <#Include Label="RepresentativesPerfectSubgroups"> <#Include Label="ConjugacyClassesPerfectSubgroups"> <#Include Label="Zuppos"> diff --git a/lib/grplatt.gd b/lib/grplatt.gd index 857a23c853..85dfeec201 100644 --- a/lib/grplatt.gd +++ b/lib/grplatt.gd @@ -557,6 +557,31 @@ DeclareOperation("MinimalFaithfulPermutationDegree",[IsGroup and IsFinite]); DeclareOperation("MinimalFaithfulPermutationRepresentation", [IsGroup and IsFinite]); +############################################################################# +## +#F MinimalFaithfulPermutationDegreeOfSimpleGroup( ) +## +## <#GAPDoc Label="MinimalFaithfulPermutationDegreeOfSimpleGroup"> +## +## +## +## +## Return the minimal faithful permutation degree of G based +## on the type of simple group. This is much faster than +## +## but limited to simple groups only. +## MinimalFaithfulPermutationDegreeOfSimpleGroup(PSL(3,3)); +## 13 +## gap> MinimalFaithfulPermutationDegree(PSL(3,3)); +## 13 +## ]]> +## +## +## <#/GAPDoc> +## +DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSimpleGroup"); + ############################################################################# ## #F DescSubgroupIterator( ) diff --git a/lib/grplatt.gi b/lib/grplatt.gi index aac6480a56..d869a20823 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3654,8 +3654,7 @@ function(G) return DoMinimalFaithfulPermutationDegree(G,true); end); -BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroup", -function (G) +InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function (G) local series, # series of simple groups parameter, # parameters of G in series @@ -3785,7 +3784,7 @@ function (G) if 3^(b+1) = q then b := b+1; fi; #just a safety net if q = 3^b and b mod 2 = 1 then return q^3 + 1; fi; fi; - return Concatenation("Couldn't fit", info.name,"aka",StructureDescriptionForFiniteSimpleGroups(G), "into a type","\n"); + return Concatenation("Couldn't fit", info.name," aka ",StructureDescriptionForFiniteSimpleGroups(G), "into a type","\n"); end); # utility function: Find a subgroup $S$ of $G\le P$, with $G'\le S\le G$ such From c771b56086193626d0b632d3b3112c49afa51870 Mon Sep 17 00:00:00 2001 From: Pranav Date: Mon, 3 Jun 2024 14:31:26 +0530 Subject: [PATCH 3/9] InstallMethod for simple group --- lib/grplatt.gi | 3 +++ .../MinimalFaithfulPermutationDegreeOfSimpleGroup.tst | 8 ++++---- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/lib/grplatt.gi b/lib/grplatt.gi index d869a20823..b05a7250ce 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3787,6 +3787,9 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function (G) return Concatenation("Couldn't fit", info.name," aka ",StructureDescriptionForFiniteSimpleGroups(G), "into a type","\n"); end); +InstallMethod(MinimalFaithfulPermutationDegree,"for simple groups",true, + [IsSimpleGroup and IsFinite],0,MinimalFaithfulPermutationDegreeOfSimpleGroup); + # utility function: Find a subgroup $S$ of $G\le P$, with $G'\le S\le G$ such # that $[G:S]<=limit$ and that $S\lhd N_P(G)$. BindGlobal("BoundedIndexAbelianized",function(P,G,limit) diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst index 57d121dc24..979ac8a04b 100644 --- a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst +++ b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst @@ -3,7 +3,7 @@ gap> checksimple := function(maxsize) > local i,mu,mu2,info,G; > i := 1; > for G in SimpleGroupsIterator(1,maxsize) do -> mu := MinimalFaithfulPermutationDegree(G); +> mu := DoMinimalFaithfulPermutationDegree(G,false); > mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroup(G); > if mu2 <> mu then > info := IsomorphismTypeInfoFiniteSimpleGroup(G); @@ -14,7 +14,7 @@ gap> checksimple := function(maxsize) > return "Passed"; > end; function( maxsize ) ... end -gap> checksimple(300000); +gap> checksimple(50000); # first 26 simple groups "Passed" gap> LightChecknonabelianSimple := function(maxsize) > local size,series,info,G,mu,mu2,mu3; @@ -39,7 +39,7 @@ gap> LightChecknonabelianSimple := function(maxsize) > if mu < mu2 then > return Concatenation("failed on",String(info),". From table :",String(mu),", Computed :",String(mu2),"\n"); > elif mu > mu2 then -> mu3 := MinimalFaithfulPermutationDegree(G); +> mu3 := DoMinimalFaithfulPermutationDegree(G,false); > if mu2 <> mu3 then > return Concatenation("failed on",String(info),". From MinimalFaithfulPermutationDegree :",String(mu3),", Computed :",String(mu2),"\n"); > fi; @@ -48,5 +48,5 @@ gap> LightChecknonabelianSimple := function(maxsize) > return "PASS"; > end; function( maxsize ) ... end -gap> LightChecknonabelianSimple(1000000000); +gap> LightChecknonabelianSimple(1000000); # First 19 non abelian simple groups "PASS" \ No newline at end of file From 73be9d45a7bcecfb0cfc6d9637de4462cf7081cb Mon Sep 17 00:00:00 2001 From: Pranav Date: Tue, 4 Jun 2024 19:03:29 +0530 Subject: [PATCH 4/9] Saperated into 2 functions to test better. --- doc/ref/groups.xml | 1 - lib/grplatt.gd | 26 +-- lib/grplatt.gi | 173 +++++++++--------- ...FaithfulPermutationDegreeOfSimpleGroup.tst | 123 ++++++++++--- 4 files changed, 189 insertions(+), 134 deletions(-) diff --git a/doc/ref/groups.xml b/doc/ref/groups.xml index 9afbc9b51c..6638a8b9ad 100644 --- a/doc/ref/groups.xml +++ b/doc/ref/groups.xml @@ -481,7 +481,6 @@ the series without destroying the properties of the series. <#Include Label="ContainedConjugates"> <#Include Label="ContainingConjugates"> <#Include Label="MinimalFaithfulPermutationDegree"> -<#Include Label="MinimalFaithfulPermutationDegreeOfSimpleGroup"> <#Include Label="RepresentativesPerfectSubgroups"> <#Include Label="ConjugacyClassesPerfectSubgroups"> <#Include Label="Zuppos"> diff --git a/lib/grplatt.gd b/lib/grplatt.gd index 85dfeec201..ddf5691544 100644 --- a/lib/grplatt.gd +++ b/lib/grplatt.gd @@ -535,6 +535,8 @@ DeclareSynonym("EmbeddingConjugates",ContainingConjugates); ## positive integer n=\mu(G) such that G is isomorphic to a ## subgroup of the symmetric group of degree n. ## This can require calculating the whole subgroup lattice. +## In case you know that G is simple, use +## MinimalFaithfulPermutationDegreeOfSimpleGroup instead. ## The operation ## ## returns a @@ -556,30 +558,6 @@ DeclareSynonym("EmbeddingConjugates",ContainingConjugates); DeclareOperation("MinimalFaithfulPermutationDegree",[IsGroup and IsFinite]); DeclareOperation("MinimalFaithfulPermutationRepresentation", [IsGroup and IsFinite]); - -############################################################################# -## -#F MinimalFaithfulPermutationDegreeOfSimpleGroup( ) -## -## <#GAPDoc Label="MinimalFaithfulPermutationDegreeOfSimpleGroup"> -## -## -## -## -## Return the minimal faithful permutation degree of G based -## on the type of simple group. This is much faster than -## -## but limited to simple groups only. -## MinimalFaithfulPermutationDegreeOfSimpleGroup(PSL(3,3)); -## 13 -## gap> MinimalFaithfulPermutationDegree(PSL(3,3)); -## 13 -## ]]> -## -## -## <#/GAPDoc> -## DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSimpleGroup"); ############################################################################# diff --git a/lib/grplatt.gi b/lib/grplatt.gi index b05a7250ce..3e2422521e 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3654,67 +3654,65 @@ function(G) return DoMinimalFaithfulPermutationDegree(G,true); end); -InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function (G) +BindGlobal("SporadicGroupMinimalFaithfulPermutationDegrees", rec( + M11 := 11, + M12 := 12, + M22 := 22, + M23 := 23, + M24 := 24, + Co1 := 98280, + Co2 := 2300, + Co3 := 276, + McL := 275, + HS := 100, + Suz := 1782, + Fi22 := 3510, + Fi23 := 31671, + Fi24 := 306936, + M := 97239461142009186000, + B := 13571955000, + Th := 143127000, + HN := 1140000, + He := 2058, + J1 := 266, + J2 := 100, + J3 := 6156, + J4 := 173067389, + ON := 122760, + Ly := 8835156, + Ru := 4060, +)); + +BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType",function (info) + # This function is derived from table 4 of this paper : + # https://www.ams.org/journals/tran/2015-367-11/S0002-9947-2015-06293-X/S0002-9947-2015-06293-X.pdf + + # `info` is the a record containing information about the type of the simple group, + # like one obtained from `IsomorphismTypeInfoFiniteSimpleGroup`. You need to give the series, + # parameter, and shortname values in the record. local series, # series of simple groups - parameter, # parameters of G in series - info, # information regarding type of simple group d, # mostly the dimension of vector space for classical groups - q, # elements in the field over which group is define + q, # elements in the field over which group is defined m, # first parameter - b, - name, - SporDegs, # The Minimal Permutation Degrees for sporadic groups - deg; + b; # q = p^b for some prime p - info := IsomorphismTypeInfoFiniteSimpleGroup(G); series := info.series; - if series = "Spor" then - name := info.shortname; - SporDegs := [ - ["M11",11], - ["M12",12], - ["M22",22], - ["M23",23], - ["M24",24], - ["Co1",98280], - ["Co2",2300], - ["Co3",276], - ["McL",275], - ["HS",100], - ["Suz",1782], - ["Fi22",3510], - ["Fi23",31671], - ["Fi24",306936], - ["M",97239461142009186000], - ["B",13571955000], - ["Th",143127000], - ["HN",1140000], - ["He",2058], - ["J1",266], - ["J2",100], - ["J3",6156], - ["J4",173067389], - ["ON",122760], - ["Ly",8835156], - ["Ru",4060] - ]; - for deg in SporDegs do - if deg[1] = name then return deg[2]; fi; - od; + return SporadicGroupMinimalFaithfulPermutationDegrees.(info.shortname); else - parameter := info.parameter; - if IsList(parameter) then - q := parameter[2]; - m := parameter[1]; - else q := parameter; fi; + if IsList(info.parameter) then + q := info.parameter[2]; + m := info.parameter[1]; + else + q := info.parameter; + fi; fi; - if series = "Z" then + if series = "Z" then #Cyclic group of prime order return q; - elif series = "A" then # Alt + elif series = "A" then # Alternating group return q; - elif series = "L" then # PSL + elif series = "L" then # PSL(m,q) d := m; if (d = 4 and q = 2) then return 8; fi; if d = 2 then @@ -3722,69 +3720,72 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function (G) if q in [5,7,11] then return q; fi; fi; return (q^d-1)/(q-1); - elif series = "2A" then # PSU + elif series = "2A" then # PSU(m+1,q) d := m + 1; if d = 3 and q = 5 then return 50; fi; if d = 3 then return q^3 + 1; fi; if d = 4 then return (q+1)*(q^3 + 1); fi; if d mod 2 = 0 and q = 2 then return (2^(d-1)*(2^d - 1))/3; fi; return ((q^d - (-1)^d)*(q^(d-1) + (-1)^d))/(q^2-1); - elif series = "B" then # P\Omega or O - d := 2*m +1; - if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; fi; - if q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); fi; - #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) - if q = 3 and m = 2 then return 27;fi; - # B(2,2) is not a simple group. - #Special case : B(2,q) ~ C(2,q) = PSp(4,q) - if m=2 then return (q^(2*m) -1)/(q-1);fi; - #Special case : B(m,2) ~ C(m,2) = PSp(2*m,2) - if q = 2 then return (2^(m-1))*(2^m -1); fi; + elif series = "B" then # P\Omega(2*m+1,q) or O + if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; + elif q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); + elif q = 3 and m = 2 then return 27; #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) + elif q = 2 and m = 2 then # B(2,2) is not a simple group. + Error("B(2,2) is not a simple group. This shouldn't be happening.\n"); + elif m = 2 then return (q^(2*m) -1)/(q-1); #Special case : B(2,q) ~ C(2,q) = PSp(4,q) + elif q = 2 then return (2^(m-1))*(2^m -1); #Special case : B(m,2) ~ C(m,2) = PSp(2*m,2) + else Error("series B and m,q not of proper form\n"); fi; elif series = "2B" then # Sz or _2 B^2 - if 2^(Log2Int(q)) = q and Log2Int(q) mod 2 = 1 then - return q^2 + 1; - fi; - elif series = "C" then # PSp + b := Log2Int(q); + if 2^b = q and b mod 2 = 1 then return q^2 + 1; + else Error("2B series without q of proper form\n"); fi; + elif series = "C" then # PSp(2*m,q) d := 2*m; if d=4 and q=2 then return 6;fi; if d=4 and q=3 then return 27;fi; if m>2 and q=2 then return (2^(m-1))*(2^m -1);fi; if m>1 and q>2 then return (q^d -1)/(q-1);fi; - elif series = "D" then # P\Omega ^+ or O+ - d := 2*m; + Error("series C and m,q are not of proper form\n"); + elif series = "D" then # POmega(+1,2*m,q) or O+ if m > 3 then if q < 4 then return q^(m-1)*(q^m -1)/(q-1); else return (q^(m-1) + 1)*(q^m-1)/(q-1); fi; - fi; - elif series = "2D" then # P\Omega ^- or O- - d := 2*m; - if m > 3 then return (q^m+1)*(q^(m-1)-1)/(q-1);fi; + else Error("series D and m < 4\n"); fi; + elif series = "2D" then # POmega(-1,2*m,q) or O- + if m > 3 then return (q^m+1)*(q^(m-1)-1)/(q-1); + else Error("series 2D and m < 4\n"); fi; elif series = "3D" then # ^3 D_4 return (q^8 + q^4 + 1)*(q+1); elif series = "E" then #E_n(q) - d := m; - if d = 6 then return (q^9 - 1)*(q^8 + q^4 + 1)/(q-1); - elif d = 7 then return (q^14 - 1)*(q^9 + 1)*(q^5 -1)/(q-1); - elif d = 8 then return (q^30 - 1)*(q^12 + 1)*(q^10 + 1)*(q^6 + 1)/(q-1); + if m = 6 then return (q^9 - 1)*(q^8 + q^4 + 1)/(q-1); + elif m = 7 then return (q^14 - 1)*(q^9 + 1)*(q^5 -1)/(q-1); + elif m = 8 then return (q^30 - 1)*(q^12 + 1)*(q^10 + 1)*(q^6 + 1)/(q-1); + else Error("series E and m is not 6,7 or 8\n"); fi; elif series = "2E" then #2E(6,q) return (q^12 -1)*(q^6 - q^3 + 1)^(q^4 +1)/(q-1); elif series = "F" then #F(4,q) return (q^12 -1)*(q^4 + 1)/(q-1); elif series = "2F" then #2F(4,q) - #special case : 2F4(2) ~ Tits - if q = 2 then return 1600; fi; - return (q^6 + 1)*(q^3 + 1)*(q+1); + if q = 2 then return 1600; #special case : 2F4(2) ~ Tits + else return (q^6 + 1)*(q^3 + 1)*(q+1); fi; elif series = "G" then #G(2,q) - if q = 3 then return 351; fi; - if q = 4 then return 416; fi; - return (q^6 -1)/(q-1); + if q = 3 then return 351; + elif q = 4 then return 416; + else return (q^6 -1)/(q-1); fi; elif series = "2G" then #2G(2,q) - b := Int(Log(Float(q)) / Log(3.0)); - if 3^(b+1) = q then b := b+1; fi; #just a safety net - if q = 3^b and b mod 2 = 1 then return q^3 + 1; fi; + b := PValuation(q,3); + if q = 3^b and b mod 2 = 1 then return q^3 + 1; + else Error("series 2G and q not of proper form\n"); fi; fi; - return Concatenation("Couldn't fit", info.name," aka ",StructureDescriptionForFiniteSimpleGroups(G), "into a type","\n"); + Error("series `",series,"` is not valid\n"); +end); + +InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function(G) + local info; + info := IsomorphismTypeInfoFiniteSimpleGroup(G); #This requires computing Size(G) + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); end); InstallMethod(MinimalFaithfulPermutationDegree,"for simple groups",true, diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst index 979ac8a04b..e4c52b7d9e 100644 --- a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst +++ b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst @@ -16,37 +16,114 @@ gap> checksimple := function(maxsize) function( maxsize ) ... end gap> checksimple(50000); # first 26 simple groups "Passed" -gap> LightChecknonabelianSimple := function(maxsize) -> local size,series,info,G,mu,mu2,mu3; -> for info in SIMPLEGPSNONL2 do -> size := info[1]; -> if size > maxsize then break; fi; -> series := info[2]; -> mu := Last(info); -> if IsString(info[3]) then #Spor -> G := SimpleGroup(info[3]); -> elif Length(info) = 5 then -> if info[4] = 0 then -> G := SimpleGroup(series,info[3]); -> else -> G := SimpleGroup(series,info[3],info[4]); +gap> Clean := function(INFO) +> local SporNames,SeriesNames,info,name,q,size; +> info := ShallowCopy(INFO); +> SporNames := [ +> ["M11","M(11)"], +> ["M12","M(12)"], +> ["M22","M(22)"], +> ["M23","M(23)"], +> ["M24","M(24)"], +> ["J1","J(1)"], +> ["J2","J(2)"], +> ["J3","J(3)"], +> ["Co2","Co(2)"], +> ["Co3","Co(3)"], +> ["Fi22","Fi(22)"], +> ]; +> SeriesNames := [ +> ["U","2A"], +> ["S","C"], +> ["Sz","2B"], +> ["O+","D"], +> ["O-","2D"], +> ["O","B"], +> ]; +> if IsString(info[3]) then +> for name in SporNames do +> if name[2] = info[3] then +> info[3] := name[1]; > fi; -> else -> Print(info,"\n"); -> continue; +> od; +> if info[3] = "T" then +> info[2] := "2F"; +> info[3] := 2; +> info[4] := 0; > fi; -> mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroup(G); +> else +> for name in SeriesNames do +> if name[1] = info[2] then +> info[2] := name[2]; +> fi; +> if INFO[2] = "U" then info[3] := INFO[3] -1;fi; +> if INFO[2] in ["S","O+","O-"] then info[3] := INFO[3]/2; fi; +> if INFO[2] = "O" then info[3] := (INFO[3] -1)/2; fi; +> if not IsInt(info[3]) then Error("wierd .. ",INFO,"\n"); fi; +> if info[2] = "R" then +> q := info[3]; +> size := info[1]; +> if size = q^3 * (q^3 + 1) * (q-1) and PrimeDivisors(q) = [3] then +> info[2] := "2G"; +> elif size = q^12 * (q^6 + 1) * (q^4 -1) * (q^3+1) * (q-1) +> and PrimeDivisors(q) = [2] then +> info[2] := "2F"; +> else +> Error("Couldn't identify"); +> fi; +> fi; +> od; +> fi; +> return info; +> end; +function( INFO ) ... end +gap> MakeRecord := function(INFO) +> local info,parameter,series,shortname; +> if IsString(INFO[3]) then +> return rec( +> series := "Spor", +> parameter := INFO[4], +> shortname := INFO[3], +> ); +> fi; +> if INFO[4] = 0 then +> parameter := INFO[3]; +> else +> parameter := [INFO[3],INFO[4]]; +> fi; +> return rec( +> series := INFO[2], +> parameter := parameter, +> ); +> end; +function( INFO ) ... end +gap> LightChecknonabelianSimple := function(perfectTill) +> local size,series,INFO,G,mu,mu2,mu3,info; +> for INFO in SIMPLEGPSNONL2 do +> if LENGTH(INFO) <> 5 then continue; fi; +> size := INFO[1]; +> series := INFO[2]; +> mu := Last(INFO); +> info := MakeRecord(Clean(INFO)); +> mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); > if mu < mu2 then -> return Concatenation("failed on",String(info),". From table :",String(mu),", Computed :",String(mu2),"\n"); -> elif mu > mu2 then +> return Concatenation("failed on",String(INFO),". From table :",String(mu),", Computed :",String(mu2),"\n"); +> elif size <= perfectTill and mu>mu2 then +> if IsString(INFO[3]) then +> G := SimpleGroup(INFO[3]); +> elif INFO[4] = 0 then +> G := SimpleGroup(INFO[2],INFO[3]); +> else +> G := SimpleGroup(INFO[2],INFO[3],INFO[4]); +> fi; > mu3 := DoMinimalFaithfulPermutationDegree(G,false); > if mu2 <> mu3 then -> return Concatenation("failed on",String(info),". From MinimalFaithfulPermutationDegree :",String(mu3),", Computed :",String(mu2),"\n"); +> return Concatenation("failed on",String(INFO),". From MinimalFaithfulPermutationDegree :",String(mu3),", Computed :",String(mu2),"\n"); > fi; > fi; > od; > return "PASS"; > end; -function( maxsize ) ... end -gap> LightChecknonabelianSimple(1000000); # First 19 non abelian simple groups +function( perfectTill ) ... end +gap> LightChecknonabelianSimple(10^6); "PASS" \ No newline at end of file From 42f49ac7b298d6cf98c25e370eb23c5b8f98484d Mon Sep 17 00:00:00 2001 From: Pranav Date: Fri, 7 Jun 2024 19:18:44 +0530 Subject: [PATCH 5/9] fixed linting errors --- lib/grplatt.gi | 58 +++++++++++++++++++++++++------------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/lib/grplatt.gi b/lib/grplatt.gi index 3e2422521e..a0eda9c355 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3654,34 +3654,34 @@ function(G) return DoMinimalFaithfulPermutationDegree(G,true); end); -BindGlobal("SporadicGroupMinimalFaithfulPermutationDegrees", rec( - M11 := 11, - M12 := 12, - M22 := 22, - M23 := 23, - M24 := 24, - Co1 := 98280, - Co2 := 2300, - Co3 := 276, - McL := 275, - HS := 100, - Suz := 1782, - Fi22 := 3510, - Fi23 := 31671, - Fi24 := 306936, - M := 97239461142009186000, - B := 13571955000, - Th := 143127000, - HN := 1140000, - He := 2058, - J1 := 266, - J2 := 100, - J3 := 6156, - J4 := 173067389, - ON := 122760, - Ly := 8835156, - Ru := 4060, -)); +BindGlobal("SporadicGroupMinimalFaithfulPermutationDegrees", rec( + M11 := 11, + M12 := 12, + M22 := 22, + M23 := 23, + M24 := 24, + Co1 := 98280, + Co2 := 2300, + Co3 := 276, + McL := 275, + HS := 100, + Suz := 1782, + Fi22 := 3510, + Fi23 := 31671, + Fi24 := 306936, + M := 97239461142009186000, + B := 13571955000, + Th := 143127000, + HN := 1140000, + He := 2058, + J1 := 266, + J2 := 100, + J3 := 6156, + J4 := 173067389, + ON := 122760, + Ly := 8835156, + Ru := 4060, +)); BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType",function (info) # This function is derived from table 4 of this paper : @@ -3729,7 +3729,7 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType",fu return ((q^d - (-1)^d)*(q^(d-1) + (-1)^d))/(q^2-1); elif series = "B" then # P\Omega(2*m+1,q) or O if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; - elif q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); + elif q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); elif q = 3 and m = 2 then return 27; #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) elif q = 2 and m = 2 then # B(2,2) is not a simple group. Error("B(2,2) is not a simple group. This shouldn't be happening.\n"); From b4d1e73b8ee8cb5b98f5c9feb20bd65bee6f26e9 Mon Sep 17 00:00:00 2001 From: Pranav Date: Wed, 3 Jul 2024 01:18:00 +0530 Subject: [PATCH 6/9] Added a function for semi-simple groups --- lib/grplatt.gd | 6 +- lib/grplatt.gi | 333 ++++++++++++++++++ ...hfulPermutationDegreeOfSemiSimpleGroup.tst | 53 +++ 3 files changed, 390 insertions(+), 2 deletions(-) create mode 100644 tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst diff --git a/lib/grplatt.gd b/lib/grplatt.gd index ddf5691544..2c14c2c3b5 100644 --- a/lib/grplatt.gd +++ b/lib/grplatt.gd @@ -535,8 +535,9 @@ DeclareSynonym("EmbeddingConjugates",ContainingConjugates); ## positive integer n=\mu(G) such that G is isomorphic to a ## subgroup of the symmetric group of degree n. ## This can require calculating the whole subgroup lattice. -## In case you know that G is simple, use -## MinimalFaithfulPermutationDegreeOfSimpleGroup instead. +## In case you know that G is simple or semi-simple, you can use +## MinimalFaithfulPermutationDegreeOfSimpleGroup and +## MinimalFaithfulPermutationDegreeOfSemiSimpleGroup instead. ## The operation ## ## returns a @@ -559,6 +560,7 @@ DeclareOperation("MinimalFaithfulPermutationDegree",[IsGroup and IsFinite]); DeclareOperation("MinimalFaithfulPermutationRepresentation", [IsGroup and IsFinite]); DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSimpleGroup"); +DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSemiSimpleGroup"); ############################################################################# ## diff --git a/lib/grplatt.gi b/lib/grplatt.gi index a0eda9c355..4e3853f4b2 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3788,6 +3788,339 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function(G) return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); end); +######################################################################### +## +#F CanLiftPermutationDegreeToNormaliserOfPSL(,,,) +## +## Checks whether mu(A) = mu(S) when S is isomorphic to PSL(d,q), +## where A is an automorphism subgroup of S, +## made of all conjugators ^n for all n in normaliser of S in G, +## and mu(X) is the Minimal Faithful Permutation Degree of X. +## This is implemented, as described in this research paper: +## https://dl.acm.org/doi/10.1145/3618260.3649641 +BindGlobal("CanLiftPermutationDegreeToNormaliserOfPSL",function(S,G,d,q) + # S is a simple subgroup of G, which is isomorphic to PSL(d,q) + local + Sldq, # SL(d,q) with generators Slgen + Slgen, # Very specific generating set of SL(d,q) + p, # q = p^e + s,g, # Any element in S + m2, # A homomorphism between SL(d,q) and PSL(d,q) + i,j,x,r, # Dummy variables + pS, # PSL(d,q) + AutpSgens, # Generators of AutpS + lambda, # Any automorphism from Sldq to Sldq + C, # Centraliser of S in G, + # and later, the Center of Sldq, + m2lambm2inv, # A function that returns the composition m2inv * lambda * m2 , + # given lambda, where m2inv maps to the elements in coset with order p + AutSlgens, # Generators of AutSl + alpha, # The automorphism corresponding to m2lambm2inv + alphaSlgen, # Images of Slgen under alpha + StopS, # An isomorphism from S to pS + pStoS, # An isomorphism from pS to S + A, # Group of conjugation automorphisms of S with elements from G + U, # Any matrix in Slgen + N, # Normaliser of S in G + NbyC, # Natural Homomorphism from N, by normal subgroup C + Ngens, # Generators of N + AutS, # The group made of conjugator automorphisms ^n for all n in N, + # also called A. + NgensNeeded, # A minimal subset of Ngens that still creates AutS + good, # A boolean + n, # any element of N + AutSgens, # Generators of group AutS (also called A) + pSgens, # Generators of pS + StoS, # Any automorphism of S, can also be called lambda + alphapSgens, # Images of Hgens under alpha + h, # any element of pS + pStopS, # Any automorphism of pS, can also be called alpha + lambda_g, # Image of g under lambda (StoS) + alpha_h, # Image of h under alpha (pStoHpS) + AutpS, # The Automorphism subgroup of pS isomorphic to A + g_list, # preimages of pSgens under the isomorphism StopS + lambda_g_list, # Images of g_list under any isomorphism of S, StoS + L, # Any list + conj, # true if everything in A is a conjugator, + # upto a field automorphism + M, # Any matrix + f, # Any field automorphism of GF(q) + alphafinv, # alpha * f^-1 + scalars, # all required elements from GF(q) + flisinit, # initial list of field automorphisms + finvlisinit, # f^-1 for f in flisinit + findlis, # list of indices of flisinit + finvlis,finv, + FirstOfimagesOfscalarMatrices, + scalarMatrices,imagesOfscalars, + MakeFieldAutomorphismOfSL,finvmatrixlist; + + # Computing Normaliser and Centraliser + N := Normaliser(G,S); + C := Centraliser(G,S); + Ngens := SmallGeneratingSet(N); + + # Computing NgensNeeded + NbyC := NaturalHomomorphismByNormalSubgroupNC(N,C); + NgensNeeded := ImagesSet(NbyC,Ngens); + NgensNeeded := List(NgensNeeded,x->PreImagesRepresentative(NbyC,x)); + + # Finding generators of AutS (A) + AutSgens := List(NgensNeeded,n -> ConjugatorAutomorphismNC(S,n)); + + # Calculating Sldq + p := PrimeDivisors(q)[1]; + Slgen := []; + for i in [1..d] do + for j in [1..d] do + if i=j then continue; fi; + for r in [0,1..p-1] do + U := IdentityMatrix(GF(q),d); + U[i][j] := Z(q)^r; + Add(Slgen,U); + od; + od; + od; + Sldq := GroupWithGenerators(Slgen); + + # Calculating m2 and pS + C := Center(Sldq); + m2 := NaturalHomomorphismByNormalSubgroupNC(Sldq,C); + pS := Image(m2); #PSL group + + # Calculating StopS + StopS := IsomorphismSimpleGroups(S,pS); # Isomorphism between S and pS + + # Calculating AutpSgens + AutpSgens := List(AutSgens,x -> InducedAutomorphism(StopS,x)); + + # Function to get alpha for any lambda + m2lambm2inv := function(U,lambda,m2,C,p) + local ZU,ZV,VZrep,V; + ZU := Image(m2,U); + ZV := Image(lambda,ZU); + VZrep := PreImagesRepresentative(m2,ZV); + ZV := RightCoset(C,VZrep); + for V in ZV do + if Order(V) = p then return V; fi; + od; + end; + + # Calculating AutSl + AutSlgens := []; + for lambda in AutpSgens do + alphaSlgen := List(Slgen,U -> m2lambm2inv(U,lambda,m2,C,p)); + alpha := GroupHomomorphismByImagesNC(Sldq,Sldq,Slgen,alphaSlgen); + Add(AutSlgens,alpha); + od; + + # Checking if AutSlgens contains an automorphism that is not a + # conjugator automorphism times a field automorphism. + scalars := Filtered(GF(q), x -> x^d = One(GF(q))); + scalars := SmallGeneratingSet(AsGroup(scalars)); + scalarMatrices := List(scalars,x -> x * IdentityMatrix(GF(q),d)); + f := FrobeniusAutomorphism(GF(q)); + flisinit := List([1..Order(f)],x->f^x); + finvlisinit := List(flisinit,f -> f^-1); + imagesOfscalars := List(flisinit,f -> List(scalars,f)); + MakeFieldAutomorphismOfSL := function(f) + local gens,row,M,applyfonrow,applyf,fgens,x; + gens := GeneratorsOfGroup(Sldq); + applyfonrow := row -> List(row,x -> Image(f,x)); + applyf := M -> List(M,applyfonrow); + fgens := List(gens,applyf); + return GroupHomomorphismByImagesNC(Sldq,Sldq,gens,fgens); + end; + finvmatrixlist := List(finvlisinit,MakeFieldAutomorphismOfSL); + for alpha in AutSlgens do + conj := false; + FirstOfimagesOfscalarMatrices := List(scalarMatrices,M -> alpha(M)[1][1]); + findlis := Filtered([1..Length(flisinit)], i -> FirstOfimagesOfscalarMatrices = imagesOfscalars[i]); + finvlis := List(findlis,i -> finvmatrixlist[i]); + for finv in finvlis do + alphafinv := alpha * finv; + if IsConjugatorAutomorphism(alphafinv) then + conj := true; + break; + fi; + od; + if not conj then return false; fi; + od; + + return true; +end); + +################################################################################## +## +#F MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(,) +## +## Returns mu(A) where S < A < Aut(S) for simple group S +## if it can compute it easily, else returns -1. +## For more details, take a look at this paper : +## https://www.sciencedirect.com/science/article/pii/S0747717118300993 +BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup",function(A,S) + local info,d,q,m,series,name,parameter,mu,Aut,b,sizeS,sizeA; + + # Just for convenience + Aut := AutomorphismGroup; + mu := MinimalFaithfulPermutationDegreeOfSimpleGroup; + + if IsInt(A) then sizeA := A; + else sizeA := Size(A); fi; + sizeS := Size(S); + info := IsomorphismTypeInfoFiniteSimpleGroup(S); + series := info.series; + name := info.shortname; + + if series = "Spor" then + if name = "M12" and + sizeA = Size(Aut(S)) #A = Aut(S) + then return 2 * mu(S); + elif name = "ON" and + sizeA = Size(Aut(S)) #A = Aut(S) + then return 2 * mu(S); + fi; + else # Set q and m + parameter := info.parameter; + if IsList(parameter) then + q := parameter[2]; + m := parameter[1]; + else q := parameter; fi; + fi; + + if series = "A" and q = 6 then + #if not A <~ SymmetricGroup(6) then return 10; fi; + if 720 mod sizeA <> 0 then return 10; + else return -1; fi; + + elif series = "L" then + d := m; + if d = 2 and q = 7 then + # if A ~ PGL(2,7) then return 8; fi; + # PGL(2,7) is isomorphic to Aut(PSL(2,7)) which is Aut(S) which has a subgroup isomorphic to A + # Thus A <~ PGL(2,7); So, the only requirement for isomorphism is that Size(A) = Size(PGL(2,7)) = 336 + if sizeA = 336 then return 8; fi; + elif d > 2 and not (q = 2 and (d = 3 or d = 4)) then + #if not A <~ GammaL(d,q) then return 2 * mu(S); + if Size(GammaL(d,q)) mod sizeA <> 0 then return 2 * mu(S); + else return -1; fi; + fi; + + elif series = "2A" # PSU + and m+1 = 3 + and q = 5 then + #if not A <~ PSigmaU(3,5) then return 126; fi; + if 126000 mod sizeA <> 0 then return 126; + else return -1; fi; + + elif series = "D" then #P\Omega^+ + d := 2*m; + if d = 8 and q = 2 + and sizeA/sizeS mod 3 = 0 + then return 3 * mu(S); + elif d = 8 and q = 3 + and sizeA/sizeS mod 3 = 0 + and sizeA/sizeS mod 12 <> 0 + then return 3 * mu(S); + elif d = 8 and q = 3 + and sizeA/sizeS mod 12 = 0 + then return 3360; + elif d = 8 + and sizeA/sizeS mod 3 = 0 + then return 3 * mu(S); + elif q = 3 and + d > 7 and + sizeA/sizeS mod 3 <> 0 and + Size(PGO(1,2*d,3)) mod sizeA <>0 # (*) + then return (3^(m-1) + 1) * (3^m -1) / 2 ; + else return -1; + fi; + + elif series = "G" then + #if q = 3 and Iso(A,Aut(S)) then return 2 * mu(S);fi; + if q = 3 and sizeA = Size(Aut(S)) then return 2 * mu(S); fi; + #This is because A is isomorphic to a subgroup in Aut(S) that contains Inn(S) \cong S at any point. + b := Int(Log(Float(q))/Log(3.0)); + if 3^(b+1) = q then b := b+1; fi; # Just a safety net + if 3^b = q and b >1 then + #if not A <~ GammaG(q) then return 2 * mu(S); fi; + if Size(GF(q))*Size(GaloisGroup(AsField(GF(q),GF(3)))) mod sizeA <> 0 then return 2 * mu(S); + else return -1; fi; + fi; + elif series = "C" #PSp + and m = 2 + and 2^Log2Int(q) = q + and q > 3 then + #if not A <~ PGammaSp(d,q) then return 2*mu(S); fi; + if sizeS * Size(GaloisGroup(AsField(GF(q),GF(2)))) mod sizeA <> 0 then return 2 * mu(S); + else return -1; fi; + elif series = "F" and 2^Log2Int(q) = q then + #if not A <~ GammaF(d,q) then return 2*mu(S); fi; + if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); + else return -1; fi; + elif series = "E" and m = 6 then + #if not A <~ GammaE(d,q) then return 2*mu(S); fi; + if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); + else return -1; fi; + fi; + return MinimalFaithfulPermutationDegreeOfSimpleGroup(S); +end); + +################################################################################## +## +#F MinimalFaithfulPermutationDegreeOfSemiSimpleGroup() +## +## Returns the minimal faithful permutation degree for a semi-simple group G, +## which is a group that doesn't contain any abelian normal subgroups. +## The function is based on this research paper : +## https://dl.acm.org/doi/10.1145/3618260.3649641 +InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSemiSimpleGroup,function(G) + local + mu, # Objective value to compute + Slis, # Decomposition of N as direct product of simple groups + N, # Any minimal normal subgroup of G + NGS, # Normaliser of S in G + CGS, # Centraliser of S in G + phi, # Homomorphism from NGS to NGS/CGS + A, # NGS/CGS =~ {^n for n in N_G(S)} + muA, # Minimal Permutation Degree of A + sizeA, # Size(A) + S, # Slis[1] =~ Slis[i] + info, # Information about isomorphism type of S + MNS; + mu := 0; + MNS := MinimalNormalSubgroups(G); + if Length(MNS) = 1 and MNS[1] = G then return MinimalFaithfulPermutationDegreeOfSimpleGroup(G); fi; + for N in MNS do + Slis := DirectFactorsOfGroup(N); + S := Slis[1]; + NGS := Normalizer(G,S); + CGS := Centralizer(G,S); + sizeA := Size(NGS)/Size(CGS); + muA := MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(sizeA,S); + if muA = -1 then + info := IsomorphismTypeInfoFiniteSimpleGroup(S); + if info.series = "L" + and info.parameter[1] > 2 + and not (info.parameter[2] = 2 and (info.parameter[1] in [3,4])) then + #Print("\t PSL type simple subgroup\n"); + if CanLiftPermutationDegreeToNormaliserOfPSL(S,G,info.parameter[1],info.parameter[2]) then + muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + muA := 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + fi; + else + #Print("\t Leaving to Lattice Algo\n"); + phi := NaturalHomomorphismByNormalSubgroupNC(NGS,CGS); + A := Image(phi); + muA := MinimalFaithfulPermutationDegree(A); + fi; + fi; + mu := mu + (Length(Slis) * muA); + od; + return mu; +end); + InstallMethod(MinimalFaithfulPermutationDegree,"for simple groups",true, [IsSimpleGroup and IsFinite],0,MinimalFaithfulPermutationDegreeOfSimpleGroup); diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst new file mode 100644 index 0000000000..9bdbdd755a --- /dev/null +++ b/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst @@ -0,0 +1,53 @@ +gap> START_TEST("MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst"); +gap> CheckInList := function(L,Mus) +> local i,stop,mu,mu2,G,g; +> for i in [1..Length(L)] do +> G := L[i]; +> if IsList(Mus) then mu := Mus[i]; +> else +> mu := DoMinimalFaithfulPermutationDegree(G,false); +> fi; +> mu2 := MinimalFaithfulPermutationDegreeOfSemiSimpleGroup(G); +> if mu2 = mu then +> else +> return Concatenation("F.A.I.L on",String(G)); +> fi; +> od; +> return "pass"; +> end;; +gap> +gap> TestCases := Filtered(List(SimpleGroupsIterator(2,50000)), +> G->IsPSL(G) or (Size(G) < 1000 and not IsAbelian(G)));; +gap> Degs := List(TestCases,MinimalFaithfulPermutationDegree);; +gap> l := Length(TestCases);; +gap> for i in [1..l] do +> for j in [1..i] do +> G := DirectProduct(TestCases[i],TestCases[j]); +> Add(TestCases,G); +> Add(Degs,Degs[i] + Degs[j]); +> od; +> od; +gap> +gap> SemiSimpleGroupsTillSize1000 := [ +> SmallGroup(60,5), +> SmallGroup(120,34), +> SmallGroup(168,42), +> SmallGroup(336,208), +> SmallGroup(360,118), +> SmallGroup(504,156), +> SmallGroup(660,13), +> SmallGroup(720,763), +> SmallGroup(720,764), +> SmallGroup(720,765), +> #sizes 512 and 768 skipped +> ];; +gap> +gap> +gap> # Semi Simple Groups below size 1000 +gap> CheckInList(SemiSimpleGroupsTillSize1000,-1); +"pass" +gap> +gap> # Products of Simple Groups +gap> ind := List([1..30],x->Random([1..Length(TestCases)]));; +gap> CheckInList(List(ind,n->TestCases[n]),List(ind,n->Degs[n])); +"pass" \ No newline at end of file From b70fa74e513773ee1f44290b3b8a4749fffd37bf Mon Sep 17 00:00:00 2001 From: Pranav Date: Mon, 8 Jul 2024 06:43:11 +0530 Subject: [PATCH 7/9] Added lifting algorithms for PSp and POmega+ --- lib/grplatt.gi | 231 ++++++++++++++++++++++++++++++++++++------------- 1 file changed, 171 insertions(+), 60 deletions(-) diff --git a/lib/grplatt.gi b/lib/grplatt.gi index 4e3853f4b2..2bf956370e 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3790,19 +3790,23 @@ end); ######################################################################### ## -#F CanLiftPermutationDegreeToNormaliserOfPSL(,,,) +#F CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(,,,,) ## -## Checks whether mu(A) = mu(S) when S is isomorphic to PSL(d,q), +## Checks whether mu(A) = mu(S) when S is isomorphic to the +## simple matrix group specified by "d","q" and "type", ## where A is an automorphism subgroup of S, ## made of all conjugators ^n for all n in normaliser of S in G, ## and mu(X) is the Minimal Faithful Permutation Degree of X. ## This is implemented, as described in this research paper: ## https://dl.acm.org/doi/10.1145/3618260.3649641 -BindGlobal("CanLiftPermutationDegreeToNormaliserOfPSL",function(S,G,d,q) - # S is a simple subgroup of G, which is isomorphic to PSL(d,q) +BindGlobal("CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup",function(S,G,d,q,type) + # S is a simple subgroup of G, which is isomorphic to PSL(d,q) , or PSp(d,q) , or POmega(1,2d,q) + # type is the type of simple group we are dealing with ("PSL","PSp","POmega+") + # For the sake of sanity, the varaibles are chosen to represent the process for type="PSL" only, + # but work functionally, for every type of simple matrix group specified. local Sldq, # SL(d,q) with generators Slgen - Slgen, # Very specific generating set of SL(d,q) + Slgen, # Very specific generating set of SL(d,q), or correspoding group based on "type" p, # q = p^e s,g, # Any element in S m2, # A homomorphism between SL(d,q) and PSL(d,q) @@ -3853,7 +3857,7 @@ BindGlobal("CanLiftPermutationDegreeToNormaliserOfPSL",function(S,G,d,q) finvlis,finv, FirstOfimagesOfscalarMatrices, scalarMatrices,imagesOfscalars, - MakeFieldAutomorphismOfSL,finvmatrixlist; + MakeFieldAutomorphismOfSldq,finvmatrixlist,O,phi,PO,POgens; # Computing Normaliser and Centraliser N := Normaliser(G,S); @@ -3871,39 +3875,116 @@ BindGlobal("CanLiftPermutationDegreeToNormaliserOfPSL",function(S,G,d,q) # Calculating Sldq p := PrimeDivisors(q)[1]; Slgen := []; - for i in [1..d] do - for j in [1..d] do - if i=j then continue; fi; - for r in [0,1..p-1] do - U := IdentityMatrix(GF(q),d); - U[i][j] := Z(q)^r; - Add(Slgen,U); + if type = "PSL" then + for i in [1..d] do + for j in [1..d] do + if i=j then continue; fi; + for r in [0,1..p-1] do + U := IdentityMatrix(GF(q),d); + U[i][j] := Z(q)^r; + Add(Slgen,U); + od; od; od; - od; + elif type="POmega+" then + for j in [2..d] do + for i in [1..j-1] do + for r in [0,1..q-2] do + # I + z(e_{i,j} - e_{-j,-i}) + U := IdentityMatrix(GF(q),2*d); + U[i][j] := Z(q)^r; + U[d+j][d+i] := -Z(q)^r; + Add(Slgen,U); + # I + z(e_{j,i} - e_{-i,-j}) + U := IdentityMatrix(GF(q),2*d); + U[j][i] := Z(q)^r; + U[d+i][d+j] := -Z(q)^r; + Add(Slgen,U); + # I + z(e_{i,-i} - e_{j,-i}) + U := IdentityMatrix(GF(q),2*d); + U[i][d+j] := Z(q)^r; + U[j][d+i] := -Z(q)^r; + Add(Slgen,U); + # I + z(e_{-i,j} - e_{-j,i}) + U := IdentityMatrix(GF(q),2*d); + U[d+i][j] := Z(q)^r; + U[d+j][i] := -Z(q)^r; + Add(Slgen,U); + od; + od; + od; + d := 2*d; + elif type="PSp" then + for j in [2..d] do + for i in [1..j-1] do + for r in [0,1..q-2] do + # I + z(e_{i,j} - e_{-j,-i}) + U := IdentityMatrix(GF(q),2*d); + U[i][j] := Z(q)^r; + U[d+j][d+i] := -Z(q)^r; + Add(Slgen,U); + # I - z(e_{-i,-j} - e_{j,i}) + U := IdentityMatrix(GF(q),2*d); + U[j][i] := Z(q)^r; + U[d+i][d+j] := -Z(q)^r; + Add(Slgen,U); + # I + z(e_{i,-i} + e_{j,-i}) + U := IdentityMatrix(GF(q),2*d); + U[i][d+j] := Z(q)^r; + U[j][d+i] := Z(q)^r; + Add(Slgen,U); + # I - z( - e_{-i,j} - e_{-j,i}) + U := IdentityMatrix(GF(q),2*d); + U[d+i][j] := Z(q)^r; + U[d+j][i] := Z(q)^r; + Add(Slgen,U); + od; + od; + od; + for i in [1..d] do + # I + z e_{i,-i} + U := IdentityMatrix(GF(q),2*d); + U[i][d+i] := Z(q)^r; + Add(Slgen,U); + # I + z e_{-i,i} + U := IdentityMatrix(GF(q),2*d); + U[d+i][i] := Z(q)^r; + Add(Slgen,U); + od; + d := 2*d; + fi; Sldq := GroupWithGenerators(Slgen); # Calculating m2 and pS - C := Center(Sldq); + if type="PSL" or type="PSp" then + C := Center(Sldq); + elif type="POmega+" then + C := Center(GO(1,d,q)); + C := Filtered(C,x->x in Sldq); #There are only O(q) elements in C + C := AsGroup(C); + fi; m2 := NaturalHomomorphismByNormalSubgroupNC(Sldq,C); - pS := Image(m2); #PSL group + pS := Image(m2); #PSL(d,q),PSp(d,q),or POmega+(2d,q) # Calculating StopS StopS := IsomorphismSimpleGroups(S,pS); # Isomorphism between S and pS + if StopS = fail then StopS := IsomorphismGroups(S,pS);fi; # Calculating AutpSgens AutpSgens := List(AutSgens,x -> InducedAutomorphism(StopS,x)); # Function to get alpha for any lambda m2lambm2inv := function(U,lambda,m2,C,p) - local ZU,ZV,VZrep,V; - ZU := Image(m2,U); - ZV := Image(lambda,ZU); - VZrep := PreImagesRepresentative(m2,ZV); - ZV := RightCoset(C,VZrep); - for V in ZV do + local UZ,VZ,VZrep,V; + UZ := Image(m2,U); + VZ := Image(lambda,UZ); + VZrep := PreImagesRepresentative(m2,VZ); + if Size(C)=1 then return VZrep;fi; + VZ := RightCoset(C,VZrep); + for V in VZ do if Order(V) = p then return V; fi; od; + Error("No element found"); end; # Calculating AutSl @@ -3923,30 +4004,46 @@ BindGlobal("CanLiftPermutationDegreeToNormaliserOfPSL",function(S,G,d,q) flisinit := List([1..Order(f)],x->f^x); finvlisinit := List(flisinit,f -> f^-1); imagesOfscalars := List(flisinit,f -> List(scalars,f)); - MakeFieldAutomorphismOfSL := function(f) - local gens,row,M,applyfonrow,applyf,fgens,x; - gens := GeneratorsOfGroup(Sldq); + MakeFieldAutomorphismOfSldq := function(f) + local row,M,applyfonrow,applyf,fgens,x; applyfonrow := row -> List(row,x -> Image(f,x)); applyf := M -> List(M,applyfonrow); - fgens := List(gens,applyf); - return GroupHomomorphismByImagesNC(Sldq,Sldq,gens,fgens); + fgens := List(Slgen,applyf); + return GroupHomomorphismByImagesNC(Sldq,Sldq,Slgen,fgens); end; - finvmatrixlist := List(finvlisinit,MakeFieldAutomorphismOfSL); - for alpha in AutSlgens do - conj := false; - FirstOfimagesOfscalarMatrices := List(scalarMatrices,M -> alpha(M)[1][1]); - findlis := Filtered([1..Length(flisinit)], i -> FirstOfimagesOfscalarMatrices = imagesOfscalars[i]); - finvlis := List(findlis,i -> finvmatrixlist[i]); - for finv in finvlis do - alphafinv := alpha * finv; - if IsConjugatorAutomorphism(alphafinv) then - conj := true; - break; - fi; - od; - if not conj then return false; fi; - od; + finvmatrixlist := List(finvlisinit,MakeFieldAutomorphismOfSldq); + if type="PSL" or type="PSp" then + for alpha in AutSlgens do + conj := false; + FirstOfimagesOfscalarMatrices := List(scalarMatrices,M -> alpha(M)[1][1]); + findlis := Filtered([1..Length(flisinit)], i -> FirstOfimagesOfscalarMatrices = imagesOfscalars[i]); + finvlis := List(findlis,i -> finvmatrixlist[i]); + for finv in finvlis do + alphafinv := alpha * finv; + if IsConjugatorAutomorphism(alphafinv) then + conj := true; + break; + fi; + od; + if not conj then return false; fi; + od; + elif type="POmega+" then + O := GO(1,d,q); + C := Center(GO(1,d,q)); + phi := NaturalHomomorphismByNormalSubgroupNC(O,C); + PO := Image(phi); + POgens := GeneratorsOfGroup(PO); + POgens := List(POgens,x -> PreImagesRepresentative(phi,x)); + POgens := List(POgens,x-> ConjugatorAutomorphismNC(Sldq,x)); + PO := GroupWithGenerators(POgens); + if d > 8 then + for alpha in AutSlgens do + if not alpha in PO then return false; fi; + od; + elif d = 8 then + fi; + fi; return true; end); @@ -4006,12 +4103,11 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou else return -1; fi; fi; - elif series = "2A" # PSU + elif series = "2A" # PSU(3,5) and m+1 = 3 and q = 5 then #if not A <~ PSigmaU(3,5) then return 126; fi; - if 126000 mod sizeA <> 0 then return 126; - else return -1; fi; + return -1; elif series = "D" then #P\Omega^+ d := 2*m; @@ -4028,20 +4124,18 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou elif d = 8 and sizeA/sizeS mod 3 = 0 then return 3 * mu(S); - elif q = 3 and - d > 7 and - sizeA/sizeS mod 3 <> 0 and - Size(PGO(1,2*d,3)) mod sizeA <>0 # (*) + elif q = 3 and d > 7 and + sizeA/sizeS mod 3 <> 0 then + if Size(PGO(1,d,3)) mod sizeA <>0 # (*) then return (3^(m-1) + 1) * (3^m -1) / 2 ; - else return -1; + else return -1; fi; fi; elif series = "G" then #if q = 3 and Iso(A,Aut(S)) then return 2 * mu(S);fi; if q = 3 and sizeA = Size(Aut(S)) then return 2 * mu(S); fi; #This is because A is isomorphic to a subgroup in Aut(S) that contains Inn(S) \cong S at any point. - b := Int(Log(Float(q))/Log(3.0)); - if 3^(b+1) = q then b := b+1; fi; # Just a safety net + b := LogInt(q,3); if 3^b = q and b >1 then #if not A <~ GammaG(q) then return 2 * mu(S); fi; if Size(GF(q))*Size(GaloisGroup(AsField(GF(q),GF(3)))) mod sizeA <> 0 then return 2 * mu(S); @@ -4052,8 +4146,7 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou and 2^Log2Int(q) = q and q > 3 then #if not A <~ PGammaSp(d,q) then return 2*mu(S); fi; - if sizeS * Size(GaloisGroup(AsField(GF(q),GF(2)))) mod sizeA <> 0 then return 2 * mu(S); - else return -1; fi; + return -1; elif series = "F" and 2^Log2Int(q) = q then #if not A <~ GammaF(d,q) then return 2*mu(S); fi; if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); @@ -4063,7 +4156,7 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); else return -1; fi; fi; - return MinimalFaithfulPermutationDegreeOfSimpleGroup(S); + return mu(S); end); ################################################################################## @@ -4087,7 +4180,7 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSemiSimpleGroup,function sizeA, # Size(A) S, # Slis[1] =~ Slis[i] info, # Information about isomorphism type of S - MNS; + MNS,m,q; mu := 0; MNS := MinimalNormalSubgroups(G); if Length(MNS) = 1 and MNS[1] = G then return MinimalFaithfulPermutationDegreeOfSimpleGroup(G); fi; @@ -4100,15 +4193,33 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSemiSimpleGroup,function muA := MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(sizeA,S); if muA = -1 then info := IsomorphismTypeInfoFiniteSimpleGroup(S); - if info.series = "L" - and info.parameter[1] > 2 - and not (info.parameter[2] = 2 and (info.parameter[1] in [3,4])) then + if not IsList(info.parameter) then q := info.parameter; + else m := info.parameter[1]; q := info.parameter[2]; fi; + if info.series = "L" #PSL + and m > 2 + and not (q = 2 and (m in [3,4])) then #Print("\t PSL type simple subgroup\n"); - if CanLiftPermutationDegreeToNormaliserOfPSL(S,G,info.parameter[1],info.parameter[2]) then + if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"PSL") then muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); else muA := 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); fi; + elif info.series ="C" #PSp + and m = 2 + and 2^Log2Int(info.parameter[2]) = info.parameter[2] then + if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"PSp") then + muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + muA := 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + fi; + elif info.series ="D" #POmega+ + and q = 3 + and m >= 4 then + if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"POmega+") then + muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + muA := (3^(m-1) + 1) * (3^m -1) / 2 ; + fi; else #Print("\t Leaving to Lattice Algo\n"); phi := NaturalHomomorphismByNormalSubgroupNC(NGS,CGS); From 2cca02bf1fd9b36b34e713369fc492a40b43a1b4 Mon Sep 17 00:00:00 2001 From: Pranav Date: Fri, 26 Jul 2024 12:40:54 +0530 Subject: [PATCH 8/9] Removed function for simple group input --- grp/simple.gd | 1 + grp/simple.gi | 129 +++++++++++++++++++++ lib/grplatt.gd | 1 - lib/grplatt.gi | 305 ++++++++++++++++--------------------------------- 4 files changed, 230 insertions(+), 206 deletions(-) diff --git a/grp/simple.gd b/grp/simple.gd index 7863ef7c79..882cee7ed1 100644 --- a/grp/simple.gd +++ b/grp/simple.gd @@ -121,6 +121,7 @@ BindGlobal("SIMPLE_GROUPS_ITERATOR_RANGE",10^27); ## <#/GAPDoc> DeclareGlobalFunction("ClassicalIsomorphismTypeFiniteSimpleGroup"); +DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType"); DeclareAttribute("DataAboutSimpleGroup",IsGroup,"mutable"); ############################################################################# diff --git a/grp/simple.gi b/grp/simple.gi index 30abd8f5a7..29f90d38ee 100644 --- a/grp/simple.gi +++ b/grp/simple.gi @@ -954,6 +954,134 @@ local p,e,f,rels,gp; return gp; end); +BindGlobal("SporadicGroupMinimalFaithfulPermutationDegrees", rec( + M11 := 11, + M12 := 12, + M22 := 22, + M23 := 23, + M24 := 24, + Co1 := 98280, + Co2 := 2300, + Co3 := 276, + McL := 275, + HS := 100, + Suz := 1782, + Fi22 := 3510, + Fi23 := 31671, + Fi24 := 306936, + M := 97239461142009186000, + B := 13571955000, + Th := 143127000, + HN := 1140000, + He := 2058, + J1 := 266, + J2 := 100, + J3 := 6156, + J4 := 173067389, + ON := 122760, + Ly := 8835156, + Ru := 4060, +)); + +InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType,function (info) + # This function is derived from table 4 of this paper : + # https://www.ams.org/journals/tran/2015-367-11/S0002-9947-2015-06293-X/S0002-9947-2015-06293-X.pdf + + # `info` is the a record containing information about the type of the simple group, + # like one obtained from `IsomorphismTypeInfoFiniteSimpleGroup`. You need to give the series, + # parameter, and shortname values in the record. + local + series, # series of simple groups + d, # mostly the dimension of vector space for classical groups + q, # elements in the field over which group is defined + m, # first parameter + b; # q = p^b for some prime p + + series := info.series; + if series = "Spor" then + return SporadicGroupMinimalFaithfulPermutationDegrees.(info.shortname); + else + if IsList(info.parameter) then + q := info.parameter[2]; + m := info.parameter[1]; + else + q := info.parameter; + fi; + fi; + if series = "Z" then #Cyclic group of prime order + return q; + elif series = "A" then # Alternating group + return q; + elif series = "L" then # PSL(m,q) + d := m; + if (d = 4 and q = 2) then return 8; fi; + if d = 2 then + if q = 9 then return 6; fi; + if q in [5,7,11] then return q; fi; + fi; + return (q^d-1)/(q-1); + elif series = "2A" then # PSU(m+1,q) + d := m + 1; + if d = 3 and q = 5 then return 50; fi; + if d = 3 then return q^3 + 1; fi; + if d = 4 then return (q+1)*(q^3 + 1); fi; + if d mod 2 = 0 and q = 2 then return (2^(d-1)*(2^d - 1))/3; fi; + return ((q^d - (-1)^d)*(q^(d-1) + (-1)^d))/(q^2-1); + elif series = "B" then # P\Omega(2*m+1,q) or O + if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; + elif q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); + elif q = 3 and m = 2 then return 27; #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) + elif q = 2 and m = 2 then # B(2,2) is not a simple group. + Error("B(2,2) is not a simple group. This shouldn't be happening.\n"); + elif m = 2 then return (q^(2*m) -1)/(q-1); #Special case : B(2,q) ~ C(2,q) = PSp(4,q) + elif q = 2 then return (2^(m-1))*(2^m -1); #Special case : B(m,2) ~ C(m,2) = PSp(2*m,2) + else Error("series B and m,q not of proper form\n"); fi; + elif series = "2B" then # Sz or _2 B^2 + b := Log2Int(q); + if 2^b = q and b mod 2 = 1 then return q^2 + 1; + else Error("2B series without q of proper form\n"); fi; + elif series = "C" then # PSp(2*m,q) + d := 2*m; + if d=4 and q=2 then return 6;fi; + if d=4 and q=3 then return 27;fi; + if m>2 and q=2 then return (2^(m-1))*(2^m -1);fi; + if m>1 and q>2 then return (q^d -1)/(q-1);fi; + Error("series C and m,q are not of proper form\n"); + elif series = "D" then # POmega(+1,2*m,q) or O+ + if m > 3 then + if q < 4 then return q^(m-1)*(q^m -1)/(q-1); + else return (q^(m-1) + 1)*(q^m-1)/(q-1); fi; + else Error("series D and m < 4\n"); fi; + elif series = "2D" then # POmega(-1,2*m,q) or O- + if m > 3 then return (q^m+1)*(q^(m-1)-1)/(q-1); + else Error("series 2D and m < 4\n"); fi; + elif series = "3D" then # ^3 D_4 + return (q^8 + q^4 + 1)*(q+1); + elif series = "E" then #E_n(q) + if m = 6 then return (q^9 - 1)*(q^8 + q^4 + 1)/(q-1); + elif m = 7 then return (q^14 - 1)*(q^9 + 1)*(q^5 -1)/(q-1); + elif m = 8 then return (q^30 - 1)*(q^12 + 1)*(q^10 + 1)*(q^6 + 1)/(q-1); + else Error("series E and m is not 6,7 or 8\n"); + fi; + elif series = "2E" then #2E(6,q) + return (q^12 -1)*(q^6 - q^3 + 1)^(q^4 +1)/(q-1); + elif series = "F" then #F(4,q) + return (q^12 -1)*(q^4 + 1)/(q-1); + elif series = "2F" then #2F(4,q) + if q = 2 then return 1600; #special case : 2F4(2) ~ Tits + else return (q^6 + 1)*(q^3 + 1)*(q+1); fi; + elif series = "G" then #G(2,q) + if q = 3 then return 351; + elif q = 4 then return 416; + else return (q^6 -1)/(q-1); fi; + elif series = "2G" then #2G(2,q) + b := PValuation(q,3); + if q = 3^b and b mod 2 = 1 then return q^3 + 1; + else Error("series 2G and q not of proper form\n"); fi; + fi; + Error("series `",series,"` is not valid\n"); +end); + InstallOtherMethod(DataAboutSimpleGroup,true,[IsRecord],0, function(id) local nam,e,efactors,par,expo,prime,result,aut,i,classical,classaut,shortname, @@ -1219,6 +1347,7 @@ local nam,e,efactors,par,expo,prime,result,aut,i,classical,classaut,shortname, tomName:=nam, allExtensions:=e, fullAutGroup:=aut, + minPerDeg:=MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(id), classicalId:=ClassicalIsomorphismTypeFiniteSimpleGroup(id)); if classaut<>fail then result.outerAutomorphismGroup:=classaut; diff --git a/lib/grplatt.gd b/lib/grplatt.gd index 2c14c2c3b5..c6dd6bb67f 100644 --- a/lib/grplatt.gd +++ b/lib/grplatt.gd @@ -559,7 +559,6 @@ DeclareSynonym("EmbeddingConjugates",ContainingConjugates); DeclareOperation("MinimalFaithfulPermutationDegree",[IsGroup and IsFinite]); DeclareOperation("MinimalFaithfulPermutationRepresentation", [IsGroup and IsFinite]); -DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSimpleGroup"); DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSemiSimpleGroup"); ############################################################################# diff --git a/lib/grplatt.gi b/lib/grplatt.gi index 2bf956370e..da565423dc 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -3654,140 +3654,6 @@ function(G) return DoMinimalFaithfulPermutationDegree(G,true); end); -BindGlobal("SporadicGroupMinimalFaithfulPermutationDegrees", rec( - M11 := 11, - M12 := 12, - M22 := 22, - M23 := 23, - M24 := 24, - Co1 := 98280, - Co2 := 2300, - Co3 := 276, - McL := 275, - HS := 100, - Suz := 1782, - Fi22 := 3510, - Fi23 := 31671, - Fi24 := 306936, - M := 97239461142009186000, - B := 13571955000, - Th := 143127000, - HN := 1140000, - He := 2058, - J1 := 266, - J2 := 100, - J3 := 6156, - J4 := 173067389, - ON := 122760, - Ly := 8835156, - Ru := 4060, -)); - -BindGlobal("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType",function (info) - # This function is derived from table 4 of this paper : - # https://www.ams.org/journals/tran/2015-367-11/S0002-9947-2015-06293-X/S0002-9947-2015-06293-X.pdf - - # `info` is the a record containing information about the type of the simple group, - # like one obtained from `IsomorphismTypeInfoFiniteSimpleGroup`. You need to give the series, - # parameter, and shortname values in the record. - local - series, # series of simple groups - d, # mostly the dimension of vector space for classical groups - q, # elements in the field over which group is defined - m, # first parameter - b; # q = p^b for some prime p - - series := info.series; - if series = "Spor" then - return SporadicGroupMinimalFaithfulPermutationDegrees.(info.shortname); - else - if IsList(info.parameter) then - q := info.parameter[2]; - m := info.parameter[1]; - else - q := info.parameter; - fi; - fi; - if series = "Z" then #Cyclic group of prime order - return q; - elif series = "A" then # Alternating group - return q; - elif series = "L" then # PSL(m,q) - d := m; - if (d = 4 and q = 2) then return 8; fi; - if d = 2 then - if q = 9 then return 6; fi; - if q in [5,7,11] then return q; fi; - fi; - return (q^d-1)/(q-1); - elif series = "2A" then # PSU(m+1,q) - d := m + 1; - if d = 3 and q = 5 then return 50; fi; - if d = 3 then return q^3 + 1; fi; - if d = 4 then return (q+1)*(q^3 + 1); fi; - if d mod 2 = 0 and q = 2 then return (2^(d-1)*(2^d - 1))/3; fi; - return ((q^d - (-1)^d)*(q^(d-1) + (-1)^d))/(q^2-1); - elif series = "B" then # P\Omega(2*m+1,q) or O - if q = 3 and m > 2 then return (3^m)*(3^m - 1)/2; - elif q > 4 and m > 2 then return (q^(2*m)-1)/(q-1); - elif q = 3 and m = 2 then return 27; #Special case : B(2,3) ~ 2A(3,2) = PSU(4,2) - elif q = 2 and m = 2 then # B(2,2) is not a simple group. - Error("B(2,2) is not a simple group. This shouldn't be happening.\n"); - elif m = 2 then return (q^(2*m) -1)/(q-1); #Special case : B(2,q) ~ C(2,q) = PSp(4,q) - elif q = 2 then return (2^(m-1))*(2^m -1); #Special case : B(m,2) ~ C(m,2) = PSp(2*m,2) - else Error("series B and m,q not of proper form\n"); fi; - elif series = "2B" then # Sz or _2 B^2 - b := Log2Int(q); - if 2^b = q and b mod 2 = 1 then return q^2 + 1; - else Error("2B series without q of proper form\n"); fi; - elif series = "C" then # PSp(2*m,q) - d := 2*m; - if d=4 and q=2 then return 6;fi; - if d=4 and q=3 then return 27;fi; - if m>2 and q=2 then return (2^(m-1))*(2^m -1);fi; - if m>1 and q>2 then return (q^d -1)/(q-1);fi; - Error("series C and m,q are not of proper form\n"); - elif series = "D" then # POmega(+1,2*m,q) or O+ - if m > 3 then - if q < 4 then return q^(m-1)*(q^m -1)/(q-1); - else return (q^(m-1) + 1)*(q^m-1)/(q-1); fi; - else Error("series D and m < 4\n"); fi; - elif series = "2D" then # POmega(-1,2*m,q) or O- - if m > 3 then return (q^m+1)*(q^(m-1)-1)/(q-1); - else Error("series 2D and m < 4\n"); fi; - elif series = "3D" then # ^3 D_4 - return (q^8 + q^4 + 1)*(q+1); - elif series = "E" then #E_n(q) - if m = 6 then return (q^9 - 1)*(q^8 + q^4 + 1)/(q-1); - elif m = 7 then return (q^14 - 1)*(q^9 + 1)*(q^5 -1)/(q-1); - elif m = 8 then return (q^30 - 1)*(q^12 + 1)*(q^10 + 1)*(q^6 + 1)/(q-1); - else Error("series E and m is not 6,7 or 8\n"); - fi; - elif series = "2E" then #2E(6,q) - return (q^12 -1)*(q^6 - q^3 + 1)^(q^4 +1)/(q-1); - elif series = "F" then #F(4,q) - return (q^12 -1)*(q^4 + 1)/(q-1); - elif series = "2F" then #2F(4,q) - if q = 2 then return 1600; #special case : 2F4(2) ~ Tits - else return (q^6 + 1)*(q^3 + 1)*(q+1); fi; - elif series = "G" then #G(2,q) - if q = 3 then return 351; - elif q = 4 then return 416; - else return (q^6 -1)/(q-1); fi; - elif series = "2G" then #2G(2,q) - b := PValuation(q,3); - if q = 3^b and b mod 2 = 1 then return q^3 + 1; - else Error("series 2G and q not of proper form\n"); fi; - fi; - Error("series `",series,"` is not valid\n"); -end); - -InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSimpleGroup,function(G) - local info; - info := IsomorphismTypeInfoFiniteSimpleGroup(G); #This requires computing Size(G) - return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); -end); - ######################################################################### ## #F CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(,,,,) @@ -4049,18 +3915,22 @@ end); ################################################################################## ## -#F MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(,) +#F MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(,,) ## -## Returns mu(A) where S < A < Aut(S) for simple group S -## if it can compute it easily, else returns -1. +## Returns mu(A) where S =~ Inn(S) < A < Aut(S) and S is a simple group if G is 0. +## If group G is given, A is congruent to the +## group of conjugator automorphisms of simple group S < G +## , using elements of normalieser of S in G as conjugators. +## This function really only need the size of A if G is given +## , so that can be given directly instead of the group A too. ## For more details, take a look at this paper : ## https://www.sciencedirect.com/science/article/pii/S0747717118300993 -BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup",function(A,S) +BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup",function(A,S,G) local info,d,q,m,series,name,parameter,mu,Aut,b,sizeS,sizeA; # Just for convenience Aut := AutomorphismGroup; - mu := MinimalFaithfulPermutationDegreeOfSimpleGroup; + mu := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType; if IsInt(A) then sizeA := A; else sizeA := Size(A); fi; @@ -4072,10 +3942,10 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou if series = "Spor" then if name = "M12" and sizeA = Size(Aut(S)) #A = Aut(S) - then return 2 * mu(S); + then return 2 * mu(info); elif name = "ON" and sizeA = Size(Aut(S)) #A = Aut(S) - then return 2 * mu(S); + then return 2 * mu(info); fi; else # Set q and m parameter := info.parameter; @@ -4088,7 +3958,14 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou if series = "A" and q = 6 then #if not A <~ SymmetricGroup(6) then return 10; fi; if 720 mod sizeA <> 0 then return 10; - else return -1; fi; + else + if G = 0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + elif IsInt(A) then + A := Normaliser(G,S) / Centraliser(G,S); + fi; + return MinimalFaithfulPermutationDegree(A); + fi; elif series = "L" then d := m; @@ -4098,65 +3975,113 @@ BindGlobal("MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgrou # Thus A <~ PGL(2,7); So, the only requirement for isomorphism is that Size(A) = Size(PGL(2,7)) = 336 if sizeA = 336 then return 8; fi; elif d > 2 and not (q = 2 and (d = 3 or d = 4)) then - #if not A <~ GammaL(d,q) then return 2 * mu(S); - if Size(GammaL(d,q)) mod sizeA <> 0 then return 2 * mu(S); - else return -1; fi; + #if not A <~ GammaL(d,q) then return 2 * mu(info); + if Size(GammaL(d,q)) mod sizeA <> 0 then + return 2 * mu(info); + elif G=0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + return MinimalFaithfulPermutationDegree(A); + elif CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,d,q,"PSL") then + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + return 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + fi; fi; elif series = "2A" # PSU(3,5) and m+1 = 3 and q = 5 then #if not A <~ PSigmaU(3,5) then return 126; fi; - return -1; + if G = 0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + elif IsInt(A) then + A := Normaliser(G,S) / Centraliser(G,S); + fi; + return MinimalFaithfulPermutationDegree(A); elif series = "D" then #P\Omega^+ d := 2*m; if d = 8 and q = 2 and sizeA/sizeS mod 3 = 0 - then return 3 * mu(S); + then return 3 * mu(info); elif d = 8 and q = 3 and sizeA/sizeS mod 3 = 0 and sizeA/sizeS mod 12 <> 0 - then return 3 * mu(S); + then return 3 * mu(info); elif d = 8 and q = 3 and sizeA/sizeS mod 12 = 0 then return 3360; elif d = 8 and sizeA/sizeS mod 3 = 0 - then return 3 * mu(S); + then return 3 * mu(info); elif q = 3 and d > 7 and sizeA/sizeS mod 3 <> 0 then if Size(PGO(1,d,3)) mod sizeA <>0 # (*) then return (3^(m-1) + 1) * (3^m -1) / 2 ; - else return -1; fi; + elif G=0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + return MinimalFaithfulPermutationDegree(A); + elif CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"POmega+") then + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + return (3^(m-1) + 1) * (3^m -1) / 2 ; + fi; fi; elif series = "G" then - #if q = 3 and Iso(A,Aut(S)) then return 2 * mu(S);fi; - if q = 3 and sizeA = Size(Aut(S)) then return 2 * mu(S); fi; + #if q = 3 and Iso(A,Aut(S)) then return 2 * mu(info);fi; + if q = 3 and sizeA = Size(Aut(S)) then return 2 * mu(info); fi; #This is because A is isomorphic to a subgroup in Aut(S) that contains Inn(S) \cong S at any point. b := LogInt(q,3); if 3^b = q and b >1 then - #if not A <~ GammaG(q) then return 2 * mu(S); fi; - if Size(GF(q))*Size(GaloisGroup(AsField(GF(q),GF(3)))) mod sizeA <> 0 then return 2 * mu(S); - else return -1; fi; + #if not A <~ GammaG(q) then return 2 * mu(info); fi; + if Size(GF(q))*Size(GaloisGroup(AsField(GF(q),GF(3)))) mod sizeA <> 0 then return 2 * mu(info); + else + if G = 0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + elif IsInt(A) then + A := Normaliser(G,S) / Centraliser(G,S); + fi; + return MinimalFaithfulPermutationDegree(A); + fi; fi; elif series = "C" #PSp and m = 2 and 2^Log2Int(q) = q and q > 3 then - #if not A <~ PGammaSp(d,q) then return 2*mu(S); fi; - return -1; + #if not A <~ PGammaSp(d,q) then return 2*mu(info); fi; + if G=0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + return MinimalFaithfulPermutationDegree(A); + elif CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"PSp") then + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + else + return 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + fi; elif series = "F" and 2^Log2Int(q) = q then - #if not A <~ GammaF(d,q) then return 2*mu(S); fi; - if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); - else return -1; fi; + #if not A <~ GammaF(d,q) then return 2*mu(info); fi; + if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(info); + else + if G = 0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + elif IsInt(A) then + A := Normaliser(G,S) / Centraliser(G,S); + fi; + return MinimalFaithfulPermutationDegree(A); + fi; elif series = "E" and m = 6 then - #if not A <~ GammaE(d,q) then return 2*mu(S); fi; - if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(S); - else return -1; fi; + #if not A <~ GammaE(d,q) then return 2*mu(info); fi; + if sizeS * Size(GaloisGroup(GF(q))) mod sizeA <> 0 then return 2 * mu(info); + else + if G = 0 then + Assert(not IsInt(A),"If group G is not given, then group A must be given"); + elif IsInt(A) then + A := Normaliser(G,S) / Centraliser(G,S); + fi; + return MinimalFaithfulPermutationDegree(A); + fi; fi; - return mu(S); + return mu(info); end); ################################################################################## @@ -4177,63 +4102,33 @@ InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSemiSimpleGroup,function phi, # Homomorphism from NGS to NGS/CGS A, # NGS/CGS =~ {^n for n in N_G(S)} muA, # Minimal Permutation Degree of A - sizeA, # Size(A) S, # Slis[1] =~ Slis[i] info, # Information about isomorphism type of S MNS,m,q; mu := 0; MNS := MinimalNormalSubgroups(G); - if Length(MNS) = 1 and MNS[1] = G then return MinimalFaithfulPermutationDegreeOfSimpleGroup(G); fi; + if Length(MNS) = 1 and MNS[1] = G then + info := IsomorphismTypeInfoFiniteSimpleGroup(G); + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); + fi; for N in MNS do Slis := DirectFactorsOfGroup(N); S := Slis[1]; NGS := Normalizer(G,S); CGS := Centralizer(G,S); - sizeA := Size(NGS)/Size(CGS); - muA := MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(sizeA,S); - if muA = -1 then - info := IsomorphismTypeInfoFiniteSimpleGroup(S); - if not IsList(info.parameter) then q := info.parameter; - else m := info.parameter[1]; q := info.parameter[2]; fi; - if info.series = "L" #PSL - and m > 2 - and not (q = 2 and (m in [3,4])) then - #Print("\t PSL type simple subgroup\n"); - if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"PSL") then - muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); - else - muA := 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); - fi; - elif info.series ="C" #PSp - and m = 2 - and 2^Log2Int(info.parameter[2]) = info.parameter[2] then - if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"PSp") then - muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); - else - muA := 2*MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); - fi; - elif info.series ="D" #POmega+ - and q = 3 - and m >= 4 then - if CanLiftPermutationDegreeToNormaliserOfSimpleMatrixGroup(S,G,m,q,"POmega+") then - muA := MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); - else - muA := (3^(m-1) + 1) * (3^m -1) / 2 ; - fi; - else - #Print("\t Leaving to Lattice Algo\n"); - phi := NaturalHomomorphismByNormalSubgroupNC(NGS,CGS); - A := Image(phi); - muA := MinimalFaithfulPermutationDegree(A); - fi; - fi; + A := NGS/CGS; + muA := MinimalFaithfulPermutationDegreeOfAlmostSimpleGroupWithSimpleSubgroup(A,S,G); mu := mu + (Length(Slis) * muA); od; return mu; end); InstallMethod(MinimalFaithfulPermutationDegree,"for simple groups",true, - [IsSimpleGroup and IsFinite],0,MinimalFaithfulPermutationDegreeOfSimpleGroup); + [IsSimpleGroup and IsFinite],0,function(S) + local info; + info := IsomorphismTypeInfoFiniteSimpleGroup(S); + return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info); +end); # utility function: Find a subgroup $S$ of $G\le P$, with $G'\le S\le G$ such # that $[G:S]<=limit$ and that $S\lhd N_P(G)$. From cd4beccf37a725795025b5d2cd3a0ab5c7198b8f Mon Sep 17 00:00:00 2001 From: Pranav Date: Fri, 26 Jul 2024 15:10:38 +0530 Subject: [PATCH 9/9] Moved tests to `testextra` --- lib/grplatt.gd | 2 +- lib/grplatt.gi | 4 ++-- ...ulPermutationDegreeOfFittingFreeGroup.tst} | 7 +++--- ...FaithfulPermutationDegreeOfSimpleGroup.tst | 22 +++---------------- 4 files changed, 10 insertions(+), 25 deletions(-) rename tst/{testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst => testextra/MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst} (86%) rename tst/{testinstall/opers => testextra}/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst (84%) diff --git a/lib/grplatt.gd b/lib/grplatt.gd index c6dd6bb67f..eb1d916a02 100644 --- a/lib/grplatt.gd +++ b/lib/grplatt.gd @@ -559,7 +559,7 @@ DeclareSynonym("EmbeddingConjugates",ContainingConjugates); DeclareOperation("MinimalFaithfulPermutationDegree",[IsGroup and IsFinite]); DeclareOperation("MinimalFaithfulPermutationRepresentation", [IsGroup and IsFinite]); -DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfSemiSimpleGroup"); +DeclareGlobalFunction("MinimalFaithfulPermutationDegreeOfFittingFreeGroup"); ############################################################################# ## diff --git a/lib/grplatt.gi b/lib/grplatt.gi index da565423dc..ca346e66d7 100644 --- a/lib/grplatt.gi +++ b/lib/grplatt.gi @@ -4086,13 +4086,13 @@ end); ################################################################################## ## -#F MinimalFaithfulPermutationDegreeOfSemiSimpleGroup() +#F MinimalFaithfulPermutationDegreeOfFittingFreeGroup() ## ## Returns the minimal faithful permutation degree for a semi-simple group G, ## which is a group that doesn't contain any abelian normal subgroups. ## The function is based on this research paper : ## https://dl.acm.org/doi/10.1145/3618260.3649641 -InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfSemiSimpleGroup,function(G) +InstallGlobalFunction(MinimalFaithfulPermutationDegreeOfFittingFreeGroup,function(G) local mu, # Objective value to compute Slis, # Decomposition of N as direct product of simple groups diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst b/tst/testextra/MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst similarity index 86% rename from tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst rename to tst/testextra/MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst index 9bdbdd755a..59e8f76abd 100644 --- a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst +++ b/tst/testextra/MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst @@ -1,4 +1,4 @@ -gap> START_TEST("MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst"); +gap> START_TEST("MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst"); gap> CheckInList := function(L,Mus) > local i,stop,mu,mu2,G,g; > for i in [1..Length(L)] do @@ -7,7 +7,7 @@ gap> CheckInList := function(L,Mus) > else > mu := DoMinimalFaithfulPermutationDegree(G,false); > fi; -> mu2 := MinimalFaithfulPermutationDegreeOfSemiSimpleGroup(G); +> mu2 := MinimalFaithfulPermutationDegreeOfFittingFreeGroup(G); > if mu2 = mu then > else > return Concatenation("F.A.I.L on",String(G)); @@ -50,4 +50,5 @@ gap> gap> # Products of Simple Groups gap> ind := List([1..30],x->Random([1..Length(TestCases)]));; gap> CheckInList(List(ind,n->TestCases[n]),List(ind,n->Degs[n])); -"pass" \ No newline at end of file +"pass" +gap> STOP_TEST( "MinimalFaithfulPermutationDegreeOfFittingFreeGroup.tst", 1); \ No newline at end of file diff --git a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst b/tst/testextra/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst similarity index 84% rename from tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst rename to tst/testextra/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst index e4c52b7d9e..76f006fe33 100644 --- a/tst/testinstall/opers/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst +++ b/tst/testextra/MinimalFaithfulPermutationDegreeOfSimpleGroup.tst @@ -1,21 +1,4 @@ -gap> START_TEST("MinimalFaithfulPermutationDegreeOfSimpleGroup.tst"); -gap> checksimple := function(maxsize) -> local i,mu,mu2,info,G; -> i := 1; -> for G in SimpleGroupsIterator(1,maxsize) do -> mu := DoMinimalFaithfulPermutationDegree(G,false); -> mu2 := MinimalFaithfulPermutationDegreeOfSimpleGroup(G); -> if mu2 <> mu then -> info := IsomorphismTypeInfoFiniteSimpleGroup(G); -> return Concatenation("Failed on simple group ",String(i)," i.e. ",info.name,"\n"); -> fi; -> i := i + 1; -> od; -> return "Passed"; -> end; -function( maxsize ) ... end -gap> checksimple(50000); # first 26 simple groups -"Passed" +gap> START_TEST("MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType.tst"); gap> Clean := function(INFO) > local SporNames,SeriesNames,info,name,q,size; > info := ShallowCopy(INFO); @@ -126,4 +109,5 @@ gap> LightChecknonabelianSimple := function(perfectTill) > end; function( perfectTill ) ... end gap> LightChecknonabelianSimple(10^6); -"PASS" \ No newline at end of file +"PASS" +gap> STOP_TEST( "MinimalFaithfulPermutationDegreeOfSimpleGroup.tst", 1); \ No newline at end of file