[Top] [Up] [Previous] [Next] [Index]

# 5 Fitting classes and Fitting sets

### Sections

1. Creating Fitting classes
2. Creating Fitting formations
3. Creating Fitting sets
4. Attributes and operations for Fitting classes and Fitting sets
5. Functions for minimal normal subgroups and the socle
6. Low level functions for normal subgroups related to radicals

In this chapter, you will find information on how to create Fitting classes and Fitting sets (see Creating Fitting classes and Creating Fitting sets below), and how to compute injectors and radicals with respect to these; see Attributes and operations for Fitting classes and Fitting sets.

## 5.1 Creating Fitting classes

Recall that a Fitting class is a nonempty group class which is closed with respect to normal subgroups and joins of subnormal subgroups.

- `FittingClass(`rec`) O`

  returns the Fitting class fitclass defined by the entries of the record rec. Note that it is the user's responsibility to ensure that rec really defines a Fitting class. rec may have components `\in`, `inj`, `rad`, `char`, and `name`. The functions assigned to the components are stored in the attributes `MemberFunction`, `InjectorFunction`, `RadicalFunction`, `Characteristic`, and `Name`, of fitclass. Please refer to MemberFunction, InjectorFunction, RadicalFunction, Characteristic, and Name for the meaning of these attributes.

  The third example below shows how to construct the Fitting class L2(calN) (see DH92, IX, 1.14 and 1.15), where calN is the class of all finite nilpotent groups.

      gap> myNilpotentGroups := FittingClass(rec(\in := IsNilpotent,
      >    rad := FittingSubgroup));
      FittingClass (in:=<Operation "IsNilpotent">, rad:=<Operation "FittingSubgroup"\
      >)
      gap> myTwoGroups := FittingClass(rec(
      >    \in := G -> IsSubset([2], Set(Factors(Size(G)))),
      >    rad :=  G -> PCore(G,2),
      >    inj := G -> SylowSubgroup(G,2)));
      FittingClass (in:=function( G ) ... end, rad:=function( G ) ... end, inj:=func\
      tion( G ) ... end)
      gap> myL2_Nilp := FittingClass (rec (\in :=
      >     G -> IsSolvableGroup (G)
      >          and Index (G, Injector (G, myNilpotentGroups)) mod 2 <> 0));
      FittingClass (in:=function( G ) ... end)
      gap> SymmetricGroup (3) in myL2_Nilp;
      false
      gap> SymmetricGroup (4) in myL2_Nilp;
      true   # thus myL2_Nilp is not closed with respect to factor groups

- `FittingProduct(`fit1`,` fit2`) O`

  returns the Fitting product prod of the Fitting classes fit1 and fit2, i. e., the class of all groups G such that G/R is a fit2-group, where R is the fit1-radical of G. prod is again a Fitting class. Note that if fit1 and fit2 are also formations, then prod equals the formation product of fit1 and fit2; see FormationProduct andindexttFittingFormationProduct FittingFormationProduct.

      gap> FittingProduct (myNilpotentGroups, myTwoGroups);
      FittingProduct (FittingClass (in:=<Operation "IsNilpotent">, rad:=<Operation "\
      FittingSubgroup">), FittingClass (in:=function( G ) ... end, rad:=function( G \
      ) ... end, inj:=function( G ) ... end))
      gap> FittingProduct (myNilpotentGroups, myL2_Nilp);
      FittingProduct (FittingClass (in:=<Operation "IsNilpotent">, rad:=<Operation "\
      FittingSubgroup">), FittingClass (in:=function( G ) ... end))

  ## 5.2 Creating Fitting formations

  Fitting formations are Fitting classes which are also formations.

