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 subgroup of \(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 [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) ])

`‣ 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 \({\rm 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

`‣ 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 \({\rm 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 ])

`‣ 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 \({\rm 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 ])

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