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

# 4 Schunck classes and formations

### Sections

1. Creating Schunck classes
2. Attributes and operations for Schunck classes
3. Additional attributes for primitive solvable groups
4. Creating formations
5. Attributes and operations for formations
6. Functions for normal and characteristic subgroups
7. Low level functions for normal subgroups related to residuals

In principle, any group class can be created as generic (group) class, followed by setting the required properties and attributes described in the preceding chapters. For certain standard kinds of group classes, there are additional functions available to accomplish this task, which are described in this and the following chapter.

## 4.1 Creating Schunck classes

A class calC of finite groups is a Schunck class if a finite group G belongs to calC if and only if all its primitive factor groups belong to calC. In particular, a Schunck class is nonempty and closed with respect to factor groups. By definition, a Schunck class calC is determined by the primitive groups which it contains (the basis of calC), or by the primitive groups not in calC but all of whose proper factor groups belong to calC (the boundary of calC).

- `SchunckClass(`rec`) O`

  returns a Schunck class defined by the information stored in the record rec. Note that it is the user's responsibility to ensure that rec really defines a Schunck class. rec may have the following components: `\in`, `proj`, `bound`, `char`, and `name`. The values bound to these entries, if present, are stored, respectively, in the attributes `MemberFunction`, `ProjectorFunction`, `BoundaryFunction`, `Characteristic`, and `Name`. Please refer to MemberFunction, ProjectorFunction, BoundaryFunction, Characteristic, and Name for the meaning of these attributes.

  At least one of the attributes `MemberFunction`, `ProjectorFunction`, or `BoundaryFunction` must be present in order to be able to compute with a Schunck class.

      gap> nilp := SchunckClass (rec (bound := G -> not IsCyclic (G),
      >        name := "class of all nilpotent groups"));
      class of all nilpotent groups
      gap> DihedralGroup (8) in nilp;
      true
      gap> SymmetricGroup (3) in nilp;
      false

  ## 4.2 Attributes and operations for Schunck classes

  In addition to the attributes and operations for generic group classes, for Schunck classes also the following are available:

- `Boundary(`class`) A`

  computes the boundary of class, i. e., the class of all primitive groups which do not belong to class but whose proper factor groups do. The result is a group class.

- `Basis(`class`) A`

  The basis of class consists of the primitive solvable groups in class. The result is a group class.

- `Projector(`grp`,` class`) O`

  This function returns a class-projector of grp. Note that, at present, methods are only available for finite solvable groups grp, or when class has an attribute `ProjectorFunction`.

  A subgroup H of the group G is a class-projector of G if H N/N is class-maximal in G/N for all normal subgroups N of G. A subgroup H of G is class-maximal in G if H belongs to class, and there is no subgroup L of G which contains H and lies in class. Note that if class consists of finite solvable groups, then class-projectors exist in every finite solvable group if and only if class is a Schunck class, and in this case all class-projectors of G are conjugate. See DH92, III, 3.21.

      gap> H := SchunckClass (rec (bound := G -> Size (G) = 6));
      SchunckClass (bound:=function( G ) ... end)
      gap> Size (Projector (GL(2,3), H));
      16
      gap> # H-projectors coincide with Sylow subgroups
      gap> U := SchunckClass (rec ( # class of all supersolvable groups
      >    bound := G -> not IsPrimeInt ( Size (Socle (G)))
      > ));
      SchunckClass (bound:=function( G ) ... end)
      gap> Size (Projector (SymmetricGroup (4), U));
      6
      gap> # the projectors are the point stabilizers

- `CoveringSubgroup(`grp`,` class`) O`

  A subgroup H of G is a class-covering subgroup of G if H is a class-projector of L for every subgroup L with H leqL leqG. Note that projectors and covering subgroups coincide for Schunck classes of finite solvable groups. At present, methods are only available for finite solvable groups grp.

- `BoundaryFunction(`grpclass`) A`

  This attribute stores a function func which has been set by the user to define grpclass, either as an argument to `SchunckClass`, `SaturatedFormation`, or `FittingFormation` (see SchunckClass, SaturatedFormation, or FittingFormation), or has been set directly (see Setter). func must be a function taking one argument. If the argument is a finite solvable group G having attributes `Socle` and `SocleComplement` (see Section Additional attributes for primitive solvable groups below), func must return `true` if G is in the boundary of grpclass, and `false` if G belongs to grpclass. The behaviour for arguments which are not primitive solvable groups, or which belong neither to grpclass nor to the boundary of grpclass need not be defined. Note that `BoundaryFunction` should not be used to test whether a given group belongs to the boundary of grpclass. `Boundary` and/or `Basis` (see Boundary and Basis), which are defined independently of the way grpclass is defined.

