GAP (PERMUT) - Chapter 4: T-groups, PT-groups, and PST-groups

Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

4 T-groups, PT-groups, and PST-groups
4.1 "One" functions
4.1-1 OneSubnormalNonNormalSubgroup
4.1-2 OneSubnormalNonPermutableSubgroup
4.1-3 OneSubnormalNonSPermutableSubgroup
4.1-4 OneSubnormalNonConjugatePermutableSubgroup
4.1-5 OneSubnormalNonSNPermutableSubgroup
4.2 Group properties related to permutability
4.2-1 IsTGroup
4.2-2 IsPTGroup
4.2-3 IsPSTGroup
4.2-4 IsCPTGroup
4.2-5 IsPSNTGroup

### 4 T-groups, PT-groups, and PST-groups

This chapter explains the functions to check whether a given group is a T-group, a PT-group, or a PST-group.

Recall that a group G is:

a T-group

  when every subnormal subgroup of G is normal,

a PT-group

  when every subnormal subgroup of G is permutable,

a PST-group

  when every subnormal subgroup of G is S-permutable.

We also present functions to identify groups in other classes related to these ones.

The "One" functions are defined to provide examples of subgroups or elements showing that a group theoretical property for a group or for a subgroup is false.

#### 4.1 "One" functions

##### 4.1-1 OneSubnormalNonNormalSubgroup

`‣ OneSubnormalNonNormalSubgroup`( G ) | ( attribute )

`OneSubnormalNonNormalSubgroup` returns a subnormal subgroup of defect 2 which is not normal in the group G, if such a subgroup exists. If such a subgroup does not exist because the group is a T-group, it returns `fail`.

A T-group is a group in which normality is transitive, that is, if H is a normal subgroup of K and K is a normal subgroup of G, then H is a normal subgroup of G. Finite T-groups are the groups in which every subnormal subgroup is normal.

This function tries to set the property `IsTGroup` (4.2-1) to `true` or `false` according to its result.

    gap> g:=SmallGroup(320,152);
    <pc group of size 320 with 7 generators>
    gap> x:=OneSubnormalNonNormalSubgroup(g);
    Group([ f2, f3, f5, f7 ])
    gap> IsNormal(g,x);
    false
    gap> IsSubnormal(g,x);
    true

##### 4.1-2 OneSubnormalNonPermutableSubgroup

`‣ OneSubnormalNonPermutableSubgroup`( G ) | ( attribute )

`OneSubnormalNonPermutableSubgroup` returns a subnormal subgroup which is not permutable in the group G, if such a subgroup exists. If such a subgroup does not exist because the group is a PT-group, it returns `fail`.

A group G is a PT-group when permutability is a transitive relation in G, that is, if H is a permutable subgroup of K and K is a permutable subgroup of G, then H is a permutable subgroupof G. This is equivalent in finite groups to affirming that every subnormal subgroup of G is permutable.

This function tries to set the property `IsPTGroup` (4.2-2) to `true` or `false` according to its result.

Since this function checks all subnormal subgroups for permutability, it may take a long time if there are many subnormal subgroups.

    gap> g:=SmallGroup(320,152);
    <pc group of size 320 with 7 generators>
    gap> OneSubnormalNonPermutableSubgroup(g);
    fail
    gap> IsPTGroup(g);
    true
    gap> g:=SmallGroup(8,3);
    <pc group of size 8 with 3 generators>
    gap> OneSubnormalNonPermutableSubgroup(g);
    Group([ f1*f3 ])

##### 4.1-3 OneSubnormalNonSPermutableSubgroup

`‣ OneSubnormalNonSPermutableSubgroup`( G ) | ( attribute )

`OneSubnormalNonSPermutableSubgroup` returns a subnormal subgroup of defect 2 which is not S-permutable in G, if such a subgroup exists. If such a subgroup does not exist because the group is a PST-group, it returns `fail`.

A group G is a PST-group when S-permutability (Sylow permutability) is a transitive relation in G, that is, if H is an S-permutable subgroup of K and K is an S-permutable subgroup of G, then H is an S-permutable subgroup of G. This is equivalent in finite groups to affirming that every subnormal subgroup of G is S-permutable. By a result of Ballester-Bolinches, Esteban-Romero, and Ragland [BBERR07], it is enough to check this last condition for all subnormal subgroups of defect 2.

