############################################################################# ## ## This file is part of GAP, a system for computational discrete algebra. ## This file's authors include Alexander Hulpke. ## ## 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 the declarations of operations for factor group maps ##
############################################################################# ## #M NaturalHomomorphismsPool(G) . . . . . . . . . . . . . . initialize method ##
#Fjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
G:[engthoole)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
[,[falsedfalse)
############################################################################# ## #F EraseNaturalHomomorphismsPool(G) . . . . . . . . . . . . initialize ##
InstallGlobalFunction:Filtered(p b:=List(OG{,Immutable
ocal
r:=java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [19, 14) out of bounds for length 35
r.GopDone:=false;
r :K(java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 17
r.:[;
r.cost:=[];
r.group:=G;c= found:=;
r.lock:=[];
r.intersects=[
r.blocksdone:=
r.in_code:=AddNaturaG,,op);
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
endjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
############################################################################# ## #F AddNaturalHomomorphismsPool(G,N,op[,cost[,blocksdone]]) . Store operation ## op for kernel N if there is not already a cheaper one ## returns false if nothing had been added and 'fail' if adding was ## forbidden ##
InstallGlobalFunction
newb= ;
G:=arg;
N:=arg[2
op:[;
# don't store trivial cases:(newb]) if Size(psub: (java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
returnfalse; eliffi
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 if not (AddSet(java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 27
# fi;
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 47
false fi
Info fi
pool:=java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
# split lists in their components if for i inl ,b java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 34
p:=[]
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
o:=Set(o,Set);
c:=Intersection(G,KernelOfMultiplicativeGeneralMapping(i));
java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
GN fi;
=CoreG fijava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
(G,,)
od;
: # closing migh abig java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 75
:# recreate if Length(arg)<4nu=(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34 # add the prices
:poolc{);
n(UNjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15 # compute/get costs elif Length(java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 5
InstallMethodFactorCosetAction
java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37 if IsGroup(java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0
c=(java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 57 elif IsMapping hom*DoFactorCosetAction(NiceObject
op;
;
c:=1;
InstallOtherMethod
c:="On cosetsof java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10 else
:Sizel ,mgsdjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
fi; fi TryNextMethod)
:ListLx-FactorCosetAction # store known information(we do't act, just store the subgroup).
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 if p=fail then if pool.in_code then
return fail; fi;
p:=PositionSortedif Length # compute the permutation we have to apply finally (java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 66
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
[.Length(ker]);bljava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 14
# first add at the end
p:=Length(pool.kerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pool.ker[p]:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#############################################################################
elif#F GenericFindActionKernel random search for subgroup with faithful core
Info(InfoFactor,4(Hbs
:; elif pool , ,knowi ,,,ermbadcoresi,;
erg:
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
perm:=(); # update dependent costs
ch:=[p];
diff:=[pool.cost[p]-badcores:=[]; whilebadi:=BADINDEX
=];
nd:=[]; for i in
IsList.
bbkb,,java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 73
) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
involved=(List(P(ch)))
pool.cost[i]:=pool.cost Info MinimumIndexNC,)nowi<
Addnch)
Add,java.lang.StringIndexOutOfBoundsException: Range [27, 27) out of bounds for length 24
((,java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 72 fi;
ch:=nch;
diff:=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
odjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7 fi;
if IsMappingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(opN; fi;
poolopsp]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
lock[]=
# update the costs of all intersections that are affected
.java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35 if IsList(pool.ops[i
java.lang.StringIndexOutOfBoundsException: Range [26, 20) out of bounds for length 38
() notbb[](u),N) and Size<SizeSolvableRadical if IsSubset(SolvableRadical(u),N) and Size(N)<Size(SolvableRadical(u)) then
od;
if affine needed,rest will have wrong
poolblocksdonepsTF(["1]nmaxheap); else
pool.blocksdone[p]:=false; fi maxTryMaximalSubgroupClassReps(u:inmax,cheap);
if perm<>() then # sort the kernels anew
pool.ker:=Permuted(pool.ker,perm); # sort/modify the other components accordingly
pool.ops:= fbdom> then for i in [1..Length(pool.ops)] do
tries are :=et(b->Immutable(({i})); fijava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
pool.ops[i]:=List(pool.ops[i],i->i^perm); fi;
pool.cost:=Permutedif java.lang.StringIndexOutOfBoundsException: Range [43, 11) out of bounds for length 49
.fi;
pool.blocksdone:=Permuted(pool.local # and note whether we got better
pool.intersects:=Set(pool.intersects
Inf( i=L)
(, end);
############################################################################# ## #F LockNaturalHomomorphismsPool(G,N) . . store flag to prohibit changes of ## the map to N ##
(ockNaturalHomomorphismsPoolfunctionGNjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
local
pool:NaturalHomomorphismsPool;ifimprove
N:=PositionSet(pool.ker,N); if N<>fail then
pool.lock[N]:=true# ; fi
)
############################################################################# ## #F UnlockNaturalHomomorphismsPool(G,N) . . . clear flag to allow changes of ## the map to N ##
(UnlockNaturalHomomorphismsPoolfunction(G,)
local pool;
pool:=java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9
:.,N) if N<>fail then
pool.lock[N]:=false s:=ActionHomomorphism(G,o[i]end; fi; end);
############################################################################# ## #F KnownNaturalHomomorphismsPool(G,N) . . . . . check whether Hom is stored ## (or obvious) ##
Info(InfoFactor" reduce to ,ength())
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s:s*SmallerDegreePermutationRepresentation(Image();
############################################################################# ## #F GetNaturalHomomorphismsPool(G,N) . . . . get operation for G/N if known ##
InstallGlobalFunction=Imagemapjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
local pool ; ifnotHasNaturalHomomorphismsPool(G Length(ma)> then
return fail; fi;
pool: (g,n;
p:=PositionSet(pool.ker,N); if p<>fail then
i: s:=GenericFindActionKernel:enericFindActionKernel(H,TrivialSubgroup(H),NrMovedPoints(H)); if IsList(h) then # just stored as intersection. Construct the mapping!
ise:=java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5 for (x--); if #F ImproveActionDegreeByBlocks( <G>, <N> , hom )
ion of <U> in <G> such that \bigcap U^g=N remains
(ise,j;
od; elif not,b,improve,bp,bb,i,k,estdeg,subo,op,bcjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
h:=GetNaturalHomomorphismsPool(G,pool.ker[i]);
pool.in_code:=true # (which would mess up the numbering)
ImproveActionDegreeByBlocks(G,pool.ker[i],h);
pool.in_code:=false; fi;
od;
:=List(ise,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 if not (ForAll(ise,IsPcGroup) or java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 19
ise=(,x-x*IsomorphismPermGroup(magex);
b.bl:];
=20java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
:=[.Length
emb:=List(GeneratorsOfGroup(G),
i->Product(java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
ise:= =(G;
h:=InstallMethod(FindActionKernel,"perm",IsIdenticalObj,
SetKernelOfMultiplicativeGeneralMapping(h,N);
pool.ops[p]:=h; elifdom:java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
Fjava.lang.StringIndexOutOfBoundsException: Range [58, 26) out of bounds for length 58
i
pifsubo>fail :CG[o]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
;
return p; end);
############################################################################# ## #F DegreeNaturalHomomorphismsPool(G,N) degree for operation for G/N if known ## while <=ength(subo[j])=
local p,pool;;
bb:= v:=RightTransverdomi-])java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
p:=First([1..Length if p=fail then
p=(pool# quickerIfthe is havea proof anyhow. fi; if p<>fail then
p:=pool.cost[p]; fi;
storandom:100; end);
############################################################################# ## #F CloseNaturalHomomorphismsPool(<G>[,<N>]) . . calc intersections of known ## operation kernels, don't continue anything which is smaller than N ##
CloseNaturalHomomorphismsPool,(rg j);
local G,pool,p,comb,i,c,perm,isi,N fi;
G:=arg[1];
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
.ker;
Npos:=fail;
# get those p that lie above N store regular to have one anyway
p:=Filtered(p,iIsSubset(ker[,=ndexNCG,)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26 if Length(
return; fi;
:bjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
Lengtho)1then # N in pool
Npos:=p[1];
c:=pool.cost[ citerate greedily immediately)
p:Filteredp,->.cost[x<) fi; else
SortParallel(List(pool.ker{p},Size),p);
N v=NaturalHomomorphismByNormalSubgroupNCImage(,u; fi;
if Size(Intersection(pool.ker{p})i Iage(act,u; # cannot reach N
IsInt(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
# determine inclusion, derivedfi fi;
k)= ;
improve=rue; for i in [1..Length(p)] do
psub[p[i # then we should look at the orbits of the normal subgroup to see, # whether anything stabilizing can be of use
AddSet(discard,p[i]); fi;
co:=iltered((,dom>(OrbitGjava.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 23 if<fail c=ClosureGroup(N;;
pder[p[i]]:=Position(pool.ker,c);
od; #if Length(discard)>0 then Error(discard);fi; #discard:=[];
p:=Filtered(p,x->not x in discard);
i trytofind
new:=p;
repeat # now intersect, staring from top if new=p thenif cnt:=;
combbadcomb=] else
=] fi;
comb:=Filtered start: (InfoFactor,,Trying)
Info(InfoFactor,,CloseNaturalHomomorphismsPool, Combinations[1.(v]cnt)do
new:=[];
discard=]java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
while
co: u:=SubgroupNC recurse=function(,lev
o:ClosureGroup(,); if not (co[1] in psub[co[2]] or co[2] (InfoFactor =Size(G)o;
;
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
.x]=oolcost[co[]+.cost[[o]) # or both intersect in an abelian factor?
or (N<>fail and # first force blocks
and pder[co[;
c:=Intersection(pool.ker[co[1]],pool.ker[co[2]]);
pos=osition(.kerc); if pos=fail or pool.cost[pos]>pool.cost[co[1]]+pool.cost[co[2]] then
Info(InfoFactor,3,";
Size(pool.ker[co Info(InfoFactor,2"Blocks to else " fijava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
ShallowCopyco)
# unpack 'iterated' lists if IsList(pool.ops[co[2]]) and IsIntreturn false;
isi:= end fi;
hom2:return recursestart,)
isi:=Concatenation(if > java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
isi:=Set(isi);
perm=AddNaturalHomomorphismsPool(isi,(costco});## if(indActionKernelperm"
pos:=Position(pool.ker,#############################################################################IsPermGroup,sPermGroup,0,
p:=List(p,i->i^perm);
new:=List(InstallMethod(NaturalHomomorphismByNormalSubgroupOp,
discard:=OnSets(discard, "search for operation",IsIdenticalObj[IsGroup,IsGroup]0, #pder:=Permuted(List(pder,x->x^perm),perm); forkin [.Length(der]do if IsPosInt(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Add(pder,0);
pder:=Permuted(pder,perm); #psub:=Permuted(List(psub,x->OnTuples(x,perm)));
od; if IsList(psub[k] IndexNC[-1,dom[]<= then
od;
Add(psub,0);
: G)
Apply(comb,j- andN=G then
# add new c if needed
; if IsSubset(pool.ker[j],c) then
fi
AddSet( fi ; fi;
od;
java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 59
pder[pos]:=fail;
Image,N); if perm<>() then Error("why vNaturalHomomorphismByNormalSubgroupNC(ct));
psubjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
fi;
AddSet(new,pos); if ForAny( [IsGroup] o # its solvablefactorwe do differently
AddSet(discard, AddNaturalHomomorphismsPool,act*,)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51 fi;
pder[pos]:=fail; CloseNaturalHomomorphismsPool,;
I,[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0 fi;
elseInfo,,Orbits known, best Index ",bestdeg);
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
Size#M NaturalHomomorphismByNormalSubgroup( <G>, <N> ) . . for solvable factors " yields## fi
fi;
i:=i+1;
IsIdenticalObj IsPermGroup java.lang.StringIndexOutOfBoundsException: Range [49, 44) out of bounds for length 50 #discard:=[];
rd do
p:=Difference(Union(p,new),discard);
new:
SortParallel(List(pool.ker{ := if ,Nthen
SortParallel(List(pool :=DegreeNaturalHomomorphismsPool(,N
until Length(new Size(s> if A<50 or (IsInt(A) and,NLogInt(GN)2^then
end:=iltered(OrbitsDomain(),i->i)>);
############################################################################# ## #F FactorCosetAction( <G>, <U>, [<N>] ) operation on the right cosets Ug ## with possibility to indicate kernel ##
InstallGlobalFunction("DoFactorCosetAction",function(arg)
local G,u :Core(G,v);
G:=arg[1];
u:arg2]java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12 if Length(arg
N:=rg3]]; else
N:=false;
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5 if IsListu and;
u:=G;
Error(G,)NrMovedPoints(G) fi; if N=# try also intersections
N:=Core((G,); fi;
rt:=RightTransversal if bestdeg:=DegreeNaturalHomomorphis(,N; # the right transversal has no special `PositionCanonical' method.
rt:=List(rt,i->RightCoset(u,java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0 fifijava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
h:=ActionHomomorphism(G,rt,OnRight,"surjective");
op:=Image(h,G);
SetSize(op,IndexNC(G,N));
# and note our knowledge
SetKernelOfMultiplicativeGeneralMapping(h,N);
AddNaturalHomomorphismsPool(G,java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 37
return h end);
InstallMethod(GetNaturalHomomorphismsPool(G,N));
IsIdenticalObj,[IsGroup,IsGroup],0, functionfi
return blocksdone:java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
InstallOtherMethod(FactorCosetAction, "by :=CreateIsomorphicPcGrouppcgs,false,false);
[IsGroup,IsGroup,IsGroup] function(G,U,N)
return UseFactorRelation G N, A ); end);
allMethod(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
IsIdenticalObj,[IsGroup and IsHandledByNiceMonomorphism,IsGroup],0, function(G,U)
local hom;
#whether anything stabilizing can be of use
return hom*( =iltered((dom,-O(GG1])>ength(); end);
InstallOtherMethod(FactorCosetAction, "by transversal operation, given filter := IsPermGroupGeneralMappingByImages a
[IsGroup IsToPcGroupGeneralMappingByImages and function(G,U,N)
local hom;
homIsGroupGeneralMappingByPcgsjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
returnhom*DoFactorCosetAction(G)Image(om,),Image andHasRange java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38 end)java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
# action on lists of subgroups
InstallOtherMethod(FactorCosetAction, "On cosets of list of groups",IsElmsColls,
[IsList],0, function(G,L)
local q,i,gens,imgs,d; if LengthForAnybadnormals,->sSubset(s)
TryNextMethod(map,subgroup weget wayjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58 fi;
q:=List( if (mjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 45
gens:=MappingGeneratorsImages(q[1])[1];
ens->ImagesRepresentative(x,y))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
d:=imgs[1]; for ;
d:=SubdirectDiagonalPerms(d,imgs[i]);
od;
imgs:=();
roupHomomorphismByImagesNC(G,imgs,gens,d);
return q; end);
############################################################################# ## #M DoCheapActionImages(G) . . . . . . . . . . All cheap operations for G ##
java.lang.StringIndexOutOfBoundsException: Range [33, 13) out of bounds for length 69
InstallMethod(DoCheapActionImages,permutationI function(G)
local return ;
found,type;
nlykernel:=ValueOption(" bestdeg:IndexNC(G,s)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
found:=NrMovedPoints(G);
pool:=NaturalHomomorphismsPool(G);
#############################################################################
# do orbits and test for blocks for i in o do
Length # only works if domain are the first n points
rnat,;
op:=ActionHomomorphism( # try to find a subgroup, which does not contain any part of m
Range(op:onlyimage); #`onlyimage' forces same generators r:= wreathproducts (the initial aim), the following method works
AddNaturalHomomorphismsPool(G,Stabilizer k in NaturalHomomorphismsPool()ker do
op,Length(i)) := nat:=homG,,FilteredGeneratorsOfGroup(G,inot iinm);
type:=1; else
op:=IdentityMapping(G);
type:=2;
java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
Go############################################################################# Info(InfoFactor,3,"Trying",cnt);
mov:=MovedPoints( for comb in CombiinCombinations([#
allb rint""omb\";
allbold:=[];
allb,ength ForAny,-sSubset() while Length(allb)>0do
ju=(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
Add(allbold,j);
=KernelOfMultiplicativeGeneralMappinghom) # >1. if Length(i)/Length( ifidx10and (java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
u permimagewon' besufficiently large
AddSet(badcomb,(comb)) Info(2,Factor subgroup index ,ndexp,);
op:=ActionHomomorphism(G,Set(b),OnSets,"java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Range [7, 5) out of bounds for length 26 ifnotdk if onlykernel<>fail and k=onlykernel and Length(b)<found then
found:=Length(b); fi;
AddNaturalHomomorphismsPool(G,k,op);
# also one finer blocks (to make up for iterating only once) if type=
newb InfoInfoFactor,3,Core" Info(InfoFactor,3,"Core ",comb else
newb:=Blocks(Go, sub:=; fi;
if (newb)>1
newb (badnormals,); if not (newb in allb or newb;
(newb)
SortBy(allb,Length); fi; fiInfo(InfoFactor,3,"ore"c, succeeded")
fi;
od;
#if Length(i)<500 and Size(Go)>10*Length(i) then #else # # one block system # b:=Blocks(G,i); # if Length(b)>1 then # Add(bl,Immutable(Set(b))); # fi; # fi;
od;
pool. SortByblocksdone:flse; fi;
end);
BindGlobal("DoActionBlocksForKernelcnt:=0; function(G,mustfaithful) fi
domfi; # orbits
o(,);
o:=Set(o,Set);
# all good blocks
bl:=dom;
allb:=ShallowCopy(RepresentativesMinimalBlocks(G,dom)); for sdsub) if : k:n(k)
(ore(mustfaithful,Stabilizer(mustfaithful,j,OnSets)))=1 then
b:=Orbit(G,j,OnSets);
blb; # also one finer blocks (as we iterate only once)
newb: i if Length(newb)>1then
newb:=Union(newb[1]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 if newbnewb then
Add(allb,newb); fi blocks fi; fi
od; if Length(bl)<Length(dom) then
return bl; else
return fail; fi;
end);
############################################################################# ## #F GenericFindActionKernel random search for subgroup with faithful core ##
BADINDEX:=1000; # the index that is too bigif bestdeg(,)or
indGlobal("GenericFindActionKernel",function()
uc ,cntHasSizeden) then
totalcnt, interrupt, u, nu, cor, ( java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 49
G:=arg[1];
bestde:DegreeNaturalHomomorphismsPool(N)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
Lengtharg (nfoFactor,, search ,;
knowi:=arg[3]; else
knowi:=IndexNC fi;
# special treatment for solvable groups. This will never be triggered for # perm groups or nice groups if StabChainOptionsactPermRepMaxDesc(G,N,)
perm:ActionHomomorphism(,(G)OnRight,"surjective");
perm:=perm*IsomorphismPcGroup(Image(perm));
perm fi;
if HasAbelianFactorGroup(,N) if IsPermGroup(G) and SizeTryNextMethod(;
IdentityMapping()java.lang.StringIndexOutOfBoundsException: Range [32, 0) out of bounds for length 0 else (GN,GetNaturalHomomorphismsPool(,N));
perm:=ActionHomomorphism(,RightCosets(,,nRight,surjective") fi;
java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 7
bigperm=IsPermGroup(G) and NrMovedPoints()>0000;
# what is a good degree:
goodi:Minimum(Int(knowi*9/10),LogInt(IndexNC(G,N),2)^2);
simple:=HasIsNonabelianSimpleGroup(G) and IsNonabelianSimpleGroup return
uc:=TrivialSubgroup(G); # look if it is worth to look at action on N # if not abelian: later replace by abelian Normal subgroup if IsAbelian(N) and (Size(N)>50 or IndexNC(G,N)<Factorial(Size(N)))
and Size(N)<50000then
zen:=Centralizer(G,N);
;
cnt:=0;
repeat
cnt:=cnt+1;
zen:=Centralizer(G,Random############################################################################# if (simple or #M FindActionKernel(<G>) . . . . . . . . . . . . . . . . . . . . generic
uc:=zen; fi; # until enough searched or just one orbitInstallMethod(indActionKernel,Niceo"IsIdenticalObj,
until cnt=9 or (IndexNC(G,zen)+1=Size(N));
[sGroup and IsHandledByNiceMonomorphism,IsGroup],0, else
Info(InfoFactor,3,"centralizer too big"); fi; fi;
omextension step # (We might always first add a random element and get something bigger)
v:=N;
#if Length(arg)=3 then ## in one example 512->90, ca. 40 tries BindGlobal("FACTGRP_TRIV",Group([],())); #else #cnt:=25; #fi;
badcores:=[];
badi:=BADINDEX;
hard:=ValueOption("hard"); if hard=fail then
hard:=100000; elif hard=true then
hard:=10000; fi;
totalcnt:=0;
interrupt:=false;
cnt:=20;
repeat
u:=v;
repeat
repeat if Length(arg)<4 or Random## permutation group (with which we can compute much easier). if IsCyclic(u) and Random,IsGroupIsGroup]0java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60 # avoid being stuck with a bad first element
u:=Subgroup(G,[Random(G)]); fi; if Length(GeneratorsOfGroup(u))<2then # closing might cost a big stabilizer chain calculation -- just # recreate
nu:=Group(Concatenation(GeneratorsOfGroup(u),[Random(G)])); else
nu:=ClosureGroup(u,Random(G)); fi; else if Length(GeneratorsOfGroup(u))<2then # closing might cost a big stabilizer chain calculation -- just# catch the trivial case N=G # recreateif CanComputeIndex(G,N)and IndexNC(G,)1then
nu=Group(Concatenation(GeneratorsOfGroup(u,[Randomarg4)])); else
nu:=h:=GroupHomomorphismByImagesNC,GeneratorsOfGroup )
Li( ( G) ->())java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78 fi;
SetParent(nu,G);
totalcnt:=totalcnt+1; if KnownNaturalHomomorphismsPool(G,N) and
Minimum(IndexNC(G,v),knowi)<hard
and 5*totalcnt return ; # interrupt if we're already quite good
interrupt:=true; fi; if ForAny(badcores,x->IsSubset(nu,x)) then
nu:=u; fi; # Abbruchkriterium: Bis kein Normalteiler, es sei denn, es ist N selber # (das brauchen wir, um in einigen trivialen F"allen abbrechen zu # k"onnen) #Print("nu=",Length(GeneratorsOfGroup(nu))," : ",Size(nu),"\n");
until
# der Index ist nicht so klein, da"s wir keine Chance haben
(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0 # check, whether we already know a factormap
( =)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
not IsNormal(G,nu)) or IsSubset(u,nu) or interrupt;
Info(InfoFactor,4,"Index ",IndexNC(G,nu));
u:=nu;
until totalcnt>300 or # und die Gruppe ist nicht zuviel schlechter als der # beste bekannte Index. Daf"ur brauchen wir aber wom"oglich mehrfache # Erweiterungen.
interrupt or (((Length(arg)=2 or IndexNC(G,u)<knowi)));
if IndexNC(G,u)<knowi then
#Print("Index:",IndexNC(G,u),"\n");
if simple and u<>G then
cor:=TrivialSubgroup(G); else
cor:=Core(G,u); fi; if Size(cor)>Size(N) and IsSubset(cor,N) and not cor in badcores then
Add(badcores,cor); fi;
(we ' act subgroupsubgroup. # Thus this is fairly cheap
pool.dotriv:=true;
zzz:=AddNaturalHomomorphismsPool(G,corfi
if IsPerm(zzz) and zzz<>() then
CloseNaturalHomomorphismsPoolGN)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43 fi
pool.dotriv:=false;
zzz:=DegreeNaturalHomomorphismsPool(G,N);
Info(InfoFactor,3," ext ",cnt,": ",IndexNC(G,u)," best degree:",zzz);
if cnt<10 and Size(cor)>Size(N) and IndexNC(G,u)*2<knowi and
ValueOption("inmax")=fail then
java.lang.StringIndexOutOfBoundsException: Range [19, 10) out of bounds for length 83 # only affine ones are needed, rest will have wrong kernel
max:=DoMaxesTF(["1]inmax,heap; else
max:=TryMaximalSubgroupClassReps(u:inmax,cheap); fi;
max:=Filtered(max,x->IndexNCjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0 for i max
cor:=Core(Gif <failandRootInth^3,<(G)then
h=GetNaturalHomomorphismsPool(G,java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
od;
zzz:=DegreeNaturalHomomorphismsPool(
Info(InfoFactor,3," Maxes: ",Length(max)," best degree:",zzz); fi; else
zzz:=DegreeNaturalHomomorphismsPool(G,N); fi; if IsInt(zzz) then
knowiifnot HasIsFinite(G) and IsFinite(G) then fi;
cnt:= return NaturalHomomorphismByNormalSubgroupOp(,)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
cnt0 and> then
badi:=Int(badi*12/10);
I+InfoFactor "index unreasonably large, iterating ",java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 48
cnt:=20;
:0
interrupt:=false;
v: fi;
until interrupt or cnt<=0 or zzz<=goodi;
Info(InfoFactor,1,zzz," vs ",badi);
############################################################################# ## #F SmallerDegreePermutationRepresentation( <G> ) ##
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
local o, s, k, gut, erg, return ;
i,cheap,k2,change;
change:=false;
Info(InfoFactor,1,"Smaller degree forsmByNormalSubgroupNCOrig,IsIdenticalObj,
cheap:=ValueOption("cheap"); if cheap="skip"then
return IdentityMapping(G); fi;
cheap:=cheap=true;
if patchOnConditionNaturalHomomorphismByNormalSubgroupInParenttrue,
s:=SmallGeneratingSet(G); if[IsGroup,IsGroup andIsFinite]0) if Length(s)<Length(GeneratorsOfGroup(G))-1then
Info(InfoFactor,1,"reduced to ",Length(s)[IsGroup],[IsGroupand IsFinite,IsGroup],);
H:=Group(s);
change:=true;
SetSize(H,Size(G));
return SmallerDegreePermutationRepresentation(H); fi; fi;
# deal with large abelian components first (which could be direct)## if cheap<true java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
hom:MaximalAbelianQuotient(G);
i:=IndependentGeneratorsOfAbelianGroup(Image(hom));
o:=List(i,Order);
ValueOption("norecurse")<>true and
Product(o)>20 and Sum(o)*4<NrMovedPoints(G) then
Info,2,"appendabelian rep";
s:=AbelianGroup(IsPermGroup,o)( , N)
ihom:=GroupHomomorphismByImagesNC(Image(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 30
erg:=SubdirectDiagonalPermsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(G),->Image(ihom,Image(om,x)),
GeneratorsOfGroup(G));
k:=Group(erg);SetSize(k,Size(G));
hom: :=DegreeNaturalHomomorphismsPool(,N;
return hom*SmallerDegreePermutationRepresentation A50 or (sInt()and <IndexNC(,N/LogInt(GN),2)^2)then fi; map=GetNaturalHomomorphismsPool(G,N); fi;
# known simple? if HasIsSimpleGroup(G) and IsSimpleGroup(G)
and NrMovedPoints(G)>=SufficientlySmallDegreeSimpleGroupOrder(Size(G)) then return IdentityMapping(G); fi;
if not IsTransitive(G,MovedPoints(G)) then
o;
SortBy(o, Length);
for loop in [1..2] do
s:=[]; # Try subdirect product
k:=G;
gut:[]; for i in [1..Length(o)] do
s=Stabilizer(koi,OnTuples)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39 if Size(s)<Size() then
k:=s;
; fi;
od; # reduce each orbit separately
o:ogut}; # second run: now take the big orbits first
Sort(o,function(a,b)return Length(a)>Length(b);end# routines).
od;
SortBy(o, Length);
erg:=List(GeneratorsOfGroup(G),i->());
k:=G; for i in [1..Length(o)] do
Info(InfoFactor,1,"Try to shorten orbit fi;
s:=ActionHomomorphism(G,o[i],OnPoints,"surjective");
k2:=Image(s,k);
k:=Stabilizer(k,o[i],OnTuples);
H:=Range(s);
# is there an action that is good enough for improving the overall # kernel, even if it is not faithful? If so use the best of them.
=(H,k2); if b<>fail then
Info(InfoFactor,2,"Blocks for kernel reduce to ",Length(b));
b:=ActionHomomorphism(H,b,OnSets,"surjective");
s:=s*b; fi;
s=sSmallerDegreePermutationRepresentation(Image(s));
Info(InfoFactor,1,"Shortened to ",NrMovedPoints(Range(s)));
erg:=SubdirectDiagonalPerms(erg,List(GeneratorsOfGroup(G),i->Image(s,i)));
od; if NrMovedPoints(erg)<NrMovedPoints(G) then
s and
SetSize(s,Size(G));
s:=roupHomomorphismByImagesNC(G,s,GeneratorsOfGroup(G),erg);
SetIsBijective(s, and HasRange and
return; fi;
); fi; # intransitive treatment
nal group no stabchain we probably not want tokeep # it (or a homomorphisms pool) there -- make a copy for working # intermediately with it. if not HasStabChainMutable(G) then
H:= ObjectifyWithAttributes(map,
change:=true; if HasSize(G) then
SetSize(H,Size(G));
(ElementsFamily(FamilyObj(G) ) if HasBaseOfGroup(G) then
)); fi; else
H:=G; fi;
hom:=IdentityMapping(H);
b:=NaturalHomomorphismsPool(H
b.dotriv:=true;
AddNaturalHomomorphismsPool(H,TrivialSubgroup(H),hom,NrMovedPoints(H));
b.dotriv:=false;
# cheap initial block reduction? if IsTransitiveH,MovedPoints()then
improve:=true; while improve and (cheap or NrMovedPoints(H)*5>
:=false;
bl:=Blocks(H,MovedPoints(H));
map:=ActionHomomorphism(G,bl,OnSets,"surjective");
ImagesSource(map:onlyimage); #`onlyimage' forces same generators
bl:=KernelOfMultiplicativeGeneralMapping
############################################################################# if Size(bl)=1then
hom:=hom*map;
H:=Image(map#F PullBackNaturalHomomorphismsPool( <hom> )
change:=true;
Info(InfoFactor,2," quickblocksimproved to degree ",NrMovedPoints(); fi;
od; fi;
b=NaturalHomomorphismsPool();
b.dotriv:=true; if change then
DoCheapActionImages(H:onlykernel:=TrivialSubgroup(H)); else
DoCheapActionImages(H); fi;
CloseNaturalHomomorphismsPool(H,TrivialSubgroup(H));
b.dotriv:=false;
map:=GetNaturalHomomorphismsPool(H,TrivialSubgroup(H)); if map<>fail and Image(map)<>H then
Info(2"cheap actions todegree"(H);
hom:=hom*map;
H:=Image(map) ; fi;
o:=java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0 if java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
s:=GenericFindActionKernel(H,TrivialSubgroup(H## if s<>fail then
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 17 fi; fi;
return hom; end);
############################################################################# ## #F ImproveActionDegreeByBlocks( <G>, <N> , hom ) ## extension of <U> in <G> such that \bigcap U^g=N remains valid ##
InstallGlobalFunction(ImproveActionDegreeByBlocksjava.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 38
ibp,i,subo,,,estblockb,
stosubomax
Info(InfoFactor,1,"try to find block systems");
# remember that we computed the blocks
IsSubsetd,k)
# special case to use it for improving a permutation representation if Size(N)=1then
Info(InfoFactor,1," ma:java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 53
b.ker:=[N];
b.:[]
b.cost:=[Length(MovedPoints(Range(oh)))];
b.lock:=[false];
b.blocksdone=[false];
subomax:=20; else
subomax:=500; fi;
i:=PositionSet(b.ker,N); if b.blocksdone[i] then
return DegreeNaturalHomomorphismsPool(G,N); # we have done it already fi;
blocksdonei:=truejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
if sub:PreImage(sub)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
return 1; fi;
(img,dom)then # one orbit: Blocks
repeat
b:=Blocks(img,dom);
improve:=false;
until (p,)=bound; if Length(dom)<40000then
subo:=java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
subo:=Difference(List(subo,i else
fi;
bc:=irstbi-dom[] )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36 if subo<>ailand Length)=)then
Info(InfoFactor,2,"try all seeds"); # if the degree is not too big or if we are desperate then go for # all blocks # greedy approach: take always locally best one (otherwise there )then # might be too much work to do)
bestdeg:=Length(dom);
bp:=SetSize(fac, ( Size(den) )
i:= else while(num ) if suboif(StabChainOptions(fac.java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 53
bb:=b; else ;
:Blocks(mg,[[],ubo[]]; fi; if Length(bb)>1 and not (fi
Info(InfoFactor,3,"found block system ",Length(bb TryNextMethod(; # new nontriv. system found
AddSet(bp,bb[1]); # store action
op:=1;# remove old homomorphism to free memory if bdom<>fail then
bb:=Set(bb,i->Immutable(Union(bdom{i}))); fi;
op:=ActionHomomorphism(gimg,bb,OnSets,"surjective"); if HasSize(gimg) and not HasStabChainMutable(gimg) then
sto:=StabChainOptions(Range(op));
sto.limit:=Size(gimg); # try only with random (will exclude some chances, but is # quicker. If the size is OK we have a proof anyhow).
sto.random:=100; # if gimgbas<>false then # SetBaseOfGroup(Range(op), # List(gimgbas,i->PositionProperty(bb,j->i in j))); # fi; if Size(Range(op))=Size(gimg) then
sto.random:=1000;
k:=TrivialSubgroup(gimg);
op:=oh*op;
SetKernelOfMultiplicativeGeneralMapping(op,PreImage(oh,k));
AddNaturalHomomorphismsPool(G,
KernelOfMultiplicativeGeneralMapping(op),
op,Length(bb)); else
k:=[]; # do not trigger improvement fi; else
k:=KernelOfMultiplicativeGeneralMapping(op);
SetSize(Range(op),IndexNC(gimg,k));
op:=oh*op;
SetKernelOfMultiplicativeGeneralMapping(op,PreImage(oh,k));
AddNaturalHomomorphismsPool(G,
KernelOfMultiplicativeGeneralMapping(op),
op,Length(bb));
fi; # and note whether we got better #improve:=improve or (Size(k)=1); if Size(k)=1 and Length(bb)<bestdeg then
improve:=true;
bestdeg:=Length(bb);
bestblock:=bb;
bestop:=op; fi; fi; # break the test loop if we found a fairly small block system # (iterate greedily immediately) if improve and bestdeg<i then
i:=Length(dom); fi;
i:=i+1;
od; else
Info(InfoFactor,2,"try only one system");
op:=1;# remove old homomorphism to free memory if bdom<>fail then
b:=Set(b,i->Immutable(Union(bdom{i}))); fi;
op:=ActionHomomorphism(gimg,b,OnSets,"surjective"); if HasSize(gimg) and not HasStabChainMutable(gimg) then
sto:=StabChainOptions(Range(op));
sto.limit:=Size(gimg); # try only with random (will exclude some chances, but is # quicker. If the size is OK we have a proof anyhow).
sto.random:=100; # if gimgbas<>false then # SetBaseOfGroup(Range(op), # List(gimgbas,i->PositionProperty(b,j->i in j))); # fi; if Size(Range(op))=Size(gimg) then
sto.random:=1000;
k:=TrivialSubgroup(gimg);
op:=oh*op;
SetKernelOfMultiplicativeGeneralMapping(op,PreImage(oh,k));
AddNaturalHomomorphismsPool(G,
KernelOfMultiplicativeGeneralMapping(op),
op,Length(b)); else
k:=[]; # do not trigger improvement fi; else
k:=KernelOfMultiplicativeGeneralMapping(op);
SetSize(Range(op),IndexNC(gimg,k)); # keep action knowledge
op:=oh*op;
SetKernelOfMultiplicativeGeneralMapping(op,PreImage(oh,k));
AddNaturalHomomorphismsPool(G,
KernelOfMultiplicativeGeneralMapping(op),
op,Length(b)); fi;
if Size(k)=1then
improve:=true;
bestblock:=b;
bestop:=op; fi; fi; if improve then # update mapping
bdom:=bestblock;
img:=Image(bestop,G);
dom:=MovedPoints(img); fi; fi;
until improve=false; fi;
Info(InfoFactor,1,"end of blocks search");
return DegreeNaturalHomomorphismsPool(G,N); end);
BindGlobal("FactPermRepMaxDesc",function(g,n,maxlev)
local lim,deg,all,c,recurse,use,start; if ValueOption("infactorpermrep")=true then return false;fi;
deg:=DegreeNaturalHomomorphismsPool(g,n); if deg=fail then deg:=infinity;fi; all:=[];
start:=ClosureGroup(DerivedSubgroup(g),n);
lim:=RootInt(IndexNC(g,n),3)*Maximum(1,LogInt(IndexNC(g,start),2));
c:=start;
Info(InfoFactor,1,"Try maximals for limit ",lim," from ",deg);
recurse:=function(a,lev)
local m,ma,nm,i,j,co,wait,use;
Info(InfoFactor,3,"pop in ",lev);
m:=[a]; while Length(m)>0do
wait:=[];
ma:=[]; for i in m do if ForAll(all,y->RepresentativeAction(g,i,y)=fail) then
Add(all,i);
Info(InfoFactor,2,"Maximals of index ",IndexNC(g,i));
nm:=TryMaximalSubgroupClassReps(i:inmax,infactorpermrep,cheap);
nm:=Filtered(nm,x->IndexNC(g,x)<=lim and IsSubset(x,n) and not
IsNormal(g,x)); for j in nm do if IsSubset(j,c) then
use:=ClosureGroup(n,DerivedSubgroup(j)); if not IsSubset(use,c) then
j:=use;
use:=true; else
Add(wait,j);
use:=false; fi; else
use:=true; fi; if use then
co:=Core(g,j);
AddNaturalHomomorphismsPool(g,co,j,IndexNC(g,j));
c:=Intersection(co,c);
Add(ma,j); fi;
od; else
Info(InfoFactor,2,"discard conjugate"); fi;
od; if Length(ma)>0then
CloseNaturalHomomorphismsPool(g,n);
i:=DegreeNaturalHomomorphismsPool(g,n); if i<deg then
deg:=i;
Info(InfoFactor,1,"Itmax improves to degree ",deg); if lev>1 or deg<lim then return true;fi; fi;
m:=ma;
SortBy(m,x->-Size(x)); elif lev<maxlev then # no improvement. Go down
wait:=Filtered(wait,x->IndexNC(g,x)*10<=lim); for i in wait do if recurse(i,lev+1) then return true;fi;
od;
m:=[]; else
m:=[]; fi;
od; if Size(c)>Size(n) then
Info(InfoFactor,3,"pop up failure ",Size(c)); else
Info(InfoFactor,3,"pop up found ",Size(c)); fi;
return false; end;
return recurse(start,1);
end);
############################################################################# ## #M FindActionKernel(<G>) . . . . . . . . . . . . . . . . . . . . permgrp ##
InstallMethod(FindActionKernel,"perm",IsIdenticalObj,
[IsPermGroup,IsPermGroup],0, function(G,N)
local pool, dom, bestdeg, blocksdone, o, s, badnormals, cnt, v, u, oo, m,
badcomb, idx, i, comb,act,k,j;
if IndexNC(G,N)<50then # small index, anything is OK
return GenericFindActionKernel(G,N); else # get the known ones, including blocks &c. which might be of use
DoCheapActionImages(G);
# find smallish layer actions
oo:=ClosureGroup(SolvableRadical(G),N);
dom:=ChiefSeriesThrough(G,[oo,N]);
dom:=Filtered(dom,x->IsSubset(oo,x) and IsSubset(x,N));
i:=2; while i<=Length(dom) do
j:=i; while j<Length(dom) #and HasElementaryAbelianFactorGroup(dom[i-1],dom[j+1])
and IndexNC(dom[i-1],dom[j+1])<=2000do
j:=j+1;
od; if IndexNC(dom[i-1],dom[j])<=2000then
v:=RightTransversal(dom[i-1],dom[j]);
oo:=OrbitsDomain(G,v,function(rep,g)
return v[PositionCanonical(v,rep^g)]; end); for k in oo do if Length(k)>1then
u:=Stabilizer(G,k[1],function(x,g)
return v[PositionCanonical(v,x^g)]; end);
repeat if not IsNormal(G,u) then
AddNaturalHomomorphismsPool(G,Core(G,u),u,IndexNC(G,u)); fi;
m:=u;
u:=ClosureGroup(N,DerivedSubgroup(u));
until m=u; fi;
od; fi;
i:=j+1;
od;
# store regular to have one anyway
bestdeg:=IndexNC(G,N);
AddNaturalHomomorphismsPool(G,N,N,bestdeg);
# check if there are multiple orbits
o:=Orbits(G,MovedPoints(G));
s:=List(o,i->Stabilizer(G,i,OnTuples)); if not ForAny(s,i->IsSubset(N,i)) then
Info(InfoFactor,2,"Try reduction to orbits");
s:=List(s,i->ClosureGroup(i,N)); if Intersection(s)=N then
Info(InfoFactor,1,"Reduction to orbits will do");
List(s,i->NaturalHomomorphismByNormalSubgroup(G,i)); fi; fi;
CloseNaturalHomomorphismsPool(G,N);
# action in orbit image -- sometimes helps if Length(o)>1then for i in o do
act:=ActionHomomorphism(G,i,OnPoints,"surjective");
k:=KernelOfMultiplicativeGeneralMapping(act);
k:=ClosureGroup(k,N); # pre-image of (image of normal subgroup under act)
u:=Image(act,N);
v:=NaturalHomomorphismByNormalSubgroupNC(Image(act),u);
o:=DegreeNaturalHomomorphismsPool(Image(act),u); if IsInt(o) then# otherwise its solvable factor we do differently
AddNaturalHomomorphismsPool(G,k,act*v,o); fi;
od;
CloseNaturalHomomorphismsPool(G,N); fi;
bestdeg:=DegreeNaturalHomomorphismsPool(G,N);
Info(InfoFactor,1,"Orbits and known, best Index ",bestdeg);
blocksdone:=false; # use subgroup that fixes a base of N # get orbits of a suitable stabilizer.
o:=BaseOfGroup(N);
s:=Stabilizer(G,o,OnTuples);
badnormals:=Filtered(pool.ker,i->IsSubset(i,N) and Size(i)>Size(N)); if Size(s)>1 and IndexNC(G,s)/Size(N)<2000 and bestdeg>IndexNC(G,s) then
cnt:=Filtered(OrbitsDomain(s,dom),i->Length(i)>1); for i in cnt do
v:=ClosureGroup(N,Stabilizer(s,i[1])); if Size(v)>Size(N) and IndexNC(G,v)<2000
and not ForAny(badnormals,j->IsSubset(v,j)) then
u:=Core(G,v); if Size(u)>Size(N) and IsSubset(u,N) and not u in badnormals then
Add(badnormals,u); fi;
AddNaturalHomomorphismsPool(G,u,v,IndexNC(G,v)); fi;
od;
# try also intersections
CloseNaturalHomomorphismsPool(G,N);
bestdeg:=DegreeNaturalHomomorphismsPool(G,N);
Info(InfoFactor,1,"Base Stabilizer and known, best Index ",bestdeg);
if bestdeg<500 and bestdeg<IndexNC(G,N) then # should be better...
bestdeg:=ImproveActionDegreeByBlocks(G,N,
GetNaturalHomomorphismsPool(G,N));
blocksdone:=true;
Info(InfoFactor,2,"Blocks improve to ",bestdeg); fi; fi;
# then we should look at the orbits of the normal subgroup to see, # whether anything stabilizing can be of use
o:=Filtered(OrbitsDomain(N,dom),i->Length(Orbit(G,i[1]))>Length(i));
Apply(o,Set);
oo:=OrbitsDomain(G,o,OnSets);
s:=G; for i in oo do
s:=StabilizerOfBlockNC(s,i[1]);
od;
Info(InfoFactor,2,"stabilizer of index ",IndexNC(G,s));
if not ForAny(badnormals,j->IsSubset(s,j)) then
m:=Core(G,s); # the normal subgroup we get this way. if Size(m)>Size(N) and IsSubset(m,N) and not m in badnormals then
Add(badnormals,m); fi;
AddNaturalHomomorphismsPool(G,m,s,IndexNC(G,s)); else
m:=G; # guaranteed fail fi;
if Size(m)=Size(N) and IndexNC(G,s)<bestdeg then
bestdeg:=IndexNC(G,s);
blocksdone:=false;
Info(InfoFactor,2,"Orbits Stabilizer improves to index ",bestdeg); elif Size(m)>Size(N) then # no hard work for trivial cases if2*IndexNC(G,N)>Length(o) then # try to find a subgroup, which does not contain any part of m # For wreath products (the initial aim), the following method works # fairly well
v:=Subgroup(G,Filtered(GeneratorsOfGroup(G),i->not i in m));
v:=SmallGeneratingSet(v);
cnt:=1;
badcomb:=[];
repeat
Info(InfoFactor,3,"Trying",cnt); for comb in Combinations([1..Length(v)],cnt) do #Print(">",comb,"\n"); if not ForAny(badcomb,j->IsSubset(comb,j)) then
u:=SubgroupNC(G,v{comb});
o:=ClosureGroup(N,u);
idx:=Size(G)/Size(o); if idx<10 and Factorial(idx)*Size(N)<Size(G) then # the permimage won't be sufficiently large
AddSet(badcomb,Immutable(comb)); fi; if idx<bestdeg and Size(G)>Size(o)
and not ForAny(badnormals,i->IsSubset(o,i)) then
m:=Core(G,o); if Size(m)>Size(N) and IsSubset(m,N) then
Info(InfoFactor,3,"Core ",comb," failed");
AddSet(badcomb,Immutable(comb)); if not m in badnormals then
Add(badnormals,m); fi; fi; if idx<bestdeg and Size(m)=Size(N) then
Info(InfoFactor,3,"Core ",comb," succeeded");
bestdeg:=idx;
AddNaturalHomomorphismsPool(G,N,o,bestdeg);
blocksdone:=false;
cnt:=0; fi; fi; fi;
od;
cnt:=cnt+1;
until cnt>Length(v); fi; fi;
Info(InfoFactor,2,"Orbits Stabilizer, Best Index ",bestdeg); # first force blocks if (not blocksdone) and bestdeg<200 and bestdeg<IndexNC(G,N) then
Info(InfoFactor,3,"force blocks");
bestdeg:=ImproveActionDegreeByBlocks(G,N,
GetNaturalHomomorphismsPool(G,N));
blocksdone:=true;
Info(InfoFactor,2,"Blocks improve to ",bestdeg); fi;
if bestdeg=IndexNC(G,N) or
(bestdeg>400 and not(bestdeg<=2*NrMovedPoints(G))) then if GenericFindActionKernel(G,N,bestdeg,s)<>fail then
blocksdone:=true; fi;
bestdeg:=DegreeNaturalHomomorphismsPool(G,N);
Info(InfoFactor,1," Random search found ",bestdeg); fi;
if bestdeg>10000 and bestdeg^2>IndexNC(G,N) then
cnt:=bestdeg;
FactPermRepMaxDesc(G,N,5);
bestdeg:=DegreeNaturalHomomorphismsPool(G,N); if bestdeg<cnt then blocksdone:=false;fi;
Info(InfoFactor,1,"Iterated maximals found ",bestdeg); fi;
if not blocksdone then
ImproveActionDegreeByBlocks(G,N,GetNaturalHomomorphismsPool(G,N)); fi;
############################################################################# ## #M NaturalHomomorphismByNormalSubgroup( <G>, <N> ) . . mapping G ->> G/N ## this function returns an epimorphism from G ## with kernel N. The range of this mapping is a suitable (isomorphic) ## permutation group (with which we can compute much easier).
InstallMethod(NaturalHomomorphismByNormalSubgroupOp, "search for operation",IsIdenticalObj,[IsGroup,IsGroup],0, function(G,N)
local proj,h,pool;
# catch the trivial case N=G if CanComputeIndex(G,N) and IndexNC(G,N)=1then
h:=FACTGRP_TRIV; # a new group is created
h:=GroupHomomorphismByImagesNC( G, h, GeneratorsOfGroup( G ),
List( GeneratorsOfGroup( G ), i -> () )); # a new group is created
SetKernelOfMultiplicativeGeneralMapping( h, G );
return h; fi;
# catch trivial case N=1 (IsTrivial might not be set) if (HasSize(N) and Size(N)=1) or (HasGeneratorsOfGroup(N) and
ForAll(GeneratorsOfGroup(N),IsOne)) then
return IdentityMapping(G); fi;
# check, whether we already know a factormap
pool:=NaturalHomomorphismsPool(G);
h:=PositionSet(pool.ker,N); if h<>fail and IsGeneralMapping(pool.ops[h]) then
return GetNaturalHomomorphismsPool(G,N); fi;
DoCheapActionImages(G); if HasSolvableRadical(G) and N=SolvableRadical(G) then
h:=GetNaturalHomomorphismsPool(G,N); fi;
if HasDirectProductInfo(G) and DegreeNaturalHomomorphismsPool(G,N)=fail then for proj in [1..Length(DirectProductInfo(G).groups)] do
proj:=Projection(G,proj);
h:=NaturalHomomorphismByNormalSubgroup(Image(proj,G),Image(proj,N));
AddNaturalHomomorphismsPool(G,
ClosureGroup(KernelOfMultiplicativeGeneralMapping(proj),N),proj*h);
od; fi;
CloseNaturalHomomorphismsPool(G,N);
h:=DegreeNaturalHomomorphismsPool(G,N); if h<>fail and RootInt(h^3,2)<IndexNC(G,N) then
h:=GetNaturalHomomorphismsPool(G,N); else
h:=fail; fi;
if h=fail then # now we try to find a suitable operation
# redispatch upon finiteness test, as following will fail in infinite case if not HasIsFinite(G) and IsFinite(G) then
return NaturalHomomorphismByNormalSubgroupOp(G,N); fi;
h:=FindActionKernel(G,N); if h<>fail then
Info(InfoFactor,1,"Action of degree ",
Length(MovedPoints(Range(h)))," found"); else
Error("I don't know how to find a natural homomorphism for <N> in <G>"); # nothing had been found, Desperately one could try again, but that # would create a possible infinite loop.
h:= NaturalHomomorphismByNormalSubgroup( G, N ); fi; fi; # return the map
return h; end);
RedispatchOnCondition(NaturalHomomorphismByNormalSubgroupNCOrig,IsIdenticalObj,
[IsGroup,IsGroup],[IsGroup and IsFinite,IsGroup],0);
RedispatchOnCondition(NaturalHomomorphismByNormalSubgroupInParent,true,
[IsGroup],[IsGroup and IsFinite],0);
RedispatchOnCondition(FactorGroupNC,IsIdenticalObj,
[IsGroup,IsGroup],[IsGroup and IsFinite,IsGroup],0);
############################################################################# ## #M NaturalHomomorphismByNormalSubgroup( <G>, <N> ) . . for solvable factors ##
NH_TRYPCGS_LIMIT:=30000;
InstallMethod( NaturalHomomorphismByNormalSubgroupOp, "test if known/try solvable factor for permutation groups",
IsIdenticalObj, [ IsPermGroup, IsPermGroup ], 0, function( G, N )
local map, pcgs, A, filter;
if KnownNaturalHomomorphismsPool(G,N) then
A:=DegreeNaturalHomomorphismsPool(G,N); if A<50 or (IsInt(A) and A<IndexNC(G,N)/LogInt(IndexNC(G,N),2)^2) then
map:=GetNaturalHomomorphismsPool(G,N); if map<>fail then
Info(InfoFactor,2,"use stored map");
return map; fi; fi; fi;
if IndexNC(G,N)=1 or Size(N)=1
or Minimum(IndexNC(G,N),NrMovedPoints(G))>NH_TRYPCGS_LIMIT then
TryNextMethod(); fi;
# Make a pcgs based on an elementary abelian series (good for ag # routines).
pcgs := TryPcgsPermGroup( [ G, N ], false, false, true ); if not IsModuloPcgs( pcgs ) then
TryNextMethod(); fi;
# Construct or look up the pcp group <A>.
A:=CreateIsomorphicPcGroup(pcgs,false,false);
UseFactorRelation( G, N, A );
# Construct the epimorphism from <G> onto <A>.
map := rec();
filter := IsPermGroupGeneralMappingByImages and
IsToPcGroupGeneralMappingByImages and
IsGroupGeneralMappingByPcgs and
IsMapping and IsSurjective and
HasSource and HasRange and
HasPreImagesRange and HasImagesSource and
HasKernelOfMultiplicativeGeneralMapping;
map.sourcePcgs := pcgs;
map.sourcePcgsImages := GeneratorsOfGroup( A );
############################################################################# ## #F PullBackNaturalHomomorphismsPool( <hom> ) ##
InstallGlobalFunction(PullBackNaturalHomomorphismsPool,function(hom)
local s,r,nat,k;
s:=Source(hom);
r:=Range(hom); for k in NaturalHomomorphismsPool(r).ker do
nat:=hom*NaturalHomomorphismByNormalSubgroup(r,k);
AddNaturalHomomorphismsPool(s,PreImage(hom,k),nat);
od; end);
############################################################################# ## #F TryQuotientsFromFactorSubgroups(<hom>,<ker>,<bound>) ##
InstallGlobalFunction(TryQuotientsFromFactorSubgroups,function(hom,ker,bound)
local s,p,k,it,u,v,d,ma,mak,lev,sub,low;
s:=Source(hom);
p:=Image(hom);
k:=KernelOfMultiplicativeGeneralMapping(hom);
it:=DescSubgroupIterator(p:skip:=4);
repeat
u:=NextIterator(it);
Info(InfoExtReps,2,"Factor subgroup index ",Index(p,u));
v:=PreImage(hom,u);
d:=DerivedSubgroup(v); if not IsSubset(d,k) then
d:=ClosureGroup(ker,d); if not IsSubset(d,k) then
ma:=NaturalHomomorphismByNormalSubgroup(v,d);
mak:=Image(ma,k);
lev:=0;
sub:=fail; while sub=fail do
lev:=lev+1;
low:=ShallowCopy(LowLayerSubgroups(Range(ma),lev));
SortBy(low,x->-Size(x));
sub:=First(low,x->not IsSubset(x,mak));
od;
sub:=PreImage(ma,sub);
Info(InfoExtReps,2,"Found factor permrep ",IndexNC(s,sub));
d:=Core(s,sub);
AddNaturalHomomorphismsPool(s,d,sub);
k:=Intersection(k,d); if Size(k)=Size(ker) then return;fi; fi; fi;
until IndexNC(p,u)>=bound; end);
############################################################################# ## #M UseFactorRelation( <num>, <den>, <fac> ) . . . . for perm group factors ##
InstallMethod( UseFactorRelation,
[ IsGroup and HasSize, IsObject, IsPermGroup ], function( num, den, fac )
local limit; if not HasSize( fac ) then if HasSize(den) then
SetSize( fac, Size( num ) / Size( den ) ); else
limit := Size( num ); if IsBound( StabChainOptions(fac).limit ) then
limit := Minimum( limit, StabChainOptions(fac).limit ); fi;
StabChainOptions(fac).limit:=limit; fi; fi;
TryNextMethod(); end );
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
