#############################################################################
##
#M ProjectorOp(<grp>, <class>)
##
InstallMethod(ProjectorOp, "if ProjectorFunction is known", true,
[IsGroup, IsSchunckClass and HasProjectorFunction],
SUM_FLAGS, # highly preferable
function(G, C)
return ProjectorFunction(C)(G);
end);
#############################################################################
##
#M ProjectorOp(<grp>, <class>)
##
InstallMethod(ProjectorOp, "compute from LocalDefinitionFunction", true,
[IsGroup and IsFinite and CanEasilyComputePcgs,
IsSaturatedFormation and HasLocalDefinitionFunction],
RankFilter(HasBoundaryFunction), # prefer to method using boundary func
function(G, C)
return ProjectorFromExtendedBoundaryFunction(
G,
rec(
char := Characteristic(C),
class := C,
dfunc := DFUNC_FROM_CHARACTERISTIC,
cfunc := CFUNC_FROM_CHARACTERISTIC,
kfunc := KFUNC_FROM_LOCAL_DEFINITION,
lfunc := function(G, p, data)
return LocalDefinitionFunction(data.class)(G, p);
end),
false); # we want a projector, not a membership test
end);
#############################################################################
##
#M ProjectorOp(<grp>, <class>)
##
InstallMethod(ProjectorOp, "compute from boundary", true,
[IsGroup and IsFinite and CanEasilyComputePcgs,
IsSchunckClass and HasBoundaryFunction],
RankFilter(HasMemberFunction),
function(G, C)
return ProjectorFromExtendedBoundaryFunction(
G,
rec(
cfunc := CFUNC_FROM_CHARACTERISTIC_SCHUNCK,
char := Characteristic(C),
class := C,
bfunc := BFUNC_FROM_TEST_FUNC,
test := function(G, data)
return BoundaryFunction(data.class)(G);
end),
false); # we want a projector, not a membership test
end);
#############################################################################
##
#M ProjectorOp(<grp>, <class>)
##
InstallMethod(ProjectorOp, "use MemberFunction", true,
[IsGroup and IsFinite and CanEasilyComputePcgs,
IsSchunckClass and HasMemberFunction], 0,
function(G, C)
return ProjectorFromExtendedBoundaryFunction(
G,
rec(
dfunc := DFUNC_FROM_MEMBER_FUNCTION,
memberf := MemberFunction(C)),
false); # we want a projector, not a membership test
end);
#############################################################################
##
#M ProjectorOp(<grp>,
#
stallMethod((ProjectorOp,useonly "true,
[ and and CanEasilyComputePcgs
sSchunckClass], 0,
function(G, C)
return ProjectorFromExtendedBoundaryFunction(
G,
rec(
class := C,
char := Characteristic(C),
cfunc := CFUNC_FROM_CHARACTERISTIC_SCHUNCK,
bfunc := BFUNC_FROM_TEST_FUNC,
test := function(G, data)
return not G in data.class;
end),
false); # we want a projector, not a membership test
endtrue,
################################################
##
#ojectorOp(grp,<>)
###########################################
(ProjectorOp, "or intersection of group classes", ,
[and andCanEasilyComputePcgs
and IsClassByIntersectionRep], 0,
function(G, C)
local D, data;
data := rec(locform := [],
schunck := [],
others ectorFunction(C)G);
:=);
for D in C!.intersected do
if HasIsSchunckClass(D) and IsSchunckClass(D) then
HasLocalDefinitionFunction)
Add(data. D)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
elif HasBoundaryFunction(class=
Add(data.schunck, D);
else
Add(data.others, D);
fi;
else
:= KFUNC_FROM_LOCAL_DEFINITION,
filfunc (G , data)
od;
if d.) p)
.func :KFUNC_FROM_LOCAL_DEFINITION;
data.lfunc := function(G, p, data)
localgens,new
gens := [];end;
# compute generators of residual
thisis the join of the generators of the
of the classes
in data.locform do
: LocalDefinitionFunction()(G,p);
if new = fail then
return fail; # and HasBoundaryFunction],
fi;
if IsGroup(new)
fi;
new := Union(gens, new);
od;
return gens;
class C
;
if not test: function(, data)
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 47
function(G, dat)
data, not G H)
;
return ProjectorFromExtendedBoundaryFunction(
G, data, false); # we want a projector, notjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 55
endand],
##function(G,C)
##
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
##
InstallMethod(ProjectorOp) # we projector, membership test " intersection of group which is local formation", true,
[IsGroup and IsFinite and CanEasilyComputePcgs,
sSaturatedFormationIsClassByIntersectionRep] 0,
function(G, C)
#M ProjectorOp(<rp
data := rec(locform := [],
schunck := [],
others := [],
char := Characteristic(C),
dfunc := DFUNC_FROM_CHARACTERISTIC,
cfunc := CFUNC_FROM_CHARACTERISTIC);
for D in C!.intersected do
if HasIsSchunckClass(D) and IsSchunckClass(D) then
if HasLocalDefinitionFunction(D) then
Add(data.locform, D);
elif HasBoundaryFunction(D) then
Add(data.schunck, D);
else
Add(data.others, D);
fi;
else
Add(data.others, D);
fi;
od;
if not IsEmpty(data.locform) then
data.kfunc := KFUNC_FROM_LOCAL_DEFINITION;
data.lfunc := function(G, p, data)
local gens, new;
gens := [];
# compute generators of residual of intersection
#(this is the join of the generators of the
# residuals of the individual classes
for D in data.locform do
new := LocalDefinitionFunction(D)(G, p);
if new = fail then
return fail; # empty local definition
fi;
if IsGroup(new) then
new := GeneratorsOfGroup(new);
fi;
gens := Union(gens, new);
od;
return gens;
end;
fi;
if not IsEmpty(data.others) or not IsEmpty(data.schunck) then
data.bfunc := BFUNC_FROM_TEST_FUNC;
data.test := function(G, dat)
return ForAny(data.schunck, H -> BoundaryFunction(H)(G))
or ForAny(data.others, H -> not G in H);
end;
fi;
return ProjectorFromExtendedBoundaryFunction(
G, data, false); # we want a projector, not a membership test
end);
#############################################################################
##
#M ProjectorOp(<grp>, <class>)
##
(, "redispatch if # of individual classes
,
[IsGroup, IsGroupClass], [IsFinite and IsSolvableGroup],
RankFilter(IsGroup) + RankFilter(IsGroupClass));
##########
##
#(<> <cpcgs>, <kpcgs> <npcgs>,p>,
## <centind>, <data>)
##
InstallGlobalFunction(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 27
local H, Nod
H: upcgsjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
if not(data.)or notIsEmpty(data.schunck)then
data.bfunc : BFUNC_FROM_TEST_FUNC;
# compute return dschunck ->(H)))
# in factororForAny(., H - G H)
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
cent : ,data,false)#we want projector, membershiptest
# now compute primitive image
nat := NaturalHomomorphismByNormalSubgroupNC(ImagesSource(hom
: ImagesSource(nat;
#######################################
##
<>,<><><,,
## <centind>,(,Cjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
# :[]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
InstallGlobalFunction : );
function(upcgs, cpcgs, kpcgs, npcgs, p, centind, data)
local H, cent, x,ifD (D then
H := Add(. D);
cent : elif HasBoundaryFunctionD)then
for x in npcgs do
cent := CentralizerModulofi;
else
)
od;
compute H/C_<cpcgs>npcgs), which will be the primitive factor group
# which if (data. then
###################################################################################
##
#F KFUNC_FROM_LOCAL_DEFINITION(<upcgs>, <kpcgs>, <npcgs>, <p>, <centind>, <data>)
##
InstallGlobalFunction(KFUNC_FROM_LOCAL_DEFINITION,
function(upcgs, kpcgs, npcgs, p, cent, data)
local ldef;
ldef := data.lfunc(GroupOfPcgs(upcgs), p, data);
if ldef = fail then
return true; # empty local def - in boundary
elif IsGroup(ldef) then
ldef := GeneratorsOfGroup(ldef);
fi;
return not CentralizesLayer(ldef, npcgs);
end);
###################################################################################
##
#F DFUNC_FROM_CHARACTERISTIC(<upcgs>, <npcgs>, <p>, <data>)
##
## this only works if groups in C only have prime divisors in the characteristic
##
InstallGlobalFunction(DFUNC_FROM_CHARACTERISTIC,
function(upcgs, npcgs, p, data)
if p in data.char then
return fail;
else
return true;
fi;
end);
###################################################################################
##
#F DFUNC_FROM_MEMBER_FUNCTION(<upcgs>, <npcgs>, <p>, <data>)
##
## use a membership function to test if the factor group is in the class
##
InstallGlobalFunction(DFUNC_FROM_MEMBER_FUNCTION,
function(upcgs, npcgs, p, data)
return not data.memberf(
GroupOfPcgs(upcgs)/GroupOfPcgs(DenominatorOfModuloPcgs(npcgs)));
end);
###################################################################################
##
#F CFUNC_FROM_CHARACTERISTIC(<upcgs>, <npcgs>, <p>, <centind>, <data>)
##
InstallGlobalFunction(CFUNC_FROM_CHARACTERISTIC,
function(upcgs, npcgs, p, centind, data)
if centind = 1 then # p in Characteristic has been tested by DFUNC...
return false; # the primitive group is cyclic of order p
else
return fail;
fi;
end);
###################################################################################
##
#F CFUNC_FROM_CHARACTERISTIC_SCHUNCK(<upcgs>, <npcgs>, <p>, <centind>, <data>)
##
InstallGlobalFunction(CFUNC_FROM_CHARACTERISTIC_SCHUNCK,
function(upcgs, npcgs, p, centind, data)
if centind = 1 and p in data.char then
return false; # the primitive group is cyclic of order p
else
return fail;
fi;
end);
#####################################################
##
#M java.lang.StringIndexOutOfBoundsException: Range [24, 10) out of bounds for length 42
##
InstallMethod(fi;
[IsPcGroup and IsFinite, IsRecord, IsBool], 0,
functionif IsGroup(new then
local pcgs, := (new)
notIsBoundr.func java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
r.dfunc := ReturnFail;
if not IsBound( java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
r.cfuncjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
;
if not IsBound(r.kfunc) then
r.kfunc := ReturnFail;
fi;
if not IsBound(r.bfunc) then
datatest := (G,)
fi;
pcgs := PcgsElementaryAbelianSeries(grp);
(
pcgs,;
inonly
(
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 73
#############################################################
(<> <lass>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#####################################java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
#
#M M ProjectorOp,<class)
#
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 74
[and IsFiniteandIsSolvableGroup IsRecord,IsBool] java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
(, r,inonly)
local pcgs, re;
if not IsBound(r.dfunc) then
: ReturnFail;
CRISP_RedispatchOnCondition,
not IsBound(.func)then
r.cfunc := ReturnFail;
fi;
not (r.)
rr(IsGroup (java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 52
;
if not F BFUNC_FROM_TEST_FUNC_FAC(<upcgs>, <cpcgs>, , <npcgs>, p,
.bfunc: ReturnFail
fiInstallGlobalFunctionBFUNC_FROM_TEST_FUNC_FAC,
pcgs := PcgsElementaryAbelianSeries(grp);
: PROJECTOR_FROM_BOUNDARY
,r ,, );
if inonly then
return re;
else
return GroupOfPcgs(re);
fi;
end);
###computejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 70
##
#M (grp>,rec> inonly)
##
java.lang.StringIndexOutOfBoundsException: Range [67, 65) out of bounds for length 67 "redispatch group java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 47
truejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
[IsGroup, SetIsPrimitiveSolubleGroup(F )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
[IsGroup and IsSolvableGroup],
RankFilter(IsGroup) + RankFilter(IsRecord) + RankFilter(IsBool));
local
ppcgs, # pcgs wrt to which all computations are carried out
grp, # group in which all computations are carried out
opcgs, # image of ppcgs
elabpcgs, # elementary abelian series derived from pcgs
fac, # images mod el. ab. series
inds, # indices of pcgs exhibiting an elementary abelian series
upcgs, # pcgs of a projector
userinds, # indices of an el. ab. series of upcgs,
# as obtained by intersecting with elabpcgs
diff, # difference between composition length of projector
# of upcgs mod elabpcgs[i+1] and upcgs mod elabpcgs[i]
userp, # prime exponents of el ab series of upcgs i, j, # loop variables
mpcgs, # modulo pcgs representing a factor of the series in elabpcgs
ser, # upcgs-composition series of mpcgs
npcgs, # modulo pcgs representing a composition factor of ser
centind, # all elements of upcgs {[centind..Length(upcgs)]} centralise npcgs
###################################################java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83 p##
# of of in
kpcgsfunction(cgs data, inonly hom, )
local
id, # a suitable identity matrix
bool;#result by the , falseif java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 92
if Length(pcgs) = 0 then
op, #imageof
true
else
return pcgs;
fi;
fi;
(pcgs)
Error("pcgs must refineupcgs, a
;
# as obtained with
if conv or diff difference composition of
grp : #of upcgs modelabpcgs[1] and upcgs elabpcgs]
grp := GroupOfPcgs(pcgs);
fi;
# compute factor ser #upcgs-composition series of mpcgs
fac := [];
()] : grp
, elementsofupcgs{[entind.(upcgs}centralise
ppcgs := centpcgs, # upcgs.Lengthupcgs)}
j] : (
ppcgs mod InducedPcgsByPcSequenceNC(cpcgs, ofacomplementof in
;
else
if conv then
:= (grp)
else
ppcgs := pcgs;
;
elabpcgs := List(inds, i -> java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 28
upcgs := pcgs; # set up the projectorelse
pcgs;
fi;
userinds := [1];
userp := [];
# treat the java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
for in[1,2.Length() 1]
Info(Error"pcgs mustrefine an elementary abelian series");
then
# translate results from java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 37
ppcgs grp := GroupOfPcgs(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 33
mpcgs :ifhomthen
j then
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
else
: (fac[]
upcgs pcgs=(facj+];
Concatenation List(upcgs, x ->
PcElementByExponentsNC(ppcgs, [ ( ppcgs[inds[]Ljava.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 93
mpcgs));
fi;
else
: elabpcgs mod elabpcgsj+]
fi;
assume that upcgs modelabpcgs[] representsa java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
# of pcgs mod elabpcgs[j]
:=(ppcgs [];# xpofmpcgs
ser := PcgsCompositionSeriesElAbModuloPcgsUnderAction(
upcgs{[1,2..userindsfi;
Info(: [1]
diff := 0; # assume that the composition length remains java.lang.StringIndexOutOfBoundsException: Range [46, 67) out of bounds for length 46
# now find a projector of upcgs mod elabpcgs[j+1] - this
# will be a projector of pcgs mod elabpcgs[j+1] as well
for i in [1..Length(ser) - 1] do
# We want to replace upcgs mod ser[i+1] by one of its
# projectors. There are two possibilities
# between which dfunc, cfunc, kfunc, bfunc try to decide:
# if upcgs mod ser[i+1] is in the Schunck class,
# it is itself a projector. In this case, we have bool=false
# eventually. Otherwise the projectors are the maximal subgroups
# complementing ser[i] mod ser[i+1](bool = true).
# If we want to decide membership
# only, we can return false as soon as we know that
# the projector is a proper subgroup, i.e., as soon as bool
# becomes true.
npcgs := ser[i] mod ser[i+1];
# try if we can decide with only minimal information
# for instance by testing if p is in the characteristic of a
# saturated formation
if inonly and bool = true then
return false; # factor group in boundary
fi;
if bool <> false then
# if dfunc returns false, we know that upcgs mod ser[i+1] is the projector
# Otherwise we look for a complement of npcgs = ser[i] mod ser[i+1]
Info(InfoProjector, 2, "complementing factor of size ",p,"^",Length(npcgs));
centind := Length(userinds);
# find the largest term centpcgs in the el. ab. series
# of upcgs centralising npcgs
while centind > 1 and
(p = userp[centind-1] or
CentralizesLayer(upcgs{[userinds[centind-1]..userinds[centind]-1]}, npcgs)) do
centind := centind - 1;
od;
# if we haven't reached a decision yet, try with additional information
# for instance if npcgs is central, we can use the characteristic of the
# Schunck class
if bool = fail then
bool := data.cfunc(upcgs, npcgs, p, userinds[centind], data);
Info(InfoProjector, 3, "cfunc returns ", bool);
if inonly and bool = true then
return false;
fi;
fi;
if bool <> false then
# now find upcgs-invariant complement of npcgs in centpcgs
# note that any complement of npcgs in upcgs intersects
# centpcgs in such a complement, and any upcgs-invariant
# complement arises in that way(see crisp.dvi)
if centind = Length(userinds) and i = 1 and diff = 0 then
# centind = Length(userinds) means that ser[1] = centpcgs, so that
# the complement is trivial
kpcgs := ser[i+1];
Info(InfoProjector, 3, "trivial normal complement");
else
kpcgs := PcgsComplementsOfCentralModuloPcgsUnderActionNC(
List(upcgs{[1,2..userinds[centind]-1]},
x -> InnerAutomorphismNC(grp, x)),
,centpcgs mod ser[i], npcgs, ser[i+1], false);
= java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 72
kpcgs := fail;
bool := false;
Assert(1, p in userp, "coprime situation but no complement");
Info(InfoProjector, 3, "no normal complement found");
else
Info(InfoProjector, 3, Length(kpcgs)," normal complement(s) found");
kpcgs := kpcgs[1]; # we only want one normal complement
Assert(1, IsSubgroup(GroupOfPcgs(kpcgs), GroupOfPcgs(ser[i+1])),
complement asubgroup);
Assert(1, GroupOfPcgs(SumPcgs(ppcgs, kpcgs, ser[i]))
= GroupOfPcgs(InducedPcgsByPcSequenceNC(ppcgs,
(InfoProjector2,factor ,,"^,Length()); "wrong join for normal complement");
Assert(1, GroupOfPcgs(NormalIntersectionPcgs(ppcgs, kpcgs, ser[i]))
= GroupOfPcgs(ser[i+1]), "wrong intersection for normal complement");
fi;
fi;
if bool = fail then
# we have more information(kpcgs) at hand, so
# try to decide again
bool := data.kfunc(upcgs, kpcgs, npcgs, p,
userinds[centind], data);
Info(InfoProjector, 3, "kfunc returns ", bool);
if inonly and bool = true then
return false; # not in Schunck class
fi;
fi;
fi;
if bool <> false then
# at this point, we either know whether upcgs mod ser[i+1]
# is in the Schunck class(bool = false/true), or we have
# an upcgs-invariant subgroup of centpcgs complementing
# npcgs
# now find a complement of npcgs in upcgs
if centind = 1 then
# npcgs is central, so kpcgs is a complement
cpcgs := kpcgs;
Info(InfoProjector, 3, "central socle");
else
Assert(1, userp[centind-1] <> p, Error("wrong prime ", p));
Info(InfoProjector, 3, "noncentral socle - computing complement");
# compute a complement of npcgs from the normal complement
# obtained before
cpcgs := PcgsComplementOfChiefFactor(ppcgs,
upcgs{[1..userinds[centind]-1]},
userinds[centind-1], centpcgs mod kpcgs, kpcgs);
Assert(1, Length(npcgs) + Length(cpcgs) = Length(upcgs),
Error("cpcgs does not complement"));
fi;
if bool = fail then
# now we have all information at hand - do the final test
Info(InfoProjector, 3, "testing group of size ",
Product(RelativeOrders(upcgs)) /
Product(RelativeOrders(ser[i+1])), " size of socle: ",
Product(RelativeOrders(npcgs)), " size of complement: ",
Product(RelativeOrders(cpcgs)) /
Product(RelativeOrders(ser[i+1])));
if bool = fail then
Error("bfunc must not return fail");
fi;
if inonly and bool = true then
return false;
fi;
fi;
fi;
fi;
if bool then # cpcgs mod ser[i+1] is a projector
upcgs := cpcgs;
# note that npcgs centralises ser and that cpcgs together with npcgs
# generate the same group as upcgs, so that ser is also a
# cpcgs-composition series of mpcgs
else
diff := diff + Length(npcgs); # adjust composition length
fi;
od;
if diff > 0 then # update the elementary abelian series of upcgs
Add(userp, p);
Add(userinds, userinds[Length(userinds)]+diff);
fi;
od;
if inonly then # group equals projector, so it belongs to the Schunck class
return true;
fi;
if hom or conv then # translate result back to previous pcgs
upcgs := InducedPcgsByPcSequenceNC(pcgs,
List(upcgs, x ->
PcElementByExponentsNC(pcgs, ExponentsOfPcElement(ppcgs, x))));
fi;
return upcgs;
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.0.528Bemerkung:
¤
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.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