- `ProjectorFunction(`grpclass`) A`

  If bound, `ProjectorFunction` stores a function func supplied by the user as part of the definition of grpclass. func must be a function taking a group G as the only argument, and returns a grpclass-projector of G. Note that `Projector` (see Projector), rather than `ProjectorFunction`, should be used by the user to compute grpclass-projectors.

  ## 4.3 Additional attributes for primitive solvable groups

  A finite group G is primitive if it has a faithful primitive permutation representation, or equivalently, if it has a maximal subgroup M with trivial core. If G is solvable, M complements the unique minimal normal subgroup N of G. Therefore N is the socle as well as the Fitting subgroup of grp.

- `IsPrimitiveSolvable(`grp`) P`

  returns true if grp is primitive and solvable, and false otherwise.

- `SocleComplement(`grp`) A`

  If present, this attribute stores a complement of the socle of grp. Currently, there is only a method available for `SocleComplement` if grp has the property `IsPrimitiveSolvable`.

  ## 4.4 Creating formations

  A nonempty group class is a formation if it is closed with respect to factor groups and residually closed. A saturated formation is, of course, a formation which is saturated. Note that by the Gaschütz-Lubeseder-Schmid theorem (see e. g. DH92, IV, 4.6), every saturated formation is a local formation. Moreover, every saturated formation is a Schunck class. Therefore a saturated formation admits the operations `Boundary`, `Basis`, and `Projector`.

- `OrdinaryFormation(`rec`) O`

  creates a formation from the record rec. Note that it is the user's responsibility to ensure that rec really defines a formation. rec may have components `\in`, `res`, `char`, and `name`, whose values are stored in the attributes `MemberFunction`, `ResidualFunction`, `Characteristic`, and `Name`, respectively, of the new formation. See MemberFunction, ResidualFunction, Characteristic, and Name, respectively, for the meaning of these attributes.

  The following example shows how to construct the formations of all groups of derived length at most 3 and of all groups of exponent dividing 6.

      gap> der3 := OrdinaryFormation (rec (
      >    res := G -> DerivedSubgroup (DerivedSubgroup (DerivedSubgroup (G)))
      > ));
      OrdinaryFormation (res:=function( G ) ... end)
      gap> SymmetricGroup (4) in der3;
      true
      gap> GL (2,3) in der3;
      false
      gap> exp6 := OrdinaryFormation (rec (
      >    \in := G -> 6 mod Exponent (G) = 0,
      >    char := [2,3]));
      OrdinaryFormation (in:=function( G ) ... end)

- `SaturatedFormation(`rec`) O`

  creates a saturated formation from the record rec. Note that it is the user's responsibility to ensure that rec really defines a saturated formation. rec may have any components admissible for formations (see OrdinaryFormation) or Schunck classes (see SchunckClass), that is, `\in`, `res`, `char`, `proj`, `bound`, `locdef`, and `name`, whose values, if bound, are stored in the attributes `MemberFunction`, `ResidualFunction`, `Characteristic`, `ProjectorFunction`, `BoundaryFunction`, `LocalDefinitionFunction`, and `Name`, respectively. Please refer to MemberFunction, ResidualFunction, Characteristic, ProjectorFunction, BoundaryFunction, LocalDefinitionFunction, and Name for the meaning of these attributes.

  There are also functions `FittingFormation` and `SaturatedFittingFormation` to create Fitting formations and saturated Fitting formations; see FittingFormation and SaturatedFittingFormation below for details.

  The following example shows how to construct the saturated formations of all finite nilpotent groups and of all nilpotent-by-abelian groups whose order is not divisible by a prime congruent 3 mod 4, and whose 2-chief factors are central. In the first case, we choose f(p) = (1) for all primes p, so that the f(p)-residual of G is generated by a generating set of G (see LocalDefinitionFunction below). In the second example, we let f(2) = 1, if p equiv3 pmod4, we define f(p) = calA, the class of all finite abelian groups, and set f(p) = emptyset otherwise.

      gap> nilp := SaturatedFormation (rec (
      >      locdef := function (G, p)
      >          return GeneratorsOfGroup (G);
      >      end));
      SaturatedFormation (locdef:=function( G, p ) ... end)
      gap> form := SaturatedFormation (rec (
      >    locdef := function (G, p)
      >        if p = 2 then
      >           return GeneratorsOfGroup (G);
      >        elif p mod 4 = 3 then
      >           return GeneratorsOfGroup (DerivedSubgroup (G));
      >        else
      >           return fail;
      >        fi;
      >     end));
      SaturatedFormation (locdef:=function( G, p ) ... end)
      gap> Projector (GL(2,3), form);
      Group([ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ],
        [ [ Z(3)^0, Z(3) ], [ 0*Z(3), Z(3)^0 ] ],
        [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ])

