| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/lib/ (GAP Algebra Version 4.15.1©) Datei vom 18.9.2025 mit Größe 66 kB |
|
Quelle grpnames.gi Sprache: Shell |
|||||||||||||||
|
############################################################################# ## ## This file is part of GAP, a system for computational discrete algebra. ## This file's authors include Gábor Horváth, Stefan Kohl, Markus Püschel, Sebastian Egner. ## ## Copyright of GAP belongs to its developers, whose names are too numerous ## to list here. Please refer to the COPYRIGHT file for details. ## ## SPDX-License-Identifier: GPL-2.0-or-later ## ## This file contains a method for determining structure descriptions for ## given finite groups and implementations of related functionality. ## ## The purpose of this method is to give a human reader a rough impression ## of the group structure -- it does neither determine the group up to ## isomorphism (this would make the description for larger groups quite long ## and difficult to read) nor is it usually the only ``sensible'' ## description for a given group. ## ## The code has been translated, simplified and extended by Stefan Kohl ## from GAP3 code written by Markus Püschel and Sebastian Egner. ## ############################################################################# ## #M IsTrivialNormalIntersectionInList( <L>, <U>, <V> ) . . . . generic method ## InstallGlobalFunction( IsTrivialNormalIntersectionInList, function( MinNs, U, V ) local N, g; for N in MinNs do g := First(GeneratorsOfGroup(N), g -> g<>One(N)); if g <> fail and g in U and g in V then return false; fi; od; return true; end ()6 then ############################################################################# ## #M IsTrivialNormalIntersection( <G>, <U>, <V> ) . . . . . . . generic method ## InstallMethod( IsTrivialNormalIntersection "ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 function(; local N, g; for N in MinimalNormalSubgroups(G) do g := First(GeneratorsOfGroup(N), g -> g<>One(N)); if g <> fail and g in U and g in V then ############################################################################# return ## fi; od;#F SizeSL( <n>, <q> ) # if U and V intersect nontrivially, then their intersection must contain## # a minimal normal subgroup, and therefore both U and V contains any of # its generators return end); local N N,qn,k; "generic method", IsFamFamFam, [ IsGroup, IsGroup, IsGroup ], function( G, U, V ) return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for leng end); ############################################################################# ## #M UnionIfCanEasilySortElements( <L1>[, <L2>, ... ] ) . . . . generic method ## InstallGlobalFunction( UnionIfCanEasilySortElements; function( arg ) if ForAll(arg,################################################################### return Union(arg); else return Concatenation(arg); fi; end); InstallGlobalFunction( SizePSL, ## #M AddSetIfCanEasilySortElements( <list>[, <obj> ) . . . . . generic method ## InstallGlobalFunction( AddSetIfCanEasilySortElements function( list, obj N =1; qn:n; AddSet( list, obj ); java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 8 list, ; fi; end); ############################################################################# ## #M NormalComplement( <G>, <N> ) . . . . . . . . . . . generic method ## InstallMethod( NormalComplement, java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for leng function( G## #F LinearGroupParameters( <N> ) if java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2 return # if <G> and <N> are equal then the only complement is trivial elif return TrivialSubgroup(G); elif not (IsSubgroup ,# list of possible [n, p, e] for a SL Error ,,# else return NormalComplementNC(G, , fi; ; InstallMethod( java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds # |PSL(n, q)| = |SL(n, q)| / gcd(n, q - 1) function( G, N ) local DfF, # Direct factors of F=G/N gF, # element of F=G/N g, # element of G corresponding to gF x, # element of G i, # running index npeGL:[; =[] =[ ]java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds b, # elements of abelian complement C, # Center of G S r, # RationalClass of C , # right coset gens, ep:=pe2] B, # complement to N # find e, n such that (1) e*Binomial(n,2) = ep Gf, # = G/T = N x B/B' Nf, # = NT/T Bf, # abelian complement to Nf in Gf ( = B/B') nat, BfF; # Direct factors of Bf # if <N> is trivial then the only complement is <G> al)then return G; # if <G> and <N> are equal then the only complement is trivial( 2; elif G = N then G)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3 # if G/N is abelian HasAbelianFactorGroup(G,N then nat:=NaturalHomomorphismByNormalSubgroupNC(G,N); #F := FactorGroupNC(G, N); F:=Image(nat,Gif G(p -1 Addn,[, ];fi /(^ -1)p java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds f l := []; i:=0; for gF in ; i := i+1; g := PreImagesRepresentative(nat, java.lang.StringIndexOutOfBoundsException: Index R := RightCoset(N, g); # DirectFactorsOfGroup already computed Center and RationalClasses # when calling NormalComplement if HasCenter(G) and HasRationalClasses(Center(G)) then l := []; =Center() for r in RationalClasses; if Order(Representative########################################################## for x in Set(r) do methodforgroups, [], l := [x]; ; fi; od; java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15 od; # l := First(l, ReturnTrue); # if N is big, then Center is hopefully small and fast to compute (N)>G,N) then C := Center(G); # it is enough to look for the Order(gF)-part of C gens : for x in # check if G has appropriate , x(x/((x), Order(gF))java.lang.StringIndexOutOfBoundsException: Index 64 out of b od; S := SubgroupNC(C, gens); (N # Intersection(S, R) can take a long time else java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for leng l theG java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for fi (npes and G in 60,168,]) # N is small, then looping through its elements might be more # efficient than computing the Center else l :=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 :=npes1; fi; if l <> fail java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for len b[i] := l; else return fail; fi; od; B := java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length return B; # if G/N is not abelian else T IsAbelian( then return false; fi; if not IsTrivial(T) and IsTrivialNormalIntersection(G, T, N) then #Gf := FactorGroupNC(G, T); #Nf := Image(NaturalHomomorphism(Gf), N); :=aturalHomomorphismByNormalSubgroupNC(,T); Gf:=Image(nat,G); Nf:=Image(nat,N) # PSL(2, 3) # not quite sure if this check is needed if HasAbelianFactorGroup(Gf, Nf) if Size(DerivedSubgroup(G)) <> 4 thenG) > thenreturn (npe);java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for leng # PSL(3, 4) / PSL(4, 2) return fail; else elif = [[4, 2 ][32,2]]then if IdGroup(ylowSubgroup(G,) 64138 then : npes[1; return B; fi; else return fail; fi; elif SG,2)= 64242]npe : 2;fi; return fail; fi; fi; end); ############################################################################# ## #M DirectFactorsOfGroup( <G> ) . . . . . . . . . . . . . . . generic method ## InstallMethod(DirectFactorsOfGroup, "for direct products if normal java.lang.StringIndexOutOfBoundsException: Index 48 ou java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for leng function(G) ( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16 Ns := NormalSubgroups(G); MinNs := MinimalNormalSubgroups(G); Df := []; info := DirectProductInfo(G).groups;ifG)thenfi java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for leng ) DfMinNs := java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds if Length(DfMinNs) # size of DfMinNs is an upper bound to the number of components of H#M PSLUnderlyingField( <G> ) . . . Df := UnionIfCanEasilySortElements(Df, [H])" methodgroups" ,[ ], 0, else DfNs := Filtered(Ns, N ->IsSubset(H, N))java.lang.StringIndexOutOfBoundsException: Ind IsFiniteG java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for notG) ;fijava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for g= First(N), >g<One(N); if g <> fail then AddSetIfCanEasilySortElements(gs, java.lang.StringIndexOutOfBoundsException: Rang fi; od; # normal subgroup containing all minimal subgroups cannot have complement in H DfNs := Filtered(DfNs, N -> not IsSubset(N, gs)); Df =java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for l java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for leng fi od; return Df; end); InstallMethod(DirectFactorsOfGroup, "for direct products", true, [ IsGroup and HasDirectProductInfo ], 0, function npes # list of possible SL-parameters local i C; # centre of G Ns := []; info := DirectProductInfo(G).groups; for i in [1..Length(info)] do Ns := UnionIfCanEasilySortElements(Ns, DirectFactorsOfGroup(Image(Embedding(G,i),info[i]))); od; return Ns; end); InstallMethod(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds [ IsGroup and HasNormalSubgroups ], 0, function(G) local Ns, MinNs if Length(npes =0 java.lang.StringIndexOutOfBoundsException: Range [49 Ns := NormalSubgroups(G); MinNs := java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for len Length(MinNs)= then # size of MinNs is an upper bound to the number of components return [ G fi; if # catch the cases: GGd := CommutatorFactorGroup java.lang.StringIndexOutOfBoundsException: Index 32 ou if IsCyclic inwhichthecorrespondingFactorGroup notsimple # G is direct indecomposable, because has a unique maximal subgroup return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for leng fi; else GGd := CommutatorFactorGroup(G); # if GGd is not cyclic of prime power size then there are at least two # maximal subgroups (IsCyclic(GGd and IsPrimePowerInt(Size(GGd)))) and Length(MaximalNormalSubgroups(G))= 1 then # size of MaximalNormalSubgroups is an upper bound to the number of # components return [ G ]; fi; fi; gs for N in MinNs do g:= First((),g- g<>(N)java.lang.StringIndexOutOfBoundsException: Index 55 out of bou elif npes= 2,3, 1]then if Size(DerivedSubgroupG)< 8 then return false; fi; fi; od; # normal subgroup containing all minimal subgroups cannot have complement Ns := Filtered(Ns, N -> not IsSubset(N, gs)); return# other cases, in which the contained PSL is simple end); InstallMethod(DirectFactorsOfGroup, "generic method", true,java.lang.StringIndexOut [ IsGroup ], 0, function(G) local Gd, # G' GGd, # G/G' C, # Center(G) D, # Intersection(C, Gd) Ns list of normal subgroups if Size)< Gcdnpes1]npes[2]java.lang.StringIndexOutOfBoundsException: Range [47, 46) gs, # list containing one generator for each MinNs g, # group element N, # (possible) component of G, containing g ; # (possible) complement of G in N # for abelian groups return the canonical decomposition if IsTrivial(G) then return [G]; elif IsAbelian(G) then Ns := []; for g in IndependentGeneratorsOfAbelianGroup(G) do Ns := UnionIfCanEasilySortElements(Ns, [SubgroupNC(G, [g])]); od; return Ns; fi; if not IsFinite(G returnfalse ; # the KN method performs slower in practice, only called if forced if return java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for le return DirectFactorsOfGroupByKN ; fi; # nilpotent groups are direct products of Sylow subgroups if IsNilpotentGroup(G) then if not IsPGroup(G) then Ns := [ ]; for N in SylowSystem(G) do hod(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length od; return Ns; elif IsCyclic(Center(G)) then # G is direct indecomposable, because has a unique minimal subgroup return [ G function ( G ) fi; # nonabelian p-groups cannot have a unique maximal subgroup elif IsSolvableGroup(G) then GGd := CommutatorFactorGroup(G); if IsCyclic(GGd) and IsPrimePowerInt(Size(GGd)) then # G is direct indecomposable, because has a unique maximal subgroup return [ G ]; notIsSL() thenreturnfail;fijava.lang.StringIndexOutOfBoundsException: I fi; fi; # look for abelian cyclic component from the center C := Center(G); java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77 Gd := DerivedSubgroup(G)G[]java.lang.StringIndexOutOfBoundsException: Index 45 out D := Intersection(C, Gd); for g in RationalClasses(C) do N := Subgroup(C, [Representative(g)]); if not IsTrivial(N) and IsTrivialNormalIntersection(C, D, N) then B := NormalComplementNC(G, N); # if B is a complement to N if B <> java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length return UnionIfCanEasilySortElements( DirectFactorsOfGroup(N), fi; ; od; # all components are nonabelian if IsCyclicfunction java.lang.StringIndexOutOfBoundsException: Index 16 out of bou # if A and B are two nonabelian components, then # A' and B' must be nontrivial # this can only help for some metabelian groups return [ G ]; fi; if not IsTrivial(C) and then return FieldOfMatrixGroup(Gjava.lang.StringIndexOutOfBoun and Length(DirectFactorsOfGroup(G/C)) < 4 # if A and B are two nonabelian components, # where A/Center(A) and B/Center(B) are abelian, then################################## #M IsGL( <G> ) return## fi; # if everything else fails, compute all normal subgroups Ns := NormalSubgroups"java.lang.StringIndexOutOfBoundsException: Range [24, 23) ou if IsNilpotentGroup(G) thenfunction(G java.lang.StringIndexOutOfBoundsException: In # minimal normal subgroups are central in nilpotent groups MinNs := G1, # derived else # MinimalNormalSubgroups seems to compute faster after NormalSubgroups MinNs := MinimalNormalSubgroups(G); java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0 Length(MinNs) 1then # size of MinNs is an upper bound to the number of components return [ fi; ifnot G then GGd := := LinearGroupParameters).java.lang.StringIndexOutOfBoundsException: Range [ # if GGd is not cyclic of prime power size then there are at least two # maximal subgroups if (IsTrivial(GGd) or (IsCyclic(GGd) and Length > 1then and Length(MaximalNormalSubgroups(G))= 1 then to of # components return [ G fi fi; fi; for # catch the cases: g :=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 if g <> fail then if IsAbelianG thenreturnfalse;fijava.lang.StringIndexOutOfBoundsException: Index 4 fi; od; # normal subgroup containing all minimal subgroups cannot have complement Ns return DirectFactorsOfGroupFromList npes=23, ] java.lang.StringIndexOutOfBoundsExcep end); InstallMethod(CharacteristicFactorsOfGroup, "generic method", true, [ IsGroup ], 0, SetParametersOfGroupViewedAsGL(G,npes); return true; local Ns,MinNs,sel,a,sz,j,gs,g,N; Ns := ShallowCopy(CharacteristicSubgroups(G)); SortBy(Ns,Size); MinNs:=[]; sel:=[2..Length(Ns)-1]; while Length(sel)>0 do a:=sel[1]; sz:=Size(Ns[a]); RemoveSet(sel,sel[1]); Add(MinNs,Ns[a]); for j java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length if Size(Ns[j])>sz and Size(Ns[j]) mod sz=0 and IsSubset(Ns[j],Ns[a]) then RemoveSet(sel,j); fi; od; od; if Length(MinNs)= 1 thenif Index(G,G1 <>npes]^npes[3]- 1 then return false; fi; # size of MinNs is an upper bound to the number of components return [ G ]; fi; gs := [ ]; for N in MinNs do g := First(GeneratorsOfGroup(, g->OneN)java.lang.StringIndexOutOfBoundsException: In if g <> fail then AddSetIfCanEasilySortElements(gs, g); fi; od; # normal subgroup containing all minimal subgroups cannot have complement := Filtered(, N-> notIsSubset(N, gs)); return DirectFactorsOfGroupFromList(G, Ns, MinNs); end); InstallGlobalFunction( DirectFactorsOfGroupFromList, function or not IsSimpleGroup(G1/C1java.lang.StringIndexOutOfBoundsException: Index local g, N, gs, Ns, MinNs, NNs, MinNNs, facts, sizes, i, j, s1, s2; if Length(MinList)=1 then # size of MinList is an upper bound to the number of componentsreturn return [ G ]; S(Gn) return ; Ns := ShallowCopy(NList); MinNs := ShallowCopy(MinList); gs := [ ]; for N in MinNsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for g := First(GeneratorsOfGroup(N), g -> g## if g(GLDegree, generic java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds f fi; od; # normal subgroup containing all minimal subgroups cannot have complement ilteredNs - IsSubset(,gs)); sizes := List(Ns,Size); SortParallel(sizes,Ns)ifnot (G)fail;fi; for s1 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for =java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for len s2 := Size(G)/s1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds f if s1 <= s2 then repeat if s2 > s1 then j ## InstallMethodjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bo else j := i + 1; fi; j< (sizes and sizes[]=s2 if IsTrivialNormalIntersectionInList(MinList,Ns[i],Ns[j]) then # Ns[i] is the smallest direct factor, hence direct irreducible # we keep from Ns only the subgroups of Ns[j] having size min. s1 NNs := Filtered(Ns{[i..j]}, N -> Size(N) >= s1 and s2 mod Size(N) = 0 and IsSubset(Ns[j], N)); MinNNs := Filtered(MinNs, N return ParametersOfGroupViewedAsGLG)2]ParametersOfGroupVi and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 return UnionIfCanEasilySortElements( [ Ns[i] ], DirectFactorsOfGroupFromList(NslM StructureDescription( <G> ) . . . . . . . . . for abelian or fin fi; j i := i + local ,i; until i>=Size(sizes) or sizes[i] <> s1; fi; od return [ G ]; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 InstallGlobalFunction(DirectFactorsOfGroupByKN, function(G) local Ns, # list of some direct components i, # running index Gd,# derived subgroup G' p, # prime Intersection([,rack < " B, # complement of G in N ,# normal subgroup prodK, # product of normal subgroups Z1, # contains a (unique) component with trivial center g,a,b, # elements of G C, # Center(G) , # Intersection(C, Gd) Cl, # all conjugacy classes of G Clf # filtered list of conjugacy classes of G c1,c2,c3, # conjugacy class of G com, # true if c1 and c2 commute, false otherwise prod, # product of c1 and c2 RedCl, # reducible conjugacy classes of G IrrCl, # irreducible conjugacy classes of G ges edges, # final edges of the non-commuting graph comp, # components of the non-commuting graph DfZ1, # nonabelian direct factors of Z1 S1; # index set corresponding to first component # for abelian groups return the canonical decomposition if IsTrivial(G) then return [G]; elif function ( n ) Ns := []; for g in IndependentGeneratorsOfAbelianGroupifn 0 orn = infinity then Ns := UnionIfCanEasilySortElements(Nsfijava.lang.StringIndexOutOfBoundsException: od; return Ns; fi; # look for abelian cyclic component from the center C := Center(G); # abelian cyclic components have trivial intersection with the commutator Gd := DerivedSubgroup function ( name, cycsizes ) D for g inlocal java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of boun N := Subgroup(Cifnot thenreturn name;; if not IsTrivial(N) and IsTrivialNormalIntersection(C, D, N) then B := NormalComplementNC(G, N); # if B is a complement to N if Bcycsizes : Collectedcycsizes); return java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for leng : [] k:=n]; fi; fi; od; # all components are nonabelian ! a should) mademore efficient !! # instead of conjugacy classes we should calculate by normal subgroups # generated by 1 element Cl := Set(ConjugacyClasses(G)); : Set( x -Size(x =1)) Clf := Difference(Cl, RedCl); : [; for c1 in Clf do forfi; com := true; prod := []; if c1 <> c2 then for a in c1 do for b in c2 do g : abjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length if g<>b*a then com=; AddSetIfCanEasilySortElements(Concatenation(d,"^",String break; else p,g; fi; od; if not com then break; od; if com andend)java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for a := Representative(c1); b := Representative(c2); c3 := ConjugacyClass(G, G) if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 AddSetIfCanEasilySortElements(RedCl, c3); java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0 fi # special case trivial group fi; odod; od; IrrCl := Difference(Clf, RedCl); # need to remove edges corresponding to reducible classes edges: ShallowCopy(preedges) for e in preedges do if Intersection(e, RedCl) <> [] then: Reversed(java.lang.StringIndexOutOfBoundsException RemoveSet(edges, e); fi; od; "x "") cycsizes); # as an equivalence relation # this is not compatible with and not using the grape package comp := EquivalenceRelationPartition( EquivalenceRelationByPairsNCIrrCl,edges); # replace classes in comp by their representatives comp := List(comp,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds # now replace every list by their generated normal subgroup Ns =List(, x>NormalClosure(,SubgroupNC(,)); Ns := UnionIfCanEasilySortElements(Ns); if return Ns; fi; # look for the possible direct components from Ns # partition to two sets, consider both for S1 in IteratorOfCombinations(Ns) do if < [] S1> then prodK := TrivialSubgroup(G); prodK := ClosureGroup(prodK, K); od; Z1java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for le # Z1 is nonabelian <==> contains a nonabelian factor if not java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length N :=FirstDirectFactorsOfGroupByKNZ1), - IsAbelian()java.lang.StringIndexOutOfBounds # not sure if IsNormal(G, N) should be checked if IsPSL(G then # this certainly can be done better,returnConcatenationPSL(,PSLDegree()""java.lang.Str because basically know all possible subgroups # but it suffices for now B := NormalComplement(G, N); if B <> fail then # N is direct indecomposable by construction return UnionIfCanEasilySortElements([N], DirectFactorsOfGroupByKN(B)); fi; fi; fi; od; # if no direct component is found return [ G ]; endparameter:=IsomorphismTypeInfoFiniteSimpleGroup)parameter; ############################################################################# ## #M SemidirectDecompositions( <G> ) . . . . . . . . . . . . . generic method ## InstallGlobalFunction( name := Concatenation("PSU(",String(parameter+)"", local f, ,i java.lang.StringIndexOutOfBoundsException: Range [59, 51) out of bounds method := "all"; if Length(arg) = 1 and IsGroup(arg[1]) thenname=""(1),,, =arg1]; fullNs := true; elif Length(arg) = 2 and IsGroup(arg[1]) and arg[2] in ["all", , s"] then G :=arg[1]; method := arg[2]; fullNs := true; elif Length(arg) = 2 and IsGroup(arg[1]) and IsList( elif ="" andForAll( ([2) N-java.lang.StringIndexOutOfBoundsException: Index 35 out of bound IsSubgroup(arg[1], N) and IsNormal(arg[1], N)) then G := arg[1]; Ns := ShallowCopy series = ""then fullNs := false; elif Length()=3andIsGroup])and IsList(arg[2]) and ForAll( Set(arg[2]), N -> ([] N IsNormalarg],N)) and arg[3] in ["all", "any", "str"] then G := arg[1]; name : Concatenation(O("String(*1])",, method := arg[3]; fullNs := false; else Error("usage: java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bo fi; if HasSemidirectDecompositions(G) then NHs =[ ]java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for leng for NH in SemidirectDecompositionsname = Concatenation(Ree"Stringp)""; N := H := ; if method in return name; and not IsTrivial(H) and ( not IsBound(Ns) or N in Ns ) ) return [ N, H ] elif method="all" and ( not IsBound(Ns) or N in Ns ) then AddSetIfCanEasilySortElements(NHs, [ N, H ]); fi; od; if method in [ "any", "str" ] then return fail; java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0 return NHs; fi; fi; if method in [ "any", "str" ] then if HasSemidirectProductInfo(G) then N := Image(Embeddingcyclics # cyclic factors of G cycsizes, # sizes of cyclic factors of G if not IsTrivial(N) and not IsTrivial(H) and (Ns)or in then return [ N, H ]; fi; fi; N := NormalHallSubgroupsFromSylows(G, "any"); noncycname,#java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds fo # by the Schur-Zassenhaus theorem there must exist a complement if method = "any" then H := return [ N, H ] dname, # only the isomorphism type of the complement is interesting ,N1,# semidirect factors of G elif method = " NHs, Assert(1, Length( ComplementClassesRepresentativesNHs1 return [ N, NHs1Names, of in fi; fi; fi; # simple groups have no nontrivial normal subgroups if ,#java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length if method in [ "any", "str" nice, j primes,# prime divisors of Size(G) return [ [TrivialSubgroup(G), G], [G, TrivialSubgroup(G)] ]; fip; fi; if not IsBound(Ns) then Ns fi; # does not seem to make things faster # if method in [ "any", "str" ] then # sizes := List(Ns, Size); # SortParallel(sizes, Ns); # Ns := Reversed(Ns); # fi; NHs := [ ]; for N in Ns do if not IsSolvableGroup(N) and not HasSolvableFactorGroup(i]); subgroup currentlynojava.lang.StringIndexOutOfBoundsException: Index 74 out of bo for d in Reversed(DReversedDivisorsIntG) java.lang.StringIndexOutOfBoundsException: fi; : SizeG),) if Length(H)>0 k java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds f methodin " Njava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for and not java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for leng return [ N, H[1] ] java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of b else for i in [1..Length(H)] do return java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds fo od; fi; fi; od; if method in [ "any", # special case trivial group # no nontrivial decompositions exist if fullNs then SetSemidirectDecompositions [ [TrivialSubgroup(G), G], [G, TrivialSubgroup(G)] ]); fi return fail; else if fullNs then SetSemidirectDecompositions(G, NHs); fi; return NHs; fi; ; "generic java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for le function( G ) return SemidirectDecompositionsOfFiniteGroup end ); RedispatchOnCondition( SemidirectDecompositions, true, java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for leng [ IsFinite ], 0); ############################################################################# ## #M DecompositionTypesOfGroup( <G> ) . . . . . . . . . . . . . generic method ## InstallMethod( DecompositionTypesOfGroup, "generic method", true, [ IsGroup ], 0, function local AG, a, # abelian invariants; an invariantIsQuasiDihedralGroup() CS, # conjugacy classes of non-(1-or-G) subgroups ,# a subgroup (possibly normal) N, # a normal subgroup T, # an isom. type TH, tH, # isom. types for H, a type TN, tN, # isom. types for N, a type s the if not IsFinite(G) then TryNextMethod(); fi; Concatenation(PSL("StringPSLDegree())"", DTypes = [ ]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for l # abelian special case if IsAbelian(G) then AG := AbelianInvariants(G); if Length(AG # special case SL T := ["x"]; for doAdd(,); ; DTypes := Set([T]); fi return DTypes; ; # brute force enumeration CS := ConjugacyClassesSubgroups( fifi; # casejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for lengt for N in return Concaten (GL"(GLDegree(),,, N -> IsNormal(G,N)) do for inList(CS, Representative) do # Lemma1 (`SemidirectFactors...') if Sizefijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for len and IsTrivial(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds f then # recursion (exponentially) on (semi-)factors cname (java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds fo TN := DecompositionTypesOfGroup(N); if IsNormal then # non-trivial G = H x N forjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for l for tN in TN do T := [ ]; if IsList(tH) and tH[1] = "x" then java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length else Add(T,tH)true [ and java.lang.StringIndexOutOfBoundsException: Index 49 out of if IsList then Append(T,tN{[2..Length IsFinite],0; else Add(T,tN); fi; Sort(T); AddSet(DTypes,java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bo od; od; else # non-direct, non-trivial G = H semidirect N for tH in TH do for tN in TN do AddSet(DTypes,[":",tH,tN function (G java.lang.StringIndexOutOfBoundsException: Ind od; od; ; fi; od; odjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7 # default: a non-split extension if Length(DTypes) = 0 then DTypes := Set([["non-split",Size(G)]]); fi; return DTypes; end ); ############################################################################# ## #M IsDihedralGroup( <G> ) . . . . . . . . . . . . . . . . . . generic method ## BindGlobal( "DoComputeDihedralGenerators", function(G) local Zn, G1, T, n, t, s, i; if Size(G) mod 2 <> 0 then return fail; fi; n := Size(G)/2; # find a normal subgroup of G of type Zn if n mod 2 <> 0 then # G = < s, t | s^n = t^2 = 1, s^t = s^-1 > # ==> Comm(s, t) = s^-1 t s t = s^-2 ==> G' = < s^2 > = < s > Zn := DerivedSubgroup(G); if not ( IsCyclic(Zn) and Size(Zn) = n ) then return fail; fi; else # n mod 2 = 0 # G = < s, t | s^n = t^2 = 1, s^t = s^-1 > # ==> Comm(s, t) = s^-1 t s t = s^-2 ==> G' = < s^2 > G1 := DerivedSubgroup(G); if not ( IsCyclic(G1) and Size(G1) = n/2 ) then return fail; fi; # G/G1 = {1*G1, t*G1, s*G1, t*s*G1} T := RightTransversal(G,G1); i := 1; repeat Zn := ClosureGroup(G1,T[i]); i := i + 1; until i > 4 or ( IsCyclic(Zn) and Size(Zn) = n ); if not ( IsCyclic(Zn) and Size(Zn) = n ) then return fail; fi; fi; # now Zn is normal in G and Zn = < s | s^n = 1 > # choose t in G\Zn and check dihedral structure repeat t := Random(G); until not t in Zn; if not (Order(t) = 2 and ForAll(GeneratorsOfGroup(Zn),s->t*s*t*s=s^0)) then return fail; fi; # choose generator s of Zn repeat s := Random(Zn); until Order(s) = n; return [t,s]; end ); InstallMethod( IsDihedralGroup, "for a group", true, [ IsGroup and IsFinite ], 0, function(G) local gens; gens := DoComputeDihedralGenerators(G); if gens = fail then return false; else SetDihedralGenerators(G, gens); fi; return true; end); InstallMethod( DihedralGenerators, "for a group", [ IsGroup and IsFinite ], function(G) local gens; gens := DoComputeDihedralGenerators(G); SetIsDihedralGroup(G, gens <> fail); if gens = fail then ErrorNoReturn("G is not a dihedral group"); fi; return gens; end); ############################################################################# ## #M IsDicyclicGroup( <G> ) . . . . . . . . . . . . . . . . . . generic method #M IsGeneralizedQuaternionGroup( <G> ) . . . . . . . . . . . generic method ## BindGlobal( "DoComputeDicyclicGenerators", function(G) local N, # size of G n, # N/2 a, # N/4 G1, # derived subgroup of G T, # transversal of G/G1 i, # counter Zn, # cyclic normal subgroup of index 2 in G t, s, # canonical generators of the dicyclic group gens; N := Size(G); if N mod 4 <> 0 then return fail; fi; n := N/2; a := n/2; # G = <t, s | s^(2a) = 1, t^2 = s^a, s^t = s^-1> # ==> Comm(s, t) = s^-1 t s t = s^-2 ==> G' = < s^2 > G1 := DerivedSubgroup(G); if not ( IsCyclic(G1) and Size(G1) = a ) then return fail; fi; # find a normal subgroup of G of type Zn # G/G1 = {1*G1, t*G1, s*G1, t*s*G1} T := RightTransversal(G, G1); i := 1; repeat Zn := ClosureGroup(G1,T[i]); i := i + 1; until i > 4 or ( IsCyclic(Zn) and Size(Zn) = n ); if not ( IsCyclic(Zn) and Size(Zn) = n ) then return fail; fi; # now Zn is normal in G and Zn = < s | s^n = 1 > # choose t in G\Zn and check quaternion structure repeat t := Random(G); until not t in Zn; if not (Order(t) = 4 and ForAll(GeneratorsOfGroup(Zn), s->s^t*s = s^0)) then return fail; fi; # choose generator s of Zn repeat s := Random(Zn); until Order(s) = n; gens:= [ t, s ]; SetDicyclicGenerators( G, gens ); return gens; end ); BindGlobal( "DoComputeGeneralisedQuaternionGenerators", function( G ) local N, gens; N:= Size( G ); if not ( IsEvenInt( N ) and IsPrimePowerInt( N ) and N >= 8 ) then return fail; elif HasDicyclicGenerators( G ) then return DicyclicGenerators( G ); fi; gens:= DoComputeDicyclicGenerators( G ); if gens <> fail then SetGeneralisedQuaternionGenerators( G, gens ); fi; return gens; end ); InstallMethod( IsDicyclicGroup, "for a finite group", [ IsGroup and IsFinite ], G -> DoComputeDicyclicGenerators( G ) <> fail ); InstallMethod( IsGeneralisedQuaternionGroup, "for a finite group", [ IsGroup and IsFinite ], G -> DoComputeGeneralisedQuaternionGenerators( G ) <> fail ); InstallMethod( DicyclicGenerators, "for a finite group", [ IsGroup and IsFinite ], function(G) local gens; gens:= DoComputeDicyclicGenerators(G); SetIsDicyclicGroup( G, gens <> fail ); if gens = fail then ErrorNoReturn( "G is not a dicyclic group"); fi; return gens; end); InstallMethod( GeneralisedQuaternionGenerators, "for a finite group", [ IsGroup and IsFinite ], function(G) local gens; gens := DoComputeGeneralisedQuaternionGenerators(G); SetIsGeneralisedQuaternionGroup(G, gens <> fail); if gens = fail then ErrorNoReturn("G is not a generalised quaternion group"); fi; return gens; end); ############################################################################# ## #M IsQuasiDihedralGroup( <G> ) . . . . . . . . . . . . . . . generic method ## InstallMethod( IsQuasiDihedralGroup, "generic method", true, [ IsGroup ], 0, function ( G ) local N, # size of G k, # ld(N) n, # N/2 G1, # derived subgroup of G Zn, # cyclic normal subgroup of index 2 in G T, # transversal of G/G1 t, s, # canonical generators of the quasidihedral group i; # counter if not IsFinite(G) then TryNextMethod(); fi; N := Size(G); k := LogInt(N, 2); if not( 2^k = N and k >= 4 ) then return false; fi; n := N/2; # G = <t, s | s^(2^n) = t^2 = 1, s^t = s^(-1 + 2^(n-1))>. # ==> Comm(s, t) = s^-1 t s t = s^(-2+2^(n-1)) # ==> G' = < s^(-2+2^(n-1)) >, |G'| = n/2. G1 := DerivedSubgroup(G); if not ( IsCyclic(G1) and Size(G1) = n/2 ) then return false; fi; # find a normal subgroup of G of type Zn # G/G1 = {1*G1, t*G1, s*G1, t*s*G1} T := RightTransversal(G, G1); i := 1; repeat Zn := ClosureGroup(G1,T[i]); i := i + 1; until i > 4 or ( IsCyclic(Zn) and Size(Zn) = n ); if not ( IsCyclic(Zn) and Size(Zn) = n ) then return false; fi; # now Zn is normal in G and Zn = < s | s^n = 1 > # now remain only the possibilities for the structure: # dihedral, quaternion, quasidihedral repeat t := Random(G); until not t in Zn; # detect cases: dihedral, quaternion if ForAll(GeneratorsOfGroup(Zn), s -> s^t*s = s^0) then return false; fi; # choose t in Zn of order 2 repeat t := Random(G); until not( t in Zn and Order(t) = 2 ); # prob = 1/4 # choose generator s of Zn repeat s := Random(Zn); until Order(s) = n; SetQuasiDihedralGenerators(G,[t,s]); return true; end ); ############################################################################# ## #M IsAlternatingGroup( <G> ) . . . . . . . . . . . . . . . . generic method ## ## This method additionally sets the attribute `AlternatingDegree' in case ## <G> is isomorphic to a natural alternating group. ## InstallMethod( IsAlternatingGroup, "generic method", true, [ IsGroup ], 0, function ( G ) local n, ids, info; if not IsFinite(G) then TryNextMethod(); fi; if IsNaturalAlternatingGroup(G) then return true;fi; if Size(G) < 60 then if Size(G) = 1 then SetAlternatingDegree(G,0); return true; elif Size(G) = 3 then SetAlternatingDegree(G,3); return true; elif Size(G) = 12 and IdGroup(G) = [ 12, 3 ] then SetAlternatingDegree(G,4); return true; else return false; fi; fi; if not IsSimpleGroup(G) then return false; fi; info := IsomorphismTypeInfoFiniteSimpleGroup(G); if info.series = "A" then SetAlternatingDegree(G,info.parameter); return true; else return false; fi; end ); ############################################################################# ## #M AlternatingDegree( <G> ) generic method, dispatch to `IsAlternatingGroup' ## InstallMethod( AlternatingDegree, "generic method, dispatch to `IsAlternatingGroup'", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if IsNaturalAlternatingGroup(G) then return DegreeAction(G); fi; if not IsAlternatingGroup(G) then return fail; fi; if HasAlternatingDegree(G) then return AlternatingDegree(G); fi; if Size(G) = 1 then return 0; elif Size(G) = 3 then return 3; elif Size(G) = 12 then return 4; else return IsomorphismTypeInfoFiniteSimpleGroup(G).parameter; fi; end ); ############################################################################# ## #M IsNaturalAlternatingGroup( <G> ) . . . . . . . for non-permutation group ## InstallOtherMethod( IsNaturalAlternatingGroup, "for non-permutation group", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsPermGroup(G) then return false; else TryNextMethod(); fi; end ); ############################################################################# ## #M IsSymmetricGroup( <G> ) . . . . . . . . . . . . . . . . . generic method ## ## This method additionally sets the attribute `SymmetricDegree' in case ## <G> is isomorphic to a natural symmetric group. ## InstallMethod( IsSymmetricGroup, "generic method", true, [ IsGroup ], 0, function ( G ) local G1; if IsNaturalSymmetricGroup(G) then return true;fi; if not IsFinite(G) then TryNextMethod(); fi; # special treatment of small cases if Size(G)<=2 then SetSymmetricDegree(G,Size(G)); return true; elif Size(G)=6 and not IsAbelian(G) then SetSymmetricDegree(G,3); return true; fi; G1 := DerivedSubgroup(G); if not (IsAlternatingGroup(G1) and Index(G,G1) = 2) # this requires deg>=4 or not IsTrivial(Centralizer(G,G1)) or Size(G) = 720 and IdGroup(G) <> [ 720, 763 ] then return false; fi; SetSymmetricDegree(G,AlternatingDegree(G1)); return true; end ); ############################################################################# ## #M IsNaturalSymmetricGroup( <G> ) . . . . . . . . for non-permutation group ## InstallOtherMethod( IsNaturalSymmetricGroup, "for non-permutation group", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsPermGroup(G) then return false; else TryNextMethod(); fi; end ); ############################################################################# ## #M SymmetricDegree( <G> ) . . generic method, dispatch to `IsSymmetricGroup' ## InstallMethod( SymmetricDegree, "generic method, dispatch to `IsSymmetricGroup'", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if IsNaturalSymmetricGroup(G) then return DegreeAction(G); fi; if not IsSymmetricGroup(G) then return fail; fi; # calling IsSymmetricGroup may have computed the SymmetricDegree if HasSymmetricDegree(G) then return SymmetricDegree(G); fi; # special treatment of small cases if Size(G)<=2 then return Size(G); elif Size(G)=6 then return 3; fi; return AlternatingDegree(DerivedSubgroup(G)); end ); ############################################################################# ## #F SizeGL( <n>, <q> ) ## InstallGlobalFunction( SizeGL, function ( n, q ) local N, qn, k; N := 1; qn := q^n; for k in [0..n-1] do N := N * (qn - q^k); od; return N; end ); ############################################################################# ## #F SizeSL( <n>, <q> ) ## InstallGlobalFunction( SizeSL, function ( n, q ) local N, qn, k; N := 1; qn := q^n; for k in [0..n-1] do N := N * (qn - q^k); od; return N/(q - 1); end ); ############################################################################# ## #F SizePSL( <n>, <q> ) ## InstallGlobalFunction( SizePSL, function ( n, q ) local N, qn, k; N := 1; qn := q^n; for k in [0..n-1] do N := N * (qn - q^k); od; return N/((q - 1)*(Gcd(n, q - 1))); end ); ############################################################################# ## #F LinearGroupParameters( <N> ) ## InstallGlobalFunction( LinearGroupParameters, function ( N ) local npeGL, # list of possible [n, p, e] for a GL npeSL, # list of possible [n, p, e] for a SL npePSL, # list of possible [n, p, e] for a PSL n, p, e, # N = Size(GL(n, p^e)) pe, p2, ep, # p^ep is maximal prime power divisor of N e2, # a divisor of ep x, r, G; # temporaries if not IsPosInt(N) then Error("<N> must be positive integer"); fi; # Formeln: # |GL(n, q)| = Product(q^n - q^k : k in [0..n-1]) # |SL(n, q)| = |GL(n, q)| / (q - 1) # |PSL(n, q)| = |SL(n, q)| / gcd(n, q - 1) # mit q = p^e f"ur p prim, e >= 1, n >= 1. # Betrachte N = |GL(n,q)|. Dann gilt f"ur n >= 2 # (1) nu_p(N) = e * Binomial(n,2) und # (2) (q - 1)^n teilt N. npeGL := [ ]; npeSL := [ ]; npePSL := [ ]; if N = 1 then return rec( npeGL := npeGL, npeSL := npeSL, npePSL := npePSL ); fi; for pe in Collected(Factors(N)) do p := pe[1]; ep := pe[2]; # find e, n such that (1) e*Binomial(n,2) = ep for e in DivisorsInt(ep) do # find n such that Binomial(n, 2) = ep/e # <==> 8 ep/e + 1 = (2 n - 1)^2 x := 8*ep/e + 1; r := RootInt(x, 2); if r^2 = x then n := (r + 1)/2; # decide it G := SizeGL(n, p^e); if N = G then Add(npeGL,[n, p, e]); fi; if N = G/(p^e - 1) then Add(npeSL, [n, p, e]); fi; if N = G/((p^e - 1)*GcdInt(p^e - 1, n)) then Add(npePSL, [n, p, e]); fi; fi; od; od; return rec( npeGL := npeGL, npeSL := npeSL, npePSL := npePSL ); end ); ############################################################################# ## #M IsPSL( <G> ) ## InstallMethod( IsPSL, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) local npes, npe; # list of possible PSL-parameters if not IsFinite(G) then TryNextMethod(); fi; if Size(G)>12 and not IsSimpleGroup(G) then return false; fi; # check if G has appropriate size npes := LinearGroupParameters(Size(G)).npePSL; if Length(npes) = 0 then return false; fi; # more than one npe-triple should only # occur in the cases |G| in [60, 168, 20160] if Length(npes) > 1 and not( Size(G) in [60, 168, 20160] ) then Error("algebraic panic! probably npe does not work"); fi; # set the parameters npe := npes[1]; # catch the cases: # PSL(2, 2) ~= S3, PSL(2, 3) ~= A4, # in which the PSL is not simple # PSL(2, 2) if npes[1] = [2, 2, 1] then if IsAbelian(G) then return false; fi; SetParametersOfGroupViewedAsPSL(G,npe); return true; # PSL(2, 3) elif npes[1] = [2, 3, 1] then if Size(DerivedSubgroup(G)) <> 4 then return false; fi; SetParametersOfGroupViewedAsPSL(G,npe); return true; # PSL(3, 4) / PSL(4, 2) elif npes = [ [ 4, 2, 1 ], [ 3, 2, 2 ] ] then if IdGroup(SylowSubgroup(G,2)) = [64,138] then npe := npes[1]; elif IdGroup(SylowSubgroup(G,2)) = [64,242] then npe := npes[2]; fi; SetParametersOfGroupViewedAsPSL(G,npe); return true; # other cases else if not IsSimpleGroup(G) then return false; fi; SetParametersOfGroupViewedAsPSL(G,npe); return true; fi; end ); ############################################################################# ## #M PSLDegree( <G> ) . . . . . . . . . . . . generic method for finite groups ## InstallMethod( PSLDegree, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsPSL(G) then return fail; fi; return ParametersOfGroupViewedAsPSL(G)[1]; end ); ############################################################################# ## #M PSLUnderlyingField( <G> ) . . . . . . . generic method for finite groups ## InstallMethod( PSLUnderlyingField, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsPSL(G) then return fail; fi; return GF(ParametersOfGroupViewedAsPSL(G)[2]^ParametersOfGroupViewedAsPSL(G)[3]); end ); ############################################################################# ## #M IsSL( <G> ) . . . . . . . . . . . . . . generic method for finite groups ## InstallMethod( IsSL, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) local npes, # list of possible SL-parameters C; # centre of G if not IsFinite(G) then TryNextMethod(); fi; # check if G has appropriate size npes := LinearGroupParameters(Size(G)).npeSL; if Length(npes) = 0 then return false; fi; # more than one npe-triple should never occur if Length(npes) > 1 then Error("algebraic panic! this should not occur"); fi; npes := npes[1]; # catch the cases: # SL(2, 2) ~= S3, SL(2, 3) # in which the corresponding FactorGroup PSL is not simple # SL(2, 2) if npes = [2, 2, 1] then if IsAbelian(G) then return false; fi; SetParametersOfGroupViewedAsSL(G,npes); return true; # SL(2, 3) elif npes = [2, 3, 1] then if Size(DerivedSubgroup(G)) <> 8 then return false; fi; SetParametersOfGroupViewedAsSL(G,npes); return true; # other cases, in which the contained PSL is simple else # calculate the centre C of G, which should have the # size gcd(n, p^e - 1), and if so, check if G/C (which # should be the corresponding PSL) is simple C := Centre(G); if Size(C) <> Gcd(npes[1],npes[2]^npes[3] - 1) or not IsSimpleGroup(G/C) or Size(G)/2 in List(NormalSubgroups(G),Size) then return false; fi; if IsomorphismGroups(G,SL(npes[1],npes[2]^npes[3])) = fail then return false; fi; SetParametersOfGroupViewedAsSL(G,npes); return true; fi; end ); ############################################################################# ## #M SLDegree( <G> ) . . . . . . . . . . . . generic method for finite groups ## InstallMethod( SLDegree, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsSL(G) then return fail; fi; if HasIsNaturalSL(G) and IsNaturalSL(G) then return DimensionOfMatrixGroup(G); fi; return ParametersOfGroupViewedAsSL(G)[1]; end ); ############################################################################# ## #M SLUnderlyingField( <G> ) . . . . . . . . generic method for finite groups ## InstallMethod( SLUnderlyingField, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsSL(G) then return fail; fi; if HasIsNaturalSL(G) and IsNaturalSL(G) then return FieldOfMatrixGroup(G); fi; return GF(ParametersOfGroupViewedAsSL(G)[2]^ParametersOfGroupViewedAsSL(G)[3]); end ); ############################################################################# ## #M IsGL( <G> ) ## InstallMethod( IsGL, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) local npes, # list of possible GL-parameters G1, # derived subgroup of G C1; # centre of G1 if not IsFinite(G) then TryNextMethod(); fi; # check if G has appropriate size npes := LinearGroupParameters(Size(G)).npeGL; if Length(npes) = 0 then return false; fi; # more than one npe-triple should never occur if Length(npes) > 1 then Error("algebraic panic! this should not occur"); fi; npes := npes[1]; # catch the cases: # GL(2, 2) ~= S3, GL(2, 3) # in which the contained group PSL is not simple # GL(2, 2) if npes = [2, 2, 1] then if IsAbelian(G) then return false; fi; SetParametersOfGroupViewedAsGL(G,npes); return true; # GL(2, 3) elif npes = [2, 3, 1] then if IdGroup(G) <> [48,29] then return false; fi; SetParametersOfGroupViewedAsGL(G,npes); return true; # other cases, in which contained PSL is simple else # calculate the derived subgroup which should be the # corresponding SL of index p^e - 1 G1 := DerivedSubgroup(G); if Index(G, G1) <> npes[2]^npes[3] - 1 then return false; fi; # calculate the centre C1 of G1, which should have the # size gcd(n, p^e - 1), and if so, check if G1/C1 # (which should be the corresponding PSL) is simple C1 := Centre(G1); if Size(C1) <> Gcd(npes[1],npes[2]^npes[3] - 1) or not IsSimpleGroup(G1/C1) then return false; fi; if IsomorphismGroups(G,GL(npes[1],npes[2]^npes[3])) = fail then return false; fi; SetParametersOfGroupViewedAsGL(G,npes); return true; fi; end ); ############################################################################# ## #M GLDegree( <G> ) . . . . . . . . . . . . generic method for finite groups ## InstallMethod( GLDegree, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsGL(G) then return fail; fi; if HasIsNaturalGL(G) and IsNaturalGL(G) then return DimensionOfMatrixGroup(G); fi; return ParametersOfGroupViewedAsGL(G)[1]; end ); ############################################################################# ## #M GLUnderlyingField( <G> ) . . . . . . . . generic method for finite groups ## InstallMethod( GLUnderlyingField, "generic method for finite groups", true, [ IsGroup ], 0, function ( G ) if not IsFinite(G) then TryNextMethod(); fi; if not IsGL(G) then return fail; fi; if HasIsNaturalGL(G) and IsNaturalGL(G) then return FieldOfMatrixGroup(G); fi; return GF(ParametersOfGroupViewedAsGL(G)[2]^ParametersOfGroupViewedAsGL(G)[3]); end ); ############################################################################# ## #M StructureDescription( <G> ) . . . . . . . . . for abelian or finite group ## BindGlobal( "SD_insertsep", # function to join parts of name function ( strs, sep, brack ) local short, s, i; short := ValueOption("short") = true; if strs = [] then return ""; fi; strs := Filtered(strs,str->str<>""); if Length(strs) > 1 then for i in [1..Length(strs)] do if Intersection(strs[i],brack) <> "" then strs[i] := Concatenation("(",strs[i],")"); fi; od; fi; s := strs[1]; for i in [2..Length(strs)] do s := Concatenation(s,sep,strs[i]); od; if short then RemoveCharacters(s," "); fi; return s; end); BindGlobal( "SD_cyclic", function ( n ) if n = 0 or n = infinity then return "Z"; fi; return Concatenation("C",String(n)); end); BindGlobal( "SD_cycsaspowers", # function to write C2 x C2 x C2 as 2^3, etc. function ( name, cycsizes ) local short, g, d, k, j, n; short := ValueOption("short") = true; if not short then return name; fi; RemoveCharacters(name," "); cycsizes := Collected(cycsizes); for n in cycsizes do d := n[1]; k := n[2]; g := SD_cyclic(d); if d = 0 then d := "Z"; else d := String(d); fi; if k > 1 then for j in Reversed([2..k]) do name := ReplacedString(name,SD_insertsep(List([1..j],i->g),"x",""), Concatenation(d,"^",String(j))); od; fi; od; RemoveCharacters(name,"C"); return name; end); BindGlobal( "StructureDescriptionForAbelianGroups", # for abelian groups function ( G ) local cycsizes; # sizes of cyclic factors of G # special case trivial group if IsTrivial(G) then return "1"; fi; # special case abelian group cycsizes := AbelianInvariants(G); cycsizes := Reversed(ElementaryDivisorsMat(DiagonalMat(cycsizes))); cycsizes := Filtered(cycsizes,n->n<>1); return SD_cycsaspowers(SD_insertsep(List(cycsizes, SD_cyclic), " x ",""), cycsizes); end ); BindGlobal( "StructureDescriptionForFiniteSimpleGroups", # for simple groups function ( G ) local name, # buffer for computed name series, # series of simple groups parameter; # parameters of G in series # special case abelian group if IsAbelian(G) then return StructureDescriptionForAbelianGroups(G); fi; # special case alternating group if IsAlternatingGroup(G) then return Concatenation("A",String(AlternatingDegree(G))); fi; # special case PSL if IsPSL(G) then return Concatenation("PSL(",String(PSLDegree(G)),",", String(Size(PSLUnderlyingField(G))),")"); fi; name := SplitString(IsomorphismTypeInfoFiniteSimpleGroup(G).name," "); name := name[1]; if Position(name,',') = fail then RemoveCharacters(name,"()"); else series := IsomorphismTypeInfoFiniteSimpleGroup(G).series; parameter := IsomorphismTypeInfoFiniteSimpleGroup(G).parameter; if series = "2A" then name := Concatenation("PSU(",String(parameter[1]+1),",", String(parameter[2]),")"); elif series = "B" then name := Concatenation("O(",String(2*parameter[1]+1),",", String(parameter[2]),")"); elif series = "2B" then name := Concatenation("Sz(",String(parameter),")"); elif series = "C" then name := Concatenation("PSp(",String(2*parameter[1]),",", String(parameter[2]),")"); elif series = "D" then name := Concatenation("O+(",String(2*parameter[1]),",", String(parameter[2]),")"); elif series = "2D" then name := Concatenation("O-(",String(2*parameter[1]),",", String(parameter[2]),")"); elif series = "3D" then name := Concatenation("3D(4,",String(parameter),")"); elif series in ["2F","2G"] and parameter > 2 then name := Concatenation("Ree(",String(parameter),")"); fi; fi; return name; end ); BindGlobal( "StructureDescriptionForFiniteGroups", # for finite groups function ( G ) local G1, # the group G reconstructed; result Hs, # split factors of G Gs, # factors of G cyclics, # cyclic factors of G cycsizes, # sizes of cyclic factors of G noncyclics, # noncyclic factors of G cycname, # part of name corresponding to cyclics noncycname, # part of name corresponding to noncyclics name, # buffer for computed name cname, # name for centre of G dname, # name for derived subgroup of G NH, H, N, N1, # semidirect factors of G NHs, # [N, H] decompositions NHname, # name of NH NHs1, # NH's with preferred N and H NHs1Names, # names of products in NHs1 len, # maximal number of direct factors g, # an element of G id, # id of G in the library of perfect groups short, # short / long output format nice, # nice output (slower) i,j, # counters primes, # prime divisors of Size(G) d, # divisor of Size(G) k, # maximal power of d in Size(G) pi; # subset of primes short := ValueOption("short") = true; nice := ValueOption("nice") = true; # fetch name from precomputed list, if available if ValueOption("recompute") <> true and Size(G) <= 2000 then if IsBound(NAMES_OF_SMALL_GROUPS[Size(G)]) then i := IdGroup(G)[2]; if IsBound(NAMES_OF_SMALL_GROUPS[Size(G)][i]) then name := ShallowCopy(NAMES_OF_SMALL_GROUPS[Size(G)][i]); cycsizes := []; if short then # DivisorsInt is rather slow, but we only call it for small groups for d in Reversed(DivisorsInt(Size(G))) do if d >1 then k := LogInt(Size(G), d); if k>1 then for j in [1..k] do Add(cycsizes, d); od; fi; fi; od; fi; return SD_cycsaspowers(name, cycsizes); fi; fi; fi; # special case trivial group if IsTrivial(G) then return "1"; fi; # special case abelian group if IsAbelian(G) then return StructureDescriptionForAbelianGroups(G); fi; # special case alternating group if IsAlternatingGroup(G) then return Concatenation("A",String(AlternatingDegree(G))); fi; # special case symmetric group if IsSymmetricGroup(G) then return Concatenation("S",String(SymmetricDegree(G))); fi; # special case dihedral group if IsDihedralGroup(G) and Size(G) > 6 then return Concatenation("D",String(Size(G))); fi; # special case quaternion group if IsQuaternionGroup(G) then return Concatenation("Q",String(Size(G))); fi; # special case quasidihedral group if IsQuasiDihedralGroup(G) then return Concatenation("QD",String(Size(G))); fi; # special case PSL if IsPSL(G) then return Concatenation("PSL(",String(PSLDegree(G)),",", String(Size(PSLUnderlyingField(G))),")"); fi; # special case SL if IsSL(G) then return Concatenation("SL(",String(SLDegree(G)),",", String(Size(SLUnderlyingField(G))),")"); fi; # special case GL if IsGL(G) then return Concatenation("GL(",String(GLDegree(G)),",", String(Size(GLUnderlyingField(G))),")"); fi; # other simple group if IsSimpleGroup(G) then return StructureDescriptionForFiniteSimpleGroups(G); fi; # direct product decomposition Gs := DirectFactorsOfGroup( G ); if Length(Gs) > 1 then # decompose the factors Hs := List(Gs,StructureDescription); # construct cyclics := Filtered(Gs,IsCyclic); if cyclics <> [] then cycsizes := ElementaryDivisorsMat(DiagonalMat(List(cyclics,Size))); cycsizes := Filtered(cycsizes,n->n<>1); cycname := SD_cycsaspowers(SD_insertsep(List(cycsizes, SD_cyclic), " x ",":."), cycsizes); else cycname := ""; fi; noncyclics := Difference(Gs,cyclics); noncycname := SD_insertsep(List(noncyclics,StructureDescription), " x ",":."); return SD_insertsep([cycname,noncycname]," x ",":."); fi; # semidirect product decomposition if not nice then NH := SemidirectDecompositionsOfFiniteGroup( G, "str" ); if NH <> fail then H := NH[2]; N := NH[1]; return SD_insertsep([StructureDescription(N), StructureDescription(H)]," : ","x:."); fi; else NHs := [ ]; for NH in SemidirectDecompositions( G ) do if not IsTrivial( NH[1] ) and not IsTrivial( NH[2] ) then AddSetIfCanEasilySortElements(NHs, [ NH[1], NH[2] ]); fi; od; if Length(NHs) > 0 then # prefer abelian H; abelian N; many direct factors in N; phi injective NHs1 := Filtered(NHs, NH -> IsAbelian(NH[2])); if Length(NHs1) > 0 then NHs := NHs1; fi; NHs1 := Filtered(NHs, NH -> IsAbelian(NH[1])); if Length(NHs1) > 0 then NHs := NHs1; len := Maximum( List(NHs, NH -> Length(AbelianInvariants(NH[1]))) ); NHs := Filtered(NHs, NH -> Length(AbelianInvariants(NH[1])) = len); fi; NHs1 := Filtered(NHs, NH -> Length(DirectFactorsOfGroup(NH[1])) > 1); if Length(NHs1) > 0 then NHs := NHs1; len := Maximum(List(NHs,NH -> Length(DirectFactorsOfGroup(NH[1])))); NHs := Filtered(NHs,NH -> Length(DirectFactorsOfGroup(NH[1]))=len); fi; NHs1 := Filtered(NHs, NH -> IsTrivial(Centralizer(NH[2],NH[1]))); if Length(NHs1) > 0 then NHs := NHs1; fi; if Length(NHs) > 1 then # decompose the pairs [N, H] and remove isomorphic copies NHs1 := []; NHs1Names := []; for NH in NHs do NHname := SD_insertsep([StructureDescription(NH[1]), StructureDescription(NH[2])], " : ","x:."); if not NHname in NHs1Names then Add(NHs1, NH); Add(NHs1Names, NHname); fi; od; NHs := NHs1; if Length(NHs) > 1 then Info(InfoWarning,2,"Warning! Non-unique semidirect product:"); Info(InfoWarning,2,List(NHs,NH -> List(NH,StructureDescription))); fi; fi; H := NHs[1][2]; N := NHs[1][1]; return SD_insertsep([StructureDescription(N:nice), StructureDescription(H:nice)]," : ","x:."); fi; fi; # non-splitting, non-simple group if not IsTrivial(Centre(G)) then cname := SD_insertsep([StructureDescription(Centre(G)), StructureDescription(G/Centre(G))]," . ","x:."); fi; if not IsPerfectGroup(G) then dname := SD_insertsep([StructureDescription(DerivedSubgroup(G)), StructureDescription(G/DerivedSubgroup(G))], " . ","x:."); fi; if IsBound(cname) and IsBound(dname) and cname <> dname then return Concatenation(cname," = ",dname); elif IsBound(cname) then return cname; elif IsBound(dname) then return dname; elif not IsTrivial(FrattiniSubgroup(G)) then return SD_insertsep([StructureDescription(FrattiniSubgroup(G)), StructureDescription(G/FrattiniSubgroup(G))], " . ","x:."); elif IsPosInt(NrPerfectGroups(Size(G))) and not Size(G) in [ 86016, 368640, 737280 ] # this does not happen for Size(G)<10^6 then id := PerfectIdentification(G); return Concatenation("PerfectGroup(",String(id[1]),",", String(id[2]),")"); else return Concatenation("<a non-simple perfect group of order ", Size(G)," with trivial centre and trivial Frattini ", "subgroup, which cannot be written as a direct or ", "semidirect product of smaller groups>"); fi; end ); InstallMethod( StructureDescription, "for abelian groups", true, [ IsGroup and IsAbelian ], 0, StructureDescriptionForAbelianGroups ); RedispatchOnCondition( StructureDescription, true, [ IsGroup ], [ IsAbelian ], 0); InstallMethod( StructureDescription, "for finite simple groups", true, [ IsGroup and IsFinite and IsSimpleGroup ], 0, StructureDescriptionForFiniteSimpleGroups ); InstallMethod( StructureDescription, "for finite groups", true, [ IsGroup and IsFinite ], 0, StructureDescriptionForFiniteGroups ); RedispatchOnCondition( StructureDescription, true, [ IsGroup ], [ IsFinite ], 0); ############################################################################# ## #M ViewObj( <G> ) . . . . . . . . for group with known structure description ## InstallMethod( ViewObj, "for groups with known structure description", true, [ IsGroup and HasStructureDescription ], SUM_FLAGS, function ( G ) if HasName(G) then TryNextMethod(); fi; Print(StructureDescription(G)); end );
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.46Angebot (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-13) ¤*Eine klare Vorstellung vom Zielzustand |
|
||||||||||||||
2026-10-11