- `FittingFormation(`rec`) O`

  creates a Fitting formation from the record rec. Note that it is the user's responsibility to ensure that rec really defines a Fitting formation. rec may have any components admissible for saturated formations (see SaturatedFormation) or Fitting classes (see FittingClass), that is, `\in`, `res`, `rad`, `inj`, `char`, and `name`, whose values are stored in the attributes `MemberFunction`, `ResidualFunction`, `RadicalFunction`, `InjectorFunction`, `Characteristic`, and `Name`, respectively. Please refer to MemberFunction, ResidualFunction, RadicalFunction, InjectorFunction, Characteristic, and Name, respectively, for the meaning of these attributes.

- `SaturatedFittingFormation(`rec`) O`

  creates a saturated Fitting formation from the record rec. Note that it is the user's responsibility to ensure that rec really defines a saturated Fitting formation. rec may have any components admissible for saturated formations (see SaturatedFormation) or Fitting classes (see FittingClass), that is, `\in`, `res`, `proj`, `bound`, `locdef`, `rad`, `inj`, `char`, and `Name`, whose values are stored in the attributes `MemberFunction` (see MemberFunction), `ResidualFunction` (see ResidualFunction), `ProjectorFunction` (see ProjectorFunction), `BoundaryFunction` (see BoundaryFunction), `LocalDefinitionFunction` (see LocalDefinitionFunction), `RadicalFunction` (see RadicalFunction), `InjectorFunction` (see InjectorFunction), `Characteristic` (see Characteristic), and `Name` (see Name), respectively.

  ## 5.3 Creating Fitting sets

  A nonempty set calF of subgroups of a group G is a Fitting set of G if it satisfies the following properties:

  (1)
    if H belongs to calF and K is normal in H, then K belongs to calF;

  (2)
    if H and K belong to calF, and H and K are normal in langleH, K rangle, then langleH, K rangle= H K belongs to cal F;

  (3)
    if H is in calF and g inG, then Hg also belongs to calF.

  Note that a Fitting set fitset of the group G is a subset of the set of all subgroups of G. Therefore it is not closed under group isomorphisms, hence is not a group class. If H is a subgroup of G, then the subgroups of G in fitset which are contained in H form a Fitting set of H. We will not distinguish between fitset and the arising Fitting set of H. Moreover, if fit is a Fitting class and grp is a group, then the set of all subgroups of grp which belong to fit is a Fitting set of grp.

- `IsFittingSet(`G`,` fitset`) O`

  tests whether fitset (or, more precisely, the set of all subgroups of G which are contained in fitset) is a Fitting set of the group G. Thus if fitset is a Fitting class, or if G is a subgroup of the group H and fitset is a Fitting set of H, then `IsFittingSet(`G`,` fitset`)` will return `true`.

- `FittingSet(`G`,` rec`) O`

  returns the Fitting set fitset of the group G, defined by the entries of the record rec. Note that, although it would be possible to test whether rec defines a Fitting set, such a test is not performed, since it would be extremely expensive, even for relatively small groups.

  rec may have components `\in`, `inj`, `rad`, and `name`. The functions assigned to the components are stored in the attributes `MemberFunction`, `InjectorFunction`, `RadicalFunction`, and `Name`, of fitset. Please see MemberFunction, InjectorFunction and RadicalFunction for the meaning of these arguments.

  Note that at present, every Fitting set has to be a class (see Set theoretical classes). The second example below shows how to define a Fitting set from a list of subgroups.

      gap>  fitset := FittingSet(SymmetricGroup (4), rec(
      >        \in := S -> IsSubgroup (AlternatingGroup (4), S),
      >        rad := S -> Intersection (AlternatingGroup (4), S),
      >        inj := S -> Intersection (AlternatingGroup (4), S)));
      FittingSet (SymmetricGroup(
      [ 1 .. 4 ] ), rec (in:=function( S ) ... end, rad:=function( S ) ... end, inj:\
      =function( S ) ... end))
      gap> FittingSet (SymmetricGroup (3), rec(
      >       \in := H -> H in [Group (()), Group ((1,2)), Group ((1,3)), Group ((2,3))]));
      FittingSet (SymmetricGroup( [ 1 .. 3 ] ), rec (in:=function( H ) ... end))

