GAP (PERMUT) - Chapter 3: Permutability of Subgroups in Finite Groups

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

[MathJax off]

3 Permutability of Subgroups in Finite Groups
3.1 Permutability functions
3.1-1 ArePermutableSubgroups
3.2 Embedding properties related to permutability
3.2-1 PermutMaxTries
3.2-2 IsPermutable
3.2-3 OneSubgroupNotPermutingWith
3.2-4 IsFPermutable
3.2-5 OneFSubgroupNotPermutingWith
3.2-6 IsSPermutable
3.2-7 OneSylowSubgroupNotPermutingWith
3.2-8 IsSNPermutable
3.2-9 OneSystemNormaliserNotPermutingWith
3.2-10 IsConjugatePermutable
3.2-11 OneConjugateSubgroupNotPermutingWith
3.2-12 IsWeaklySPermutable
3.2-13 OneElementShowingNotWeaklySPermutable
3.2-14 IsWeaklyPermutable
3.2-15 OneElementShowingNotWeaklyPermutable
3.2-16 IsWeaklyNormal
3.2-17 OneElementShowingNotWeaklyNormal
3.2-18 IsWithSubnormalizerCondition
3.2-19 OneSubgroupInWhichSubnormalNotNormal
3.2-20 IsWithSubpermutizerCondition
3.2-21 OneSubgroupInWhichSubnormalNotPermutable
3.2-22 IsWithSSubpermutizerCondition
3.2-23 OneSubgroupInWhichSubnormalNotSPermutable

### 3 Permutability of Subgroups in Finite Groups

This chapter describes functions to check permutability of subgroups in a given group. First we present a function to check whether a subgroup permutes with another one, then we present functions to test whether a subgroup permutes with the members of a given family of subgroups, and finally we introduce some other subgroup embedding properties related to permutability.

#### 3.1 Permutability functions

##### 3.1-1 ArePermutableSubgroups

`‣ ArePermutableSubgroups`( [G, ]U, V ) | ( function )

This function returns `true` if U and V permute in G. The groups U and V must be subgroups of G. The subgroups \(U\) and \(V\) permute when \(UV = VU\). This is equivalent to affirming that \(UV\) is a subgroup of \(G\).

This is done by checking that the order of \(\langle U, V \rangle\) is the order of their Frobenius product \(UV\), that is, \(|U||V|/|U \cap V|\). Hence the performance of this function depends strongly on the existence of good algorithms to compute the intersection of two subgroups and, of course, the order of a subgroup. Shorthands are provided for the cases in which one of U and V is a subgroup of the other one or U or V are permutable in a common supergroup.

In the version with two arguments, U and V must have a common parent or `ClosureGroup( U, V )` (see `ClosureGroup` (Reference: ClosureGroup)) is called to construct a common supergroup for U and V.

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> a:=Subgroup(g,[(1,2)(3,4)]);
    Group([ (1,2)(3,4) ])
    gap> b:=Subgroup(g,[(1,2,3)]);
    Group([ (1,2,3) ])
    gap> c:=Subgroup(g,[(1,2)]);
    Group([ (1,2) ])
    gap> ArePermutableSubgroups(g,a,b);
    false
    gap> ArePermutableSubgroups(g,a,c);
    true
    gap> ArePermutableSubgroups(g,b,c);
    true
    gap> ArePermutableSubgroups(b,c);
    true
    gap> ArePermutableSubgroups(b,a);
    false

#### 3.2 Embedding properties related to permutability

In the following we describe some functions which allow us to test whether a subgroup permutes with the members of some families of subgroups. We pay special attention to the families of all subgroups and all Sylow subgroups of the group. In some cases, we have introduced some "One" functions, which give an element or a subgroup in the relevant family of subgroups of the group which shows that the given property fails, or `fail` otherwise.

##### 3.2-1 PermutMaxTries

`‣ PermutMaxTries` | ( global variable )

This variable contains the maximum number of random attempts of permutability checks before trying general deterministic methods in the functions `IsPermutable` (3.2-2) and `IsIwasawaSylow` (5.3-5). Its default value is \(10\).

##### 3.2-2 IsPermutable

`‣ IsPermutable`( G, H ) | ( operation )

`‣ IsPermutableInParent`( H ) | ( property )

This property returns `true` if the subgroup H is permutable in G, otherwise it returns `false`. We say that a subgroup \(H\) of a group \(G\) is permutable in \(G\) if \(H\) permutes with all subgroups of \(G\).