This function tries to set the property `IsPSTGroup` (4.2-3) to `true` or `false` according to its result.

    gap> g:=AlternatingGroup(4);
    Alt( [ 1 .. 4 ] )
    gap> OneSubnormalNonSPermutableSubgroup(g);
    Group([ (1,2)(3,4) ])

##### 4.1-4 OneSubnormalNonConjugatePermutableSubgroup

`‣ OneSubnormalNonConjugatePermutableSubgroup`( G ) | ( attribute )

This function finds a subnormal subgroup H which does not permute with all its conjugates, if such a subgroup exist; otherwise, it returns `fail`.

    gap> g:=AlternatingGroup(4);
    Alt( [ 1 .. 4 ] )
    gap> OneSubnormalNonConjugatePermutableSubgroup(g);
    fail
    gap> g:=DihedralGroup(16);
    <pc group of size 16 with 4 generators>
    gap> OneSubnormalNonConjugatePermutableSubgroup(g);
    Group([ f1*f4 ])
    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> OneSubnormalNonConjugatePermutableSubgroup(g);
    fail
    gap> OneSubnormalNonPermutableSubgroup(g);
    Group([ (1,2)(3,4) ])

##### 4.1-5 OneSubnormalNonSNPermutableSubgroup

`‣ OneSubnormalNonSNPermutableSubgroup`( G ) | ( attribute )

This attribute returns a subnormal subgroup H of the soluble group G such that H does not permute with a system normaliser if such a subgroup exists; otherwise, it returns `fail`. This system normaliser is obtained with the function `SystemNormalizer` (FORMAT: SystemNormalizer) of the Format package.

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> OneSubnormalNonSNPermutableSubgroup(g);
    Group([ (1,3)(2,4) ])
    gap> g:=Group((1,2,3)(4,5,6),(1,2));
    Group([ (1,2,3)(4,5,6), (1,2) ])
    gap> OneSubnormalNonSNPermutableSubgroup(g);
    fail
    gap> OneSubnormalNonSPermutableSubgroup(g);
    Group([ (1,2,3)(4,6,5) ])

#### 4.2 Group properties related to permutability

The next function names correspond to properties.

##### 4.2-1 IsTGroup

`‣ IsTGroup`( G ) | ( property )

This function returns `true` if G is a T-group, and `false` otherwise.

T-groups are the groups in which normality is a transitive relation, that is, if H is a subgroup of K and K is a subgroup of G, then H is a subgroup of G. In the finite case, they are the groups in which every subnormal subgroup is normal.

For soluble groups, the algorithm checks that for every prime p dividing its order, G is p-nilpotent and has a Dedekind Sylow p-subgroup or G has an abelian Sylow p-subgroup P and every subgroup of P is normal in N_G(P).

For insoluble groups, the function checks whether the group is an SC-group with the function `IsSCGroup` (7.1-4), because PT-groups are SC-groups. Since the methods for insoluble groups depend on the computation of a chief series with the function `ChiefSeries` (Reference: ChiefSeries), they might not be available if the group is not given as a permutation group. Then it is checked that every subnormal subgroup of defect 2 is normal with the help of the function `OneSubnormalNonNormalSubgroup` (4.1-1). The methods based on the ideas of [BBBH03a], [BBBH03b], and [BH03] have not been implemented so far because they require the computation of quotients by all normal subgroups, which could be a time-consuming task.

    gap> g:=SmallGroup(40,4);
    <pc group of size 40 with 4 generators>
    gap> IsTGroup(g);
    true
    gap> g:=SymmetricGroup(3);
    Sym( [ 1 .. 3 ] )
    gap> IsTGroup(g);
    true

##### 4.2-2 IsPTGroup

`‣ IsPTGroup`( G ) | ( property )

This property takes the value `true` if G is a PT-group, and the value `false` otherwise.

For a soluble group G, the function checks whether for all primes p, G is p-nilpotent and has an Iwasawa Sylow p-subgroup or G has an abelian Sylow p-subgroup and it satisfies the property C_p (that is, every subgroup of a Sylow p-subgroup P of G is normal in the Sylow normaliser N_G(P)).