- `ImageFittingSet(`alpha`,` fitset`) O`

  returns the image F_1 of the Fitting set fitset under the group homomorphism alpha, i.e. the Fitting set F_1 of `Image(`alpha`)` which consists of all subgroups ``alpha`(`S`)` of `Image(`alpha`)` such that S is a fitset-injector of `PreImage(`alpha`,` S`)`. fitset must be a Fitting set of `PreImage(`alpha`)` or a Fitting class. Note that the image of a Fitting class is a Fitting set but not a Fitting class.

      gap> alpha := GroupHomomorphismByImages (SymmetricGroup (4), SymmetricGroup (3),
      >  [(1,2), (1,3), (1,4)], [(1,2), (1,3), (2,3)]);;
      gap> im := ImageFittingSet (alpha, fitset);
      FittingSet (Group( [ (1,2), (1,3), (2,3)
       ] ), rec (inj:=function( G ) ... end))
      gap> Radical (Image (alpha), im);
      Group([ (1,2,3), (1,3,2) ])

- `PreImageFittingSet(`alpha`,` fitset`) O`

  returns the preimage fitset_0 of the Fitting set fitset of `Image(`alpha`)` under the group homomorphism alpha. It consists of all subgroups S of `PreImage(`alpha`)` which are subnormal in `PreImage(`alpha`,` T`)` for some T in fitset. fitset must be a Fitting set of `Image(`alpha`)` or a Fitting class.

  Note that the preimage of a Fitting class is just a Fitting set but not a Fitting class.

  Moreover, `ImageFittingSet(PreImageFittingSet(`fitset`,` alpha`),` alpha`)` equals fitset but in general, fitset is not contained in `PreImageFittingSet(ImageFittingSet(`fitset`,` alpha`),` alpha`)`; see e.g. Example VIII, 2.16 of DH92.

      gap> pre := PreImageFittingSet (alpha, NilpotentGroups);
      FittingSet (SymmetricGroup( [ 1 .. 4 ] ), rec (inj:=function( G ) ... end))
      gap> Injector (Source (alpha), pre);
      Group([ (1,4)(2,3), (1,2)(3,4), (2,3,4) ])

- `Intersection(`fitset1`,` fitset2`)`

  Let fitset1 and fitset2 be Fitting sets of the groups G1 and G2. Then the intersection of fitset1 and fitset2 will be a Fitting set of the intersection of G1 and G2. You will run into an error if GAP cannot compute the intersection of G1 and G2.

      gap> F1 := FittingSet (SymmetricGroup (3),
      > rec (\in := IsNilpotent, rad := FittingSubgroup));
      FittingSet (SymmetricGroup(
      [ 1 .. 3 ] ), rec (in:=<Operation "IsNilpotent">, rad:=<Operation "FittingSubg\
      roup">))
      gap> F2 := FittingSet (AlternatingGroup (4),
      > rec (\in := ReturnTrue, rad := H -> H));
      FittingSet (AlternatingGroup(
      [ 1 .. 4 ] ), rec (in:=function(  ) ... end, rad:=function( H ) ... end))
      gap> F := Intersection (F1, F2);
      FittingSet (Group(
      [ (1,2,3) ] ), rec (in:=function( x ) ... end, rad:=function( G ) ... end))
      gap> Intersection (F1, PiGroups ([2,5]));
      FittingSet (SymmetricGroup(
      [ 1 .. 3 ] ), rec (in:=function( x ) ... end, rad:=function( G ) ... end))

  ## 5.4 Attributes and operations for Fitting classes and Fitting sets

  In addition to operations applicable to classes, both Fitting sets and Fitting classes admit the following attributes and operations. Of course, Fitting classes, being group classes, also admit all properties and attributes for group classes.