- `FormationProduct(`form1`,` form2`) O`

  The formation product prod of two formations form1 and form2 consists of the groups G such that the form2-residual of G belongs to form1. The product prod is again a formation. If form1 and form2 are saturated formations, the result is a saturated formation. The same is true if the characteristic of form2 is contained in that of form1. This is automatically recognised if the characteristic of form1 is `AllPrimes` (see AllPrimes). In all other cases, you will have to set the attribute `IsSaturated` manually, if applicable. Note that in general it is not possible for CRISP to determine if two classes are contained in each other.

      gap> nilp := SaturatedFormation (rec (\in := IsNilpotent, name := "nilp"));
      nilp
      gap> FormationProduct (nilp, der3); # no characteristic known
      FormationProduct (nilp, OrdinaryFormation (res:=function( G ) ... end))
      gap> HasIsSaturated (last);HasCharacteristic (nilp);
      false
      false
      gap> SetCharacteristic (nilp, AllPrimes);
      gap> FormationProduct (nilp, der3); # try with characteristic
      FormationProduct (nilp, OrdinaryFormation (res:=function( G ) ... end))
      gap> IsSaturated (last);
      true

- `FittingFormationProduct(`fitform1`,` fitform2`) O`

  If fitform1 and fitform2 are Fitting formations, the formation product equals the Fitting product (see FittingProduct) of fitform1 and fitform2, which, in turn, equals the class product of fitform1 and fitform2. The latter consists of all groups G having a normal subgroup N in fitform1 such that G/N belongs to fitform2.

  Note that if fitform1 and fitform2 are Fitting formations, then `FormationProduct(`fitform1`,` fitform2`)`, `FittingProduct(`fitform1`,` fitform2`)` and `FittingFormationProduct(`fitform1`,` fitform2`)` all return the same mathematical object (but distinct GAP objects), which is, again, a Fitting formation.

      gap> nilp := FittingFormation (rec (\in := IsNilpotent, name := "nilp"));;
      gap> FormationProduct (nilp, nilp);
      FittingFormationProduct (nilp, nilp)
      gap> FittingProduct (nilp, nilp);
      FittingFormationProduct (nilp, nilp)
      gap> FittingFormationProduct (nilp, nilp);
      FittingFormationProduct (nilp, nilp)

  ## 4.5 Attributes and operations for formations

  In addition to those available for generic group classes, formations also admit the following attributes and operations. See also Attributes and operations for Schunck classes for additional operations for saturated formations.

- `Residual(`grp`,` form`) O`
- `Residuum(`grp`.` form`) O`

  return the form-residual (also called form-residuum) of the group grp. This is the smallest normal subgroup res of grp such that grp/res belongs to form. Note that, unless form has an attribute `ResidualFunction`, there are presently only methods available for finite solvable groups.

- `ResidualFunction(`form`) A`

  This attribute is part of the definition of form supplied by the user. If present, it must contain a function which computes the form-residual of a given group. In general, such a residual only exists if form is residually closed; cf. IsResiduallyClosed. Note that `ResidualFunction`, if present, is called by `Residual` (see Residual). Therefore `Residual`, which also works for formations without `ResidualFunction`, should be used by the user to compute form-residuals.

- `LocalDefinitionFunction(`form`) A`

  Let form be a saturated formation with local function f. This attribute, if present, stores a function func supplied by the user as part of the definition of form. func must be a function taking two parameters, a group G and a prime p. If p is in the characteristic of form, this function must return a list list of elements of G, such that the smallest normal subgroup of G containing list is the f(p)-residual of G. If p is not in the characteristic of form, then ``func`(`G`,` p`)` must return `fail` for any group G. `LocalDefinitionFunction` is part of the definition of form and should not be called by the user.

  ## 4.6 Functions for normal and characteristic subgroups

- `NormalSubgroups(`grp`) A`

  CRISP provides an improved method for `NormalSubgroups` (see NormalSubgroups) for groups grp which are finite and solvable. This method simply calls `AllInvSgrsWithQPropUnderAction` with act = grp, `ReturnTrue` as pretest and `ReturnFail` as test. Note that, since pretest always returns `true`, test is never actually called. This is usually significantly faster than the methods in the GAP library.