If the attribute `OneSubgroupNotPermutingWithInParent` (3.2-3) has been set, it is used if possible. Otherwise, the algorithm checks looks for a cyclic subgroup not permuting with H. The number of such cyclic subgroups is controlled by the variable `PermutMaxTries` (3.2-1), by default, \(10\). If H permutes with all these subgroups, then the algorithm checks whether H is hypercentrally embedded in G and that the Sylow \(p\)-subgroups of \(H/H_G\) permute with all cyclic \(p\)-subgroups of \(G/H_G\) for each prime \(p\) dividing the order of \(G/H_G\). This is a sufficient condition for permutability.

##### 3.2-3 OneSubgroupNotPermutingWith

`‣ OneSubgroupNotPermutingWith`( G, H ) | ( function )

`‣ OneSubgroupNotPermutingWithInParent`( H ) | ( attribute )

This attribute finds a cyclic subgroup of G which does not permute with H, that is, a subgroup which shows that H is not permutable in G. Recall that a subgroup \(H\) of a group \(G\) is permutable in \(G\) if \(H\) permutes with all subgroups of \(G\).

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> a:=Subgroup(g,[(1,2)(3,4)]);
    Group([ (1,2)(3,4) ])
    gap> b:=Subgroup(g,[(1,2,3)]);
    Group([ (1,2,3) ])
    gap> c:=Subgroup(g,[(1,2)]);
    Group([ (1,2) ])
    gap> IsPermutable(g,a);
    false
    gap> IsPermutable(g,b);
    false
    gap> IsPermutable(g,c);
    false
    gap> OneSubgroupNotPermutingWith(g,b);
    Group([ (1,3,4) ])
    gap> v:=Subgroup(g,[(1,2)(3,4),(1,3)(2,4)]);
    Group([ (1,2)(3,4), (1,3)(2,4) ])
    gap> OneSubgroupNotPermutingWith(g,v);
    fail
    gap> IsPermutable(g,b);
    false
    gap> IsPermutable(g,v);
    true

    gap> g:=SmallGroup(16,6);
    <pc group of size 16 with 4 generators>
    gap> h:=Subgroup(g,[g.2]);
    Group([ f2 ])
    gap> IsNormal(g,h);
    false
    gap> IsPermutable(g,h);
    true

Sometimes one does not require a subgroup to permute with all subgroups of the group, but only with a selected family of subgroups of the group. The general case is the following.

##### 3.2-4 IsFPermutable

`‣ IsFPermutable`( G, H, f ) | ( function )

In this function, H is a subgroup of G and f must be a list of subgroups of G. It returns `true` if H permutes with all members of f and `false` otherwise.

This function uses the function `OneFSubgroupNotPermutingWith` (3.2-5). Hence it tries to use the values of `IsPermutableInParent` (3.2-2) and `OneSubgroupNotPermutingWithInParent` (3.2-3) if one of them is set, and if it returns `false` it tries to set the values of `IsPermutableInParent` (3.2-2) and `OneSubgroupNotPermutingWithInParent` (3.2-3).

##### 3.2-5 OneFSubgroupNotPermutingWith

`‣ OneFSubgroupNotPermutingWith`( G, H, f ) | ( operation )

In this operation, H is a subgroup of G and f must be a list of subgroups of G. It returns a subgroup in f not permuting with H if such a subgroup exists, and `fail` otherwise.

This function tries to use the values of `IsPermutableInParent` (3.2-2) and `OneSubgroupNotPermutingWithInParent` (3.2-3) if one of them is set. If it returns `fail`, then it tries to set the value of `IsPermutableInParent` (3.2-2) and `OneSubgroupNotPermutingWithInParent` (3.2-3).

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> a:=Subgroup(g,[(1,2,3,4),(1,3)]);
    Group([ (1,2,3,4), (1,3) ])
    gap> Size(a);
    8
    gap> OneFSubgroupNotPermutingWith(g,a,MaximalSubgroups(g));
    Group([ (1,2), (3,4), (1,3)(2,4) ])
    gap> IsFPermutable(g,a,MaximalSubgroups(g));
    false
    gap> HasIsPermutableInParent(a);
    true
    gap> IsPermutableInParent(a);
    false
    gap> HasOneSubgroupNotPermutingWithInParent(a);
    true
    gap> OneSubgroupNotPermutingWithInParent(a);
    Group([ (1,2), (3,4), (1,3)(2,4) ])
    gap> IsFPermutable(g,a,AllSubnormalSubgroups(g));
    true
    gap> OneFSubgroupNotPermutingWith(g,a,AllSubnormalSubgroups(g));
    fail
    gap> sylows:=g->Union(List(SylowSubgroups(g),
    >           t->ConjugacyClassSubgroups(g,t)));
    function( g ) ... end
    gap> OneFSubgroupNotPermutingWith(g,a,sylows(g));
    Group([ (3,4), (1,4)(2,3), (1,3)(2,4) ])