For insoluble groups, the function checks that the group is an SC-group with the function `IsSCGroup` (7.1-4), because PT-groups are SC-groups. Since the methods for insoluble groups depend on the computation of a chief series with the function `ChiefSeries` (Reference: ChiefSeries), they might not be available if the group is not given as a permutation group. Then it uses the function `OneSubnormalNonPermutableSubgroup` (4.1-2) to check whether or not every subnormal subgroup is permutable. The methods based on the ideas of [BBBH03a], [BBBH03b], and [BH03] have not been implemented so far because they require the computation of quotients by all normal subgroups, which could be a time-consuming task.

    gap> g:=SmallGroup(1323,37);
    <pc group of size 1323 with 5 generators>
    gap> IsPTGroup(g);
    true
    gap> IsTGroup(g);
    false
    gap> OneSubnormalNonNormalSubgroup(g);
    Group([ f2*f3, f4, f5 ])

##### 4.2-3 IsPSTGroup

`‣ IsPSTGroup`( G ) | ( property )

This function returns true if the group G is a PST-group, and false otherwise.

A finite group G is a PST-group if S-permutability (Sylow-permutability) is a transitive relation in G, that is, if H is S-permutable in K and K is S-permutable in G, then H is S-permutable in G. This is equivalent to affirming that every subnormal subgroup of G is S-permutable in G.

For a soluble group G, the function checks whether for all primes p, G is p-nilpotent, or G has an abelian Sylow p-subgroup and G satisfies the property C_p (that is, every subgroup of a Sylow p-subgroup P of G is normal in the Sylow normaliser N_G(P))

For insoluble groups, the function checks whether the group is an SC-group with the function `IsSCGroup` (7.1-4), because PST-groups are SC-groups. Since the methods for insoluble groups depend on the computation of a chief series with the function `ChiefSeries` (Reference: ChiefSeries), they might not be available if the group is not given as a permutation group. Then it uses the function `OneSubnormalNonSPermutableSubgroup` (4.1-3) to check whether or not every subnormal subgroup of defect 2 is S-permutable. The methods based on the ideas of [BBBH03a], [BBBH03b], and [BH03] have not been implemented so far because they require the computation of quotients by all normal subgroups, which could be a time-consuming task.

    gap> g:=SmallGroup(24,6);
    <pc group of size 24 with 4 generators>
    gap> IsPSTGroup(g);
    true
    gap> IsPTGroup(g);
    false
    gap> OneSubnormalNonPermutableSubgroup(g);
    Group([ f1*f3, f4 ])
    gap> g:=SmallGroup(24,6);
    <pc group of size 24 with 4 generators>
    gap> IsPSTGroup(g);
    true
    gap> IsPTGroup(g);
    false
    gap> OneSubnormalNonPermutableSubgroup(g);
    Group([ f1*f3, f4 ])
    gap> OneSubgroupNotPermutingWith(g,last);
    Group([ f1*f2 ])

##### 4.2-4 IsCPTGroup

`‣ IsCPTGroup`( G ) | ( property )

This property returns true if every subnormal subgroup of G permutes with all its conjugates, and false otherwise.

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> IsCPTGroup(g);
    true
    gap> IsPTGroup(g);
    false
    gap> IsPSTGroup(g);
    false

##### 4.2-5 IsPSNTGroup

`‣ IsPSNTGroup`( G ) | ( property )

This property takes the value `true` if every subnormal subgroup of the soluble group G permutes with every system normaliser of G, and `false` otherwise. If the function is applied to an insoluble group, it gives an error.

    gap> g:=Group((1,2,3)(4,5,6),(1,3));
    Group([ (1,2,3)(4,5,6), (1,3) ])
    gap> IsPSTGroup(g);
    false
    gap> IsPSNTGroup(g);
    true
    gap> IsCPTGroup(g);
    true
    gap> g:=SmallGroup(16,7);
    <pc group of size 16 with 4 generators>
    gap> IsPSTGroup(g);
    true
    gap> IsCPTGroup(g);
    false
    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> IsPSNTGroup(g);
    false
    gap> IsCPTGroup(g);
    true

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind

generated by GAPDoc2HTML