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.

`‣ 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

`‣ 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 ])

`‣ 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 [BER07], 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) ])

`‣ 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) ])

`‣ 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) ])

The next function names correspond to properties.

`‣ 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 [BBH03b], [BBH03a], 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

`‣ 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 [BBH03b], [BBH03a], 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 ])

`‣ 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 [BBH03b], [BBH03a], 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 ])

`‣ 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

`‣ 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

generated by GAPDoc2HTML