- `Radical(`G`,` fitset`) O`

  returns the grpclass-radical of the group G, where fitset is a Fitting set of G (see IsFittingSet), or a Fitting class. The fitset-radical of G is the unique largest normal subgroup of G belonging to fitset. Note that `Radical(`G`)` returns the solvable radical of a group G (see RadicalGroup in the GAP reference manual). The class `myL2_Nilp` in the example below has been defined in FittingClass.

      gap> Radical (SymmetricGroup (4), FittingClass (rec(\in := IsNilpotentGroup)));
      Group([ (1,4)(2,3), (1,3)(2,4) ])
      gap> Radical (SymmetricGroup (4), myL2_Nilp);
      Sym( [ 1 .. 4 ] )
      gap> Radical (SymmetricGroup (3), myL2_Nilp);
      Group([ (1,2,3) ])

- `Injector(`G`,` fitset`) O`

  returns a fitset-injector of the group G, where fitset is a Fitting set of G (or a group containing G), or a Fitting class. A subgroup H of G is a fitset-injector of G if S capH is fitset-maximal in S for every subnormal subgroup S of G. Note that by DH92, VIII, 2.9, all fitset-injectors of G are conjugate in G, and it is not hard to see that every subgroup of G has fitset-injectors if and only if fitset is a Fitting set of G. In particular, if fitset is a group class, then every finite solvable group has fitset-injectors if and only if fitset is a Fitting class; see DH92, IX, 1.4.

      gap> Injector (SymmetricGroup (4), FittingClass (rec(\in := IsNilpotentGroup)));
      Group([ (1,3)(2,4), (1,4)(2,3), (3,4) ])

- `RadicalFunction(`class`) A`

  This attribute, if present, forms part of the definition of class supplied by the user. It must contain a function which takes one argument, a group G, and returns the class-radical of G. This function will be used during subsequent calls to `Radical`. Therefore `Radical` (see Radical), which is guaranteed to work for arbitrary Fitting sets class, should always be called by the user to compute class-radicals.

- `InjectorFunction(`class`) A`

  This attribute constitutes part of the definition of class supplied by the user. If present, it must contain a function taking a group G as the only argument and returning a class-injector of G. This function will then be used by `Injector` (see Injector). Since `Injector` will work for arbitrary Fitting sets, it should always be called by the user to compute class-injectors.

  ## 5.5 Functions for minimal normal subgroups and the socle

  This section contains various algorithms to compute the socle of a finite soluble group, or, more generally, the solvable socle of an arbitrary finite group.

- `Socle(`grp`) A`

  CRISP provides a method for `Socle` (see Socle) for which works for all finite soluble groups grp. The socle of a group grp is the subgroup generated by all minimal normal subgroups of grp. See also SolvableSocle and PSocle below.

      gap> Size (Socle ( DirectProduct (DihedralGroup (8), CyclicGroup (12))));
      12

- `AbelianSocle(`grp`) A`
- `SolvableSocle(`grp`) A`

  This function computes the solvable socle of grp. The solvable socle of a group grp is the subgroup generated by all minimal normal solvable subgroups of grp.

- `SocleComponents(`grp`) A`

  This function returns a list of minimal normal subgroups of grp such that the socle of grp (see Socle) is the direct product of these minimal normal subgroups. Note that, in general, this decomposition is not unique. Currently, this function is only implemented for finite soluble groups. See also SolvableSocleComponents and PSocleComponents.

- `AbelianSocleComponents(`grp`) A`
- `SolvableSocleComponents(`grp`) A`

  This function returns a list of solvable minimal normal subgroups of grp such that the socle of grp (see Socle) is the direct product of these minimal normal subgroups. Note that, in general, this decomposition is not unique.

- `PSocle(`grp`,` p`) A`

  If p is a prime, the p-socle of a group grp is the subgroup generated by all minimal normal p-subgroups of grp.

