Quelle covering.gi
Sprache: unbekannt
|
|
Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
#############################################################################
##
#W covering.gi FORMAT Bettina Eick
#W conversion from GAP3 by C.R.B. Wright
##
## Both methods exploit the fact that an F-covering subgroup of a pi-Hall
## subgroup of G is an (F meet pi-groups)-covering subgroup of G.
#############################################################################
#M CoveringSubgroup1Op( G, form ) . . . . . .<form>-covering subgroup of <G>
##
InstallMethod( CoveringSubgroup1Op, "for locally induced formation", true,
[IsGroup and IsFinite, IsFormation and HasScreenOfFormation], 0,
function( G, form )
local iso, # onto special pc group
g, # its image
spg, # pcgs of g
newform, # formation without support
U, # approximate cover, eventually the answer
system, # system for normalizer mod less and less
head, tail, # of nilpotent factor
hhead, # next nilpotent factor
locals, # local residuals
localspcgs, # pcgses for these
ffirst, # correction factor
first, next, # of layer
p, # prime
primes, # list of primes
reflayer, # refined layer
index, # to cut out eccentric elements
j, k, # positions
i; # loop variable
# catch trivial case
if Length( Pcgs( G ) ) = 0 then return G; fi;
iso := IsomorphismSpecialPcGroup( G );
g := Image( iso );
spg := SpecialPcgs( g );
if HasSupportOfFormation( form ) then
newform := rec( );
newform.name := "temporary";
if HasScreenOfFormation(form) then
newform.fScreen := ScreenOfFormation(form);
fi;
if HasResidualFunctionOfFormation(form) then
newform.fResidual := ResidualFunctionOfFormation(form);
fi;
if HasIsIntegrated(form) and IsIntegrated(form) then
newform.isIntegrated := true;
fi;
newform := Formation( newform );
U := CoveringSubgroup1Op( HallSubgroup( g, SupportOfFormation( form ) ),
newform );
return PreImage( iso, U );
fi;
form := Integrated(form); # can be tricked by setting IsIntegrated
# set up system record
head := LGHeads( spg )[2];
index := [1..head-1];
system := rec();
system.H := g;
## to pass spg on to ChangeGenerator
system.sph := spg;
system.base := spg{ index };
system.weights := LGWeights( spg ){ index };
system.Fcentral := List( index, x -> true );
system.Ffirst := Filtered( LGFirst( spg ){[ 1..Position(
LGFirst( spg ), head) ]}, x -> x in index );
# Add(system.Ffirst, LGHeads(spg)[2] - LGFirst(spg)[2] + Length(index));
# set up the cover
U := SubgroupNC( g, Concatenation( system.base,
spg{[ head..Length(spg) ]} ) );
Info( InfoForm, 2, "1 head done \n");
# run down lower nilpotent series (the first factor is trivial)
for i in [ 2..Length(LGHeads( spg ))-1 ] do
head := LGHeads( spg )[ i ];
tail := LGTails( spg )[ i ];
hhead := LGHeads( spg )[ i+1 ];
# get local residuals
primes := Set( List( LGWeights( spg ){[head..tail-1]}, x -> x[3] ) );
locals := List( primes, x -> ScreenOfFormation( form )( U, x ) );
## Here's where we cut down to U. Locals is just a list of normal
## subgroups of U. Nothing special.
localspcgs := [ ];
for i in [1..Length( locals )] do
if locals[i] = [ ] then
localspcgs[i] := [ ];
else
localspcgs[i] := NormalizedPcgs( spg, InducedPcgs( spg, locals[i] ) );
fi;
od;
# compute correction factor
ffirst := head - Length( system.base ) - 1;
# refine nilpotent layer
j := Position( LGFirst( spg ), head );
while LGFirst( spg )[j] < hhead do
first := LGFirst( spg )[j];
next := LGFirst( spg )[j+1];
p := LGWeights( spg )[ first ][3];
if not HasSupportOfFormation( form ) or (HasSupportOfFormation(
form ) and p in SupportOfFormation( form )) then
k := Position( primes, p );
reflayer := RefinedBaseLayer( g, locals[k], localspcgs[k], j );
Append( system.base, reflayer.base );
Append( system.Fcentral, reflayer.central );
Append( system.Ffirst,
List( reflayer.firsts, x -> x - ffirst ) );
else
Append( system.base, spg{[ first..next-1 ]} );
Append( system.Fcentral, List( [first..next-1], x -> false ));
Append( system.Ffirst, [next - ffirst] );
fi;
Append( system.weights, LGWeights( spg ){[ first..next-1 ]} );
j := j + 1;
od;
system.depths := List( system.base, x -> DepthOfPcElement( spg, x ) );
# compute layers relative to first for full base
system.Flayers := List( system.base, x -> false );
j := 1;
for k in [1..Length( system.base )] do
if system.Ffirst[j] = k then
j := j + 1;
fi;
system.Flayers[k] := j-1;
od;
# calculate p-complements of residuals
for j in [1..Length(primes)] do
if not HasSupportOfFormation( form ) or (HasSupportOfFormation(
form ) and primes[j] in SupportOfFormation( form )) then
if Length( InducedPcgs( spg, locals[j] ) ) > 0 then
locals[j] := NormalIntersection(locals[j],
SylowComplement(g,primes[j]));
fi;
localspcgs[j] := NormalizedPcgs( spg, InducedPcgs( spg, locals[j] ) );
fi;
od;
j := Length( system.base );
while j >= 1 and system.Fcentral[ j ] do
j := j - 1;
od;
while j >= 1 do
if system.Fcentral[ j ] then
p := system.weights[ j ][ 3 ];
k := Position( primes, p );
if not IsBool( k ) then
ChangeGenerator( system, localspcgs[ k ], j );
## If this gives an error message, it's a problem
## with alignment of pcgs's for setting up the
## system of equations.
fi;
fi;
j := j - 1;
od;
# set up for next head
index := Filtered( [1..Length(system.Fcentral)],
x -> system.Fcentral[x] );
system.base := system.base{ index };
system.weights := system.weights{ index };
system.Fcentral := List( index, x -> true );
system.Ffirst := [ ];
k := 1;
for j in [1..Length(system.base)] do
if DepthOfPcElement( spg, system.base[j] ) >=
LGFirst( spg )[k] then
k := k + 1;
Add( system.Ffirst, j );
fi;
od;
Add( system.Ffirst, Length( system.base ) + 1 );
U := SubgroupNC( g, Concatenation( system.base,
spg{[ hhead..Length(spg) ]} ) );
Info( InfoForm, 2, i," head done \n");
od;
return PreImage( iso, U );
end);
#############################################################################
#M CoveringSubgroup1Op( G, form ) . . . . . .<form>-covering subgroup of <G>
##
SubgpMethodByNiceMonomorphismCollOther(CoveringSubgroup1Op, [IsGroup,
IsFormation]);
#############################################################################
## Second strategy ##
#############################################################################
#############################################################################
#M CoveringSubgroup2Op( G, formation ) . . . . . . . . . . . . 2nd strategy
##
InstallMethod( CoveringSubgroup2Op,
"second strategy for locally induced formation", true,
[IsGroup and IsFinite, IsFormation and HasScreenOfFormation], 0,
function( G, form )
local iso, # onto special pc group
g, # its image
spg, # pcgs of g
newform, # formation without support
U, # the covering group
max, # composition length of g
head, # the first nilpotent factor of g
system, # system of cover
first, next, # of a layer
wt, p, # corresponding weight and prime
pcgsN, pcgsM, # corresponding normal subgroup pcgses
loc, # local residual
comp, ncomp, # p-complement and O^p of loc
residual, # pcgs of residual modulo M
gens, # some new system elements
layer, # number of layer
Ffirst, # first of layer
q, # prime of element
index, # to cut out eccentric elements
i, j, k; # indices
# catch trivial case
if Length( Pcgs( G ) ) = 0 then return G; fi;
iso := IsomorphismSpecialPcGroup( G );
g := Image( iso );
spg := SpecialPcgs( g );
max := Length( spg );
if HasSupportOfFormation( form ) then
newform := rec( );
newform.name := "temporary";
if HasScreenOfFormation(form) then
newform.fScreen := ScreenOfFormation(form);
fi;
if HasResidualFunctionOfFormation(form) then
newform.fResidual := ResidualFunctionOfFormation(form);
fi;
if HasIsIntegrated(form) and IsIntegrated(form) then
newform.isIntegrated := true;
fi;
newform := Formation( newform );
U := CoveringSubgroup1Op( HallSubgroup( g, SupportOfFormation( form ) ),
newform );
return PreImage( iso, U );
fi;
form := Integrated(form); # can be tricked by setting IsIntegrated
# set up system record
head := LGHeads( spg )[2];
index := [1..head-1];
system := rec();
system.H := g;
## to pass spg on to ChangeGenerator
system.sph := spg;
system.base := spg{ index };
system.weights := LGWeights( spg ){ index };
system.Fcentral := List( index, x -> true );
system.Ffirst := LGFirst( spg ){[ 1..Position(
LGFirst( spg ), head) ]};
# compute layers allowing for support
system.Flayers := List( system.base, x -> false );
j := 1;
for k in [1..Length( system.base )] do
if system.Ffirst[j] = k then
j := j + 1;
fi;
system.Flayers[k] := j-1;
od;
# set up the cover
U := SubgroupNC( g, Concatenation( system.base,
spg{[ head..Length(spg) ]} ) );
Info( InfoForm, 2, "1 head done \n");
# run down elementary abelian series (the first factor is trivial)
for i in [Position(LGFirst( spg ), head)..Length(LGFirst( spg ))-1] do
first := LGFirst( spg )[ i ];
next := LGFirst( spg )[ i+1 ];
wt := LGWeights( spg )[ first ];
p := wt[ 3 ];
if not HasSupportOfFormation( form ) or (HasSupportOfFormation(
form ) and p in SupportOfFormation( form )) then
pcgsN := InducedPcgsByPcSequenceNC( spg, spg{[first..max]} );
pcgsM := InducedPcgsByPcSequenceNC( spg, spg{[next..max]} );
# get local residual
loc := ScreenOfFormation( form )( U, p );
## Here's where U comes in.
# compute p-complement and O^p
comp := InducedPcgsByPcSequenceNC( spg,
Filtered( InducedPcgs( spg, loc ), x ->
not ( RelativeOrderOfPcElement( spg, x ) = p ) ) );
# ncomp := Pcgs( NormalClosure( loc, SubgroupByPcgs( loc, comp ) ) );
## If we didn't need comp itself later on, we could use
ncomp := Pcgs( PResidual( loc, p ) ); # which would be lots faster.
# compute residual
residual := NormalizedPcgs( spg,
FCommutatorPcgs( g, ncomp, pcgsN, pcgsM ) );
## ncomp need not be induced wrt spg.
# update system record for normalizer
gens := pcgsN mod residual;
if Length( gens ) > 0 then
Append( system.base, gens );
Append( system.Fcentral, List( gens, x -> true ) );
Append( system.weights, List( gens, x -> wt ) );
if system.Flayers = [ ] then
system.Flayers := List( system.base, x -> 1 );
else
layer := system.Flayers[ Length( system.Flayers ) ];
Append( system.Flayers, List( gens, x -> layer + 1 ) );
fi;
if Length(system.Ffirst) = 0 then
Ffirst := Length(gens);
else
Ffirst := system.Ffirst[Length(system.Ffirst)] + Length(gens);
fi;
Add( system.Ffirst, Ffirst );
fi;
gens := residual mod pcgsM;
if Length( gens ) > 0 then
Append( system.base, gens );
Append( system.Fcentral, List( gens, x -> false ) );
Append( system.weights, List( gens, x -> wt ) );
layer := system.Flayers[ Length( system.Flayers ) ];
Append( system.Flayers, List( gens, x -> layer + 1 ) );
Ffirst := system.Ffirst[Length(system.Ffirst)] + Length(gens);
Add( system.Ffirst, Ffirst );
## Next line added to allow use of ChangeGenerator
system.depths := List( system.base,
x -> DepthOfPcElement( spg, x ) );
# modify central elements
j := system.Ffirst[ Length( system.Ffirst ) - 1 ] - 1;
while j >= 1 do
q := system.weights[ j ][ 3 ];
if p = q then
ChangeGenerator( system, NormalizedPcgs( spg, comp ), j );
fi;
j := j - 1;
od;
# cut out eccentric part
Unbind( system.Ffirst[ Length( system.Ffirst ) ] );
j := system.Ffirst[ Length( system.Ffirst ) ] - 1;
system.base := system.base{[1..j]};
system.Fcentral := system.Fcentral{[1..j]};
system.weights := system.weights{[1..j]};
system.Flayers := system.Flayers{[1..j]};
fi;
fi;
# change U
U := SubgroupNC( g,
Concatenation( system.base, spg{[ next..max ]} ) );
Info( InfoForm, 2, i," layer done \n");
od;
return PreImage( iso, U );
end);
#############################################################################
#M CoveringSubgroup2Op( G, form ) . . . . . .<form>-covering subgroup of <G>
##
SubgpMethodByNiceMonomorphismCollOther(CoveringSubgroup2Op, [IsGroup,
IsFormation]);
#############################################################################
#M CoveringSubgroupWrtFormation( G, form ) . . .<form>-covering group of <G>
##
## CoveringSubgroup1 seems to be somewhat faster than CoveringSubgroup2 in
## general, to judge from experiments.
InstallMethod( CoveringSubgroupWrtFormation,
"integrated", true,
[IsGroup, IsFormation and HasScreenOfFormation], 0,
function( G, form )
if HasComputedCoveringSubgroup1s( G ) and
Integrated( form ) in ComputedCoveringSubgroup2s( G ) then
return CoveringSubgroup2( G, Integrated( form ) );
else
return CoveringSubgroup1( G, Integrated( form ) );
fi;
end);
#############################################################################
#M CarterSubgroup( G ) . . . . . . . . . .nilpotent-covering subgroup of <G>
##
InstallMethod( CarterSubgroup, "solvable", true, [IsGroup], 0,
function( G )
return CoveringSubgroupWrtFormation( G, Formation("Nilpotent") );
end);
#E End of covering.gi
[ Dauer der Verarbeitung: 0.98 Sekunden
]
|
2026-03-28
|
