<html><head><title>[FORMAT] 6 Formation Examples</title></head>
<body text="#000000" bgcolor="#ffffff">
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<h1>6 Formation Examples</h1><p>
<p>
The following is a <font face="Gill Sans,Helvetica,Arial">GAP</font> session that illustrates the various functions
in the package. We have chosen to work with the symmetric group <i>S</i><sub>4</sub>
and the special linear group <i>SL</i>(2,3) as examples, because it is easy
to print and read the results of computations for these groups, and the
answers can be checked by inspection. However, both
<i>S</i><sub>4</sub> and <i>SL</i>(2,3) are extremely small examples for the algorithms in
<font face="Gill Sans,Helvetica,Arial">FORMAT</font>. In
<a href="biblio.htm#EW"><cite>EW</cite></a> we describe effective application of the algorithms to groups
of composition length as much as 61, for which the computations take
a few seconds to complete. The file <code>grp</code> contains some of these groups and other groups readable as <font face="Gill Sans,Helvetica,Arial">GAP</font> input.
<p>
<pre>
gap> LoadPackage("format");;
</pre>
A primitive banner appears.
<p>
First we define <i>S</i><sub>4</sub> as a permutation group and compute some
subgroups of it.
<pre>
gap> G := SymmetricGroup(4);
Sym( [ 1 .. 4 ] )
gap> SystemNormalizer(G); CarterSubgroup(G);
Group([ (3,4) ])
Group([ (3,4), (1,3)(2,4), (1,2)(3,4) ])
</pre>
Now we take the formation of supersolvable groups from the examples
and look at it.
<pre>
gap> sup := Formation("Supersolvable");
formation of Supersolvable groups
gap> KnownAttributesOfObject(sup); KnownPropertiesOfObject(sup);
[ "NameOfFormation", "ScreenOfFormation" ]
[ "IsIntegrated" ]
</pre>
<p>
We can look at the screen for <code>sup</code>.
<pre>
gap> ScreenOfFormation(sup);
<Operation "AbelianExponentResidual">
gap> ScreenOfFormation(sup)(G,2); ScreenOfFormation(sup)(G,3);
Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
</pre>
We get the residuals for <code>G</code> of the formations of abelian groups of exponent 1 ( = 2−1) and of exponent 2 (=3−1).
<p>
Notice that <code>sup</code> does not yet have a residual function.
Let's compute some subgroups of G corresponding to sup.
<pre>
gap> ResidualWrtFormation(G, sup);
Group([ (1,2)(3,4), (1,4)(2,3) ])
gap> KnownAttributesOfObject(sup);
[ "NameOfFormation", "ScreenOfFormation", "ResidualFunctionOfFormation" ]
</pre>
The residual function for <code>sup</code> was required and created.
<pre>
gap> FNormalizerWrtFormation(G, sup);
Group([ (3,4), (2,4,3) ])
gap> CoveringSubgroupWrtFormation(G, sup);
Group([ (3,4), (2,4,3) ])
gap> KnownAttributesOfObject(G);
[ "Size", "OneImmutable", "SmallestMovedPoint", "NrMovedPoints", "MovedPoints", "GeneratorsOfMagmaWithInverses", "TrivialSubmagmaWithOne", "MultiplicativeNeutralElement", "DerivedSubgroup", "IsomorphismPcGroup", "IsomorphismSpecialPcGroup", "PcgsElementaryAbelianSeries", "Pcgs", "GeneralizedPcgs", "StabChainOptions", "ComputedResidualWrtFormations", "ComputedAbelianExponentResiduals", "ComputedFNormalizerWrtFormations", "ComputedCoveringSubgroup1s", "ComputedCoveringSubgroup2s", "SystemNormalizer", "CarterSubgroup" ]
</pre>
The <code>AbelianExponentResidual</code>s were computed in connection with the
local definition of <code>sup</code>. (<code>AbelianExponentResidual(G, n)</code> returns
the smallest normal subgroup of <code>G</code> whose factor group is abelian of
exponent dividing <code>n-1</code>.) Here are some of the other records.
<pre>
gap> ComputedResidualWrtFormations(G);
[ formation of Supersolvable groups, Group([ (1,2)(3,4), (1,4)(2,3) ]) ]
gap> ComputedFNormalizerWrtFormations(G);
[ formation of Nilpotent groups, Group([ (3,4) ]),
formation of Supersolvable groups, Group([ (3,4), (2,4,3) ]) ]
gap> ComputedCoveringSubgroup2s(G);
[ ]
gap> ComputedCoveringSubgroup1s(G);
[ formation of Nilpotent groups, Group([ (3,4), (1,3)(2,4), (1,2)(3,4) ]),
formation of Supersolvable groups, Group([ (3,4), (2,4,3) ]) ]
</pre>
The call by <code>CoveringSubgroupWrtFormation</code> was to <code>CoveringSubgroup1</code>, not
<code>CoveringSubgroup2</code>.
<p>
We could also have started with a pc group or a nice enough matrix group.
<pre>
gap> s4 := SmallGroup(IdGroup(G));
<pc group of size 24 with 4 generators>
</pre>
This is <i>S</i><sub>4</sub> again. The answers just look different now.
<pre>
gap> SystemNormalizer(s4); CarterSubgroup(s4);
Group([ f1 ])
Group([ f1, f4, f3*f4 ])
</pre>
Similarly, we have <i>SL</i>(2,3) and an isomorphic pc group.
<pre>
gap> sl := SpecialLinearGroup(2,3);
SL(2,3)
gap> h := SmallGroup(IdGroup(sl));
<pc group of size 24 with 4 generators>
</pre>
We get the following subgroups.
<pre>
gap> CarterSubgroup(sl); Size(last);
<group of 2x2 matrices in characteristic 3>
6
gap> SystemNormalizer(h); CarterSubgroup(h);
Group([ f1, f4 ])
Group([ f1, f4 ])
</pre>
<p>
Now let's make new formations from old.
<pre>
gap> ab := Formation("Abelian");
formation of Abelian groups
gap> KnownPropertiesOfObject(ab); KnownAttributesOfObject(ab);
[ ]
[ "NameOfFormation", "ResidualFunctionOfFormation" ]
gap> nil2 := Formation("PNilpotent",2);
formation of 2Nilpotent groups
gap> KnownPropertiesOfObject(nil2); KnownAttributesOfObject(nil2);
[ "IsIntegrated" ]
[ "NameOfFormation", "ScreenOfFormation", "ResidualFunctionOfFormation" ]
</pre>
Compute the product and check some attributes.
<pre>
gap> form := ProductOfFormations(ab, nil2);
formation of (AbelianBy2Nilpotent) groups
gap> KnownAttributesOfObject(form);
[ "NameOfFormation", "ResidualFunctionOfFormation" ]
</pre>
Now the product in the other order, which <strong>is</strong> locally defined.
<pre>
gap> form2 := ProductOfFormations(nil2, ab);
formation of (2NilpotentByAbelian) groups
gap> KnownAttributesOfObject(form2);
[ "NameOfFormation", "ScreenOfFormation", "ResidualFunctionOfFormation" ]
</pre>
We check the results on <code>G</code>, which is still <i>S</i><sub>4</sub>.
<pre>
gap> ResidualWrtFormation(G, form); ResidualWrtFormation(G, form2);
Group(())
Group([ (1,3)(2,4), (1,2)(3,4) ])
gap> KnownPropertiesOfObject(form2);
[ ]
</pre>
Although <code>form2</code> is not integrated, we can make an integrated formation
that differs from <code>form2</code> only in its local definition, i.e., whose
residual subgroups are the same as those for <code>form2</code>.
<pre>
gap> Integrated(form2);
formation of (2NilpotentByAbelian)Int groups
</pre>
<code>FNormalizerWrtFormation</code> and
<code>CoveringSubgroupWrtFormation</code> both require integrated formations, so they
silently replace <code>form2</code> by this last formation without, however,
changing <code>form2</code>.
<pre>
gap> FNormalizerWrtFormation(G, form2); CoveringSubgroupWrtFormation(G, form2);
Group([ (3,4), (2,4,3) ])
Group([ (3,4), (2,4,3) ])
gap> KnownPropertiesOfObject(form2);
[ ]
gap> ComputedCoveringSubgroup1s(G);
[ formation of (2NilpotentByAbelian)Int groups, Group([ (3,4), (2,4,3) ]),
formation of Nilpotent groups, Group([ (3,4), (1,3)(2,4), (1,2)(3,4) ]),
formation of Supersolvable groups, Group([ (3,4), (2,4,3) ]) ]
gap> ComputedResidualWrtFormations(G);
[ formation of (2NilpotentByAbelian) groups,
Group([ (1,4)(2,3), (1,2)(3,4) ]),
formation of (AbelianBy2Nilpotent) groups, Group(()),
formation of 2Nilpotent groups, Group([ (1,2)(3,4), (1,3)(2,4) ]),
formation of Abelian groups, Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]),
formation of Supersolvable groups, Group([ (1,2)(3,4), (1,4)(2,3) ]) ]
</pre>
Lots of work has been going on behind the scenes.
<p>
Before we compute an intersection, we construct yet another formation.
<pre>
gap> pig := Formation("PiGroups", [2,5]);
formation of (2,5)-Group groups with support [ 2, 5 ]
gap> form := Intersection(pig, nil2);
formation of ((2,5)-GroupAnd2Nilpotent) groups with support [ 2, 5 ]
gap> KnownAttributesOfObject(form);
[ "NameOfFormation", "ScreenOfFormation", "SupportOfFormation", "ResidualFunctionOfFormation" ]
</pre>
Let's cut down the support of nil2 to {2,5}.
<pre>
gap> form3 := ChangedSupport(nil2, [2,5]);
formation of Changed2Nilpotent[ 2, 5 ] groups
gap> SupportOfFormation(form3);
[ 2, 5 ]
gap> form = form3;
false
</pre>
Although the formations defined by <code>form</code> and <code>form3</code> are abstractly
identical, <font face="Gill Sans,Helvetica,Arial">GAP</font> has no way to know this fact, and so distinguishes
them.
<p>
We can mix the various operations, too.
<pre>
gap> ProductOfFormations(Intersection(pig, nil2), sup);
formation of (((2,5)-GroupAnd2Nilpotent)BySupersolvable) groups
gap> Intersection(pig, ProductOfFormations(nil2, sup));
formation of ((2,5)-GroupAnd(2NilpotentBySupersolvable)) groups with support
[ 2, 5 ]
</pre>
<p>
Now let's define our own formation.
<pre>
gap> preform := rec( name := "MyOwn",
> fScreen := function( G, p)
> return DerivedSubgroup( G );
> end);
rec( fScreen := function( G, p ) ... end, name := "MyOwn" )
gap> form := Formation(preform);
formation of MyOwn groups
gap> KnownAttributesOfObject(form); KnownPropertiesOfObject(form);
[ "NameOfFormation", "ScreenOfFormation" ]
[ ]
</pre>
In fact, the definition is integrated. Let's tell GAP so and compute
some related subgroups.
<pre>
gap> SetIsIntegrated(form, true);
gap> ResidualWrtFormation(G, form);
Group([ (1,4)(2,3), (1,2)(3,4) ])
gap> FNormalizerWrtFormation(G, form);
Group([ (3,4), (2,4,3) ])
gap> CoveringSubgroup1(G, form);
Group([ (3,4), (2,4,3) ])
</pre>
These answers are consistent with the fact that <code>MyOwn</code> is really just the
formation of abelian by nilpotent groups.
<p>
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<P>
<address>FORMAT manual<br>January 2024
</address></body></html>
¤ Dauer der Verarbeitung: 0.1 Sekunden
(vorverarbeitet)
¤
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 ist noch experimentell.