The following functions can be considered as particular cases of the previous function for some subgroup embedding functors. However, they can be stored as "in parent" attributes or properties and in some cases we have tried to give more efficient code.

##### 3.2-6 IsSPermutable

`‣ IsSPermutable`( G, H ) | ( operation )

`‣ IsSPermutableInParent`( H ) | ( property )

This operation returns `true` if a subgroup H of G is S-permutable in G, that is, H permutes with all Sylow subgroups of G, and returns `false` otherwise.

    gap> g:=SmallGroup(8,3);
    <pc group of size 8 with 3 generators>
    gap> IsSPermutable(g,Subgroup(g,[g.1]));
    true
    gap> IsPermutable(g,Subgroup(g,[g.1]));
    false

##### 3.2-7 OneSylowSubgroupNotPermutingWith

`‣ OneSylowSubgroupNotPermutingWith`( G, H ) | ( operation )

`‣ OneSylowSubgroupNotPermutingWithInParent`( H ) | ( attribute )

The argument H must be a subgroup of G. If H is S-permutable in G, then it returns `fail`. Otherwise, it returns a Sylow subgroup of G which does not permute with H. We say that a subgroup \(H\) of a group \(G\) is S-permutable in \(G\) if \(H\) permutes with all Sylow subgroups of \(G\).

    gap> g:=SymmetricGroup(4);;
    gap> a:=Subgroup(g,[(1,2)(3,4)]);;
    gap> OneSylowSubgroupNotPermutingWith(g,a);
    Group([ (2,4,3) ])

##### 3.2-8 IsSNPermutable

`‣ IsSNPermutable`( G, H ) | ( operation )

`‣ IsSNPermutableInParent`( H ) | ( attribute )

This operation returns `true` if H permutes with all system normalisers of G, and `false` otherwise. Here G must be a soluble group and H must be a subgroup of G. If the function is applied to an insoluble group, it gives an error.

##### 3.2-9 OneSystemNormaliserNotPermutingWith

`‣ OneSystemNormaliserNotPermutingWith`( G, H ) | ( operation )

`‣ OneSystemNormaliserNotPermutingWithInParent`( H ) | ( attribute )

Here G must be a soluble group and H must be a subgroup of G. If H permutes with all system normalisers of G, then this operation returns `fail`. Otherwise, it returns a system normaliser \(D\) of \(G\) such that \(H\) does not permute with \(D\). If the group G is not soluble, then it gives an error.

    gap> g:=Group((1,2,3),(4,5,6),(1,2));
    Group([ (1,2,3), (4,5,6), (1,2) ])
    gap> a:=Subgroup(g,[(1,2,3)(4,5,6)]);
    Group([ (1,2,3)(4,5,6) ])
    gap> IsSNPermutable(g,a);
    true
    gap> IsSPermutable(g,a);
    false

The next functions are not particular cases of `IsFPermutable` (3.2-4) or `OneFSubgroupNotPermutingWith` (3.2-5), but we include them in the package because every subgroup permuting with all its conjugates is subnormal (see [Fog97]).

##### 3.2-10 IsConjugatePermutable

`‣ IsConjugatePermutable`( G, H ) | ( operation )

`‣ IsConjugatePermutableInParent`( H ) | ( property )

This operation takes the value `true` if H permutes with all its conjugates, and the value `false` otherwise.

    gap> g:=SymmetricGroup(4);
    Sym( [ 1 .. 4 ] )
    gap> a:=Subgroup(g,[(1,2)(3,4)]);
    Group([ (1,2)(3,4) ])
    gap> IsPermutable(g,a);
    false
    gap> IsConjugatePermutable(g,a);
    true

##### 3.2-11 OneConjugateSubgroupNotPermutingWith

`‣ OneConjugateSubgroupNotPermutingWith`( G, H ) | ( operation )

`‣ OneConjugateSubgroupNotPermutingWithInParent`( H ) | ( attribute )