- `PSocleComponents(`grp`,` p`) A`

  For a prime p, this function returns a list of minimal normal p-subgroups of grp such that the p-socle of grp (see PSocle) is the direct product of these minimal normal subgroups. Note that, in general, this decomposition is not unique.

- `AbelianMinimalNormalSubgroups(`grp`) A`

  This computes a list of all subgroups which are minimal among the nontrivial abelian normal subgroups. If grp is solvable, this coincides with the list of all minimal normal subgroups of grp.

  ## 5.6 Low level functions for normal subgroups related to radicals

- `OneInvariantSubgroupMaxWrtNProperty(`act`,` grp`,` pretest`,` test`,` data`) O`

  Let act be a list or group whose elements act on grp via the caret operator, such that every subgroup of grp invariant under act is normal in grp. Assume calX is a set of subgroups of grp such that calX contains the trivial group, and if M and N are act-invariant subgroups with M incalX and M containing N, then also N incalX. Then `OneInvariantSubgroupMaxWrtNProperty` computes an act-invariant subgroup M in calX such that no act-invariant subgroup of grp properly containing M belongs to cal X.

  For example, every Fitting set calX satisfies the above properties, where act = G. In this case, `OneInvariantSubgroupMaxWrtNProperty` will return the cal X-radical of grp.

  The class calX is described by two functions, pretest and test.

  pretest is a function taking four arguments, U, V, R, and data, where data is just the argument passed to `OneInvariantSubgroupMaxWrtNProperty`. U/V is an act-composition factor of grp, and R is an act-invariant subgroup of grp contained in V which is known to belong to calX.

  pretest may return the values `true`, `false`, or `fail`. If it returns `true`, every act-invariant subgroup N of grp contained in U such that N/R is G-isomorphic with U/V must belong to calX. If it returns `false`, no such N may belong to calX.

  test is a function taking three arguments, S, R, and data, where data has been described above. R is an act-invariant subgroup of grp belonging to calX, and S/R is an act-composition factor of grp. The function must return true if S belongs to calX, and false otherwise.

  Note that ``test`(`S`,` R`,` data`)` is only called if `pretest(`U`,` V`,` R`,` data`)` has returned `fail` for a chief factor U/V which is G-isomorphic with S/R. Therefore test need not repeat tests already performed by pretest. In particular, if pretest always returns `true` or `false`, test will not be called at all.

  data is never used or changed by `OneInvariantSubgroupMaxWrtNProperty`, but exists only as a means for passing additional information to or between the functions pretest and test.

- `AllInvariantSubgroupsWithNProperty(`act`,` grp`,` pretest`,` test`,` data`) O`

  returns a list consisting of all act-invariant subgroups of grp belonging to the class calX described by pretest, test, and data. See the documentation of `OneInvariantSubgroupMaxWrtNProperty` (see OneInvariantSubgroupMaxWrtNProperty) for details.

      gap> D := DihedralGroup (8);;
      gap> AllInvariantSubgroupsWithNProperty (
      > D, D,
      >     ReturnFail,
      >     function (R, S, data)
      >         return IsAbelian (R);
      >     end,
      >     fail);
      [ Group([ f3 ]), <pc group with 2 generators>, <pc group with 2 generators>,
        Group([ f2, f3 ]), Group([  ]) ]

- `OneNormalSubgroupWithNProperty(`grp`,` pretest`,` test`,` data`) O`
- `AllNormalSubgroupsWithNProperty(`grp`,` pretest`,` test`,` data`) O`

  are the same as `OneInvariantSubgroupMaxWrtNProperty` (see OneInvariantSubgroupMaxWrtNProperty) and `AllInvariantSubgroupsWithNProperty` ((see AllInvariantSubgroupsWithNProperty), where act = grp, and thus the act-invariant subgroups of grp are just the normal subgroups of grp.

  [Top] [Up] [Previous] [Next] [Index]