- `CharacteristicSubgroups(`grp`) A`

  returns a list containing all characteristic subgroups of grp. `CharacteristicSubgroups` calls `AllInvSgrsWithQPropUnderAction`.

  ## 4.7 Low level functions for normal subgroups related to residuals

- `OneInvariantSubgroupMinWrtQProperty(`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 that calX is a set of act-invariant subgroups of grp containing grp, and such that whenever M and N are act-invariant subgroups with M incalX and M contained in N, then also N incalX. Then `OneInvariantSubgroupMinWrtQProperty` computes an act-invariant subgroup M incalX such that no act-invariant subgroup of grp contained in M belongs to calX. At present, there exist only methods for finite solvable groups 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 `OneInvariantSubgroupMinWrtQProperty` (see below for examples). U/V is a chief factor of grp, and R is an act-invariant subgroup of grp containing U 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 such that V is contained in N and R/N is G-isomorphic with U/V must belong to calX. If it returns `false`, no such act-invariant subgroup N may belong to calX.

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

  Note that whenever ``test`(`S`,` R`,` data`)` is called, ``pretest`(`U`,` V`,` R`,` data`)` has been called before, and has returned `fail`, where U/V is a chief factor which is G-isomorphic with R/S. Thus test need not repeat tests which have been performed by pretest. In particular, if pretest always returns `true` or `false`, test will never be called.

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

  For example, if calC is a group class which is closed with respect to factor groups and calX is the set of all act-invariant subgroups N of grp with grp/N incalC, then calX satisfies the above properties. In particular, if calC is a formation, then `OneInvariantSubgroupMinWrtQProperty` will return the calC-residual of grp.

  The following example shows how to use `OneInvariantSubgroupMinWrtQProperty` to compute the derived subgroup of a group G. (Note that in practise, this is not a particularly efficient way of computing the derived subgroup.)

      gap> G := DirectProduct (SL(2,3), CyclicGroup (2));;
      gap> data := rec (gens := GeneratorsOfGroup (G),
      >    comms := List (Combinations (GeneratorsOfGroup (G), 2),
      >       x -> Comm (x[1],x[2])));;
      gap> OneInvariantSubgroupMinWrtQProperty (
      >    G, G,
      >    function (U, V, R, data) # test if U/V is central in G
      >        if ForAny (ModuloPcgs (U, V), y ->
      >           ForAny (data.gens, x -> not Comm (x, y) in V)) then
      >           return false;
      >        else
      >           return fail;
      >        fi;
      >     end,
      >     function (S, R, data)
      >        return ForAll (data.comms, x -> x in S);
      >     end,
      >     data) = DerivedSubgroup (G); # compare results
      true

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

  `AllInvariantSubgroupsWithQProperty` returns a list consisting of all act-invariant subgroups in calX, where calX is the class defined by pretest, test, and data, as described for `OneInvariantSubgroupMinWrtQProperty` (see OneInvariantSubgroupMinWrtQProperty). At present, there exist only methods for finite solvable groups grp.

      gap> G := GL(2,3);
      GL(2,3)
      gap> normsWithSupersolvableFactorGroups :=
      > AllInvSgrsWithQPropUnderAction (G, G,
      >    function (U, V, R, data)
      >       return IsPrimeInt (Index (U, V));
      >    end,
      >    ReturnFail, # pretest is sufficient
      >    fail); # no data required
      [ GL(2,3),
        Group([ [ [ Z(3)^0, Z(3) ], [ 0*Z(3), Z(3)^0 ] ], [ [ Z(3), Z(3)^0 ],
                [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), Z(3)^0 ], [ Z(3), 0*Z(3) ] ],
            [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ]),
        Group([ [ [ Z(3), Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ],
            [ [ 0*Z(3), Z(3)^0 ], [ Z(3), 0*Z(3) ] ],
            [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ]) ]

- `OneNormalSubgroupMinWrtQProperty(`grp`,` pretest`,` test`,` data`) O`

  `OneNormalSubgroupMinWrtQProperty` is the same as `OneInvariantSubgroupMinWrtQProperty` (see OneInvariantSubgroupMinWrtQProperty), where act = grp.

- `AllNormalSubgroupsWithQProperty(`grp`,` pretest`,` test`,` data`) O`

  `AllNormalSubgroupsWithQProperty` is the same as `AllInvariantSubgroupsWithQProperty` (see AllInvariantSubgroupsWithQProperty), where act = grp.

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