This operation finds a conjugate subgroup of H which does not permute with H if such a subgroup exists. If H permutes with all its conjugates, then this operation returns `fail`.

    gap> g:=SmallGroup(16,7);
    <pc group of size 16 with 4 generators>
    gap> h:=Subgroup(g,[g.1*g.4]);
    Group([ f1*f4 ])
    gap> IsConjugatePermutable(g,h);
    false
    gap> OneConjugateSubgroupNotPermutingWith(g,h);
    Group([ f1*f3 ])

Next we introduce some subgroup embedding functions related to permutability which have proved to be useful in some characterisations of soluble T-groups, PT-groups, and PST-groups. The "One" functions return a value which proves that the corresponding subgroup embedding property is false.

##### 3.2-12 IsWeaklySPermutable

`‣ IsWeaklySPermutable`( G, H ) | ( operation )

`‣ IsWeaklySPermutableInParent`( H ) | ( property )

The value returned by this operation is `true` when H is a weakly S-permutable subgroup of G, that is, \(H\) is S-permutable in \(\langle H, H^g \rangle\) implies that \(H\) is S-permutable in \(\langle H, g \rangle\), and `false` otherwise.

##### 3.2-13 OneElementShowingNotWeaklySPermutable

`‣ OneElementShowingNotWeaklySPermutable`( G, H ) | ( operation )

`‣ OneElementShowingNotWeaklySPermutableInParent`( H ) | ( attribute )

If H is a weakly S-permutable subgroup of G, then this operation returns `fail`. Otherwise, the value returned by this operation is an element \(g \in G\) such that H is S-permutable in \(\langle H, H^g \rangle\), but \(H\) is not S-permutable in \(\langle H, g \rangle\). A subgroup \(H\) of a group \(G\) is said to be weakly S-permutable if \(H\) is S-permutable in \(\langle H, H^g \rangle\) implies that \(H\) is S-permutable in \(\langle H, g \rangle\).

##### 3.2-14 IsWeaklyPermutable

`‣ IsWeaklyPermutable`( G, H ) | ( operation )

`‣ IsWeaklyPermutableInParent`( H ) | ( property )

This operation returns `true` if H is weakly permutable in G, and `false` otherwise. A subgroup \(H\) of \(G\) is weakly permutable if the fact that \(H\) is S-permutable in \(\langle H, H^g \rangle\), implies that \(H\) is S-permutable in \(\langle H, g \rangle\).

##### 3.2-15 OneElementShowingNotWeaklyPermutable

`‣ OneElementShowingNotWeaklyPermutable`( G, H ) | ( operation )

`‣ OneElementShowingNotWeaklyPermutableInParent`( H ) | ( attribute )

If H is a weakly permutable subgroup of G, then this operation returns `fail`. Otherwise, the value returned by this operation is an element \(g \in G\) such that H is permutable in \(\langle H, H^g \rangle\), but \(H\) is not permutable in \(\langle H, g \rangle\). A subgroup \(H\) of a group \(G\) is said to be weakly permutable if the fact that \(H\) is permutable in \(\langle H, H^g \rangle\) implies that \(H\) is permutable in \(\langle H, g \rangle\).

##### 3.2-16 IsWeaklyNormal

`‣ IsWeaklyNormal`( G, H ) | ( operation )

`‣ IsWeaklyNormalInParent`( H ) | ( property )

This operation returns `true` if H is weakly normal in G, and `false` otherwise. A subgroup \(H\) of \(G\) is weakly normal whenever if \(H^g \leq {\rm N}_G(H)\), then \(g \in {\rm N}_G(H)\).

##### 3.2-17 OneElementShowingNotWeaklyNormal

`‣ OneElementShowingNotWeaklyNormal`( G, H ) | ( operation )

`‣ OneElementShowingNotWeaklyNormalInParent`( H ) | ( attribute )

If H is a weakly normal subgruop of G, then this function returns `fail`. Otherwise, the value returned by this operation is an element \(g\) such that \(H^g\leq {\rm N}_G(H)\) is a subgroup of \({\rm N}_G(H)\) but \(g \notin{\rm N}_G(H)\).

    gap> g:=DihedralGroup(8);
    <pc group of size 8 with 3 generators>
    gap> a:=Subgroup(g,[g.1]);
    Group([ f1 ])
    gap> IsWeaklySPermutable(g,a);
    true
    gap> IsWeaklyPermutable(g,a);
    false
    gap> x:=OneElementShowingNotWeaklyPermutable(g,a);
    f2
    gap> IsSubgroup(Normalizer(g,a),ConjugateSubgroup(a,x));
    true
    gap> x in Normalizer(g,a);
    false

##### 3.2-18 IsWithSubnormalizerCondition

`‣ IsWithSubnormalizerCondition`( G, H ) | ( operation )

`‣ IsWithSubnormalizerConditionInParent`( H ) | ( property )

`‣ IsWithSubnormaliserCondition`( G, H ) | ( operation )

`‣ IsWithSubnormaliserConditionInParent`( H ) | ( property )

This operation returns `true` if the subgroup \(H\) satisfies the subnormaliser condition in \(G\), and `false` otherwise.

A subgroup \(H\) is said to satisfy the subnormaliser condition in \(G\) if the condition that \(H\) is subnormal in a subgroup \(K\) of \(G\) implies that \(H\) is normal in \(K\).

##### 3.2-19 OneSubgroupInWhichSubnormalNotNormal

`‣ OneSubgroupInWhichSubnormalNotNormal`( G, H ) | ( operation )

`‣ OneSubgroupInWhichSubnormalNotNormalInParent`( H ) | ( attribute )

This function returns a subgroup \(K\) of \(G\) such that \(H\) is subnormal in \(K\) and \(H\) is not normal in \(K\), if this subgroup exists; otherwise, it returns `fail`.

##### 3.2-20 IsWithSubpermutizerCondition

`‣ IsWithSubpermutizerCondition`( G, H ) | ( operation )

`‣ IsWithSubpermutizerConditionInParent`( H ) | ( property )

`‣ IsWithSubpermutiserCondition`( G, H ) | ( operation )

`‣ IsWithSubpermutiserConditionInParent`( H ) | ( property )

This operation returns `true` if the subgroup \(H\) satisfies the subpermutiser condition in \(G\), and `false` otherwise.

A subgroup \(H\) is said to satisfy the subpermutiser condition in \(G\) if the condition that \(H\) is subnormal in a subgroup \(K\) of \(G\) implies that \(H\) is permutable in \(K\).

##### 3.2-21 OneSubgroupInWhichSubnormalNotPermutable

`‣ OneSubgroupInWhichSubnormalNotPermutable`( G, H ) | ( operation )

`‣ OneSubgroupInWhichSubnormalNotPermutableInParent`( H ) | ( attribute )

This function returns a subgroup \(K\) of \(G\) such that \(H\) is subnormal in \(K\) and \(H\) is not permutable in \(K\) if this subgroup exists; otherwise it returns `fail`.

##### 3.2-22 IsWithSSubpermutizerCondition

`‣ IsWithSSubpermutizerCondition`( G, H ) | ( operation )

`‣ IsWithSSubpermutizerConditionInParent`( H ) | ( property )

`‣ IsWithSSubpermutiserCondition`( G, H ) | ( operation )

`‣ IsWithSSubpermutiserConditionInParent`( H ) | ( property )

This operation returns `true` if the subgroup \(H\) satisfies the S-subpermutiser condition in \(G\), and `false` otherwise.

A subgroup \(H\) is said to satisfy the S-subpermutiser condition in \(G\) if the condition that \(H\) is subnormal in a subgroup \(K\) of \(G\) implies that \(H\) is S-permutable in \(K\).

##### 3.2-23 OneSubgroupInWhichSubnormalNotSPermutable

`‣ OneSubgroupInWhichSubnormalNotSPermutable`( G, H ) | ( operation )

`‣ OneSubgroupInWhichSubnormalNotSPermutableInParent`( H ) | ( attribute )

This function returns a subgroup \(K\) of \(G\) such that \(H\) is subnormal in \(K\) and \(H\) is not S-permutable in \(K\) if such a subgroup exists; otherwise it returns `fail`.

    gap> g:=SmallGroup(324,160);
    <pc group of size 324 with 6 generators>
    gap> a:=Subgroup(g,[g.3,g.5]);
    Group([ f3, f5 ])
    gap> IsWithSubnormalizerCondition(g,a);
    true
    gap> IsWeaklyNormal(g,a);
    false
    gap> IsWeaklySPermutable(g,a);
    false
    gap> x:=OneElementShowingNotWeaklyNormal(g,a);
    f1
    gap> ConjugateSubgroup(a,x)=a;
    false
    gap> IsSubset(Normalizer(g,a),ConjugateSubgroup(a,x));
    true

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

generated by GAPDoc2HTML