GAP:IsFiniteJoinClosedGivenNormalizingJoinClosed

Definition
IsFiniteJoinClosedGivenNormalizingJoinClosed is a GAP function defined here that takes as input a group and a subgroup property, and outputs a boolean variable.

Behavior
If the subgroup property provided is a normalizing join-closed subgroup property, the behavior is as follows:


 * The function returns true if the join of any two subgroups of the group having the property also has the property; in other words, as far as this group is concerned, the subgroup property is a finite-join-closed subgroup property (NOTE: It may not be finite-join-closed because there may be some other group where the join of two subgroups with the property does not have the property).
 * The function returns false if there exist two subgroups of the group having the property whose join does not have the property. Note that this lets us definitely conclude that the join of two subgroups with the property does not have the property.

Note that the code assumes that the subgroup property is a subgroup property, i.e., that it is isomorphism-invariant. In particular, the code assumes that given two conjugate subgroups, one of them has the property if and only if the other does. Further, the code assumes that the subgroup property is normalizing join-closed: i.e., that the join of two subgroups with the property, where one of them normalizes the other, also has the property. If the subgroup property is not normalizing join-closed, an answer of false can still be trusted, but an answer of true cannot.

Related functions

 * GAP:IsFiniteJoinClosed: A similar behavior, but does not require the subgroup property to be normalizing join-closed.
 * GAP:IsFiniteJoinClosedGivenClosedUnderJoinWithNormal: A similar behavior, but requires a condition weaker than being normalizing join-closed: it requires that the join of any subgroup with the property with any normal subgroup with the property also has the property.
 * GAP:IsFiniteJoinClosedGivenNormalizingJoinClosedAndWeakerThanNormalForPGroup: An improved version where the whole group is a group of prime power order, and where every normal subgroup of the group has the property.

Code
IsFiniteJoinClosedGivenNormalizingJoinClosed := function(G,P) local H, K, L, R, S;       L := Filtered(ConjugacyClassesSubgroups(G),C -> P(G,Representative(C)) and not IsNormal(G,Representative(C))); for R in L do           H := Representative(R); for S in L do               for K in Filtered(AsList(S), W -> not IsNormal(W,H) and not IsNormal(H,W)) do                    if (not P(G,Group(Union(H,K)))) then return false; fi; od; od; od; return true; end;;

Underlying idea

 * First, a list of all conjugacy classes of subgroups is created using the GAP command ConjugacyClassesSubgroups.
 * This list is then filtered for the subgroup property, and the normal subgroups are filtered out. This is because since the property is normalizing join-closed, the join of any subgroup with the property and any normal subgroup with the property also has the property. Thus, the new list comprises conjugacy classes of non-normal subgroups with the property.
 * Next, we take joins between subgroups in these conjugacy classes, and check whether these joins again satisfy the property. For this, we use a slightly smart approach: instead of taking join between all pairs of subgroups in these conjugacy classes, we try all pairs where one member of the pair varies over representatives of the conjugacy classes of subgroups, and the other member varies over all subgroups. The idea is that if a counterexample exists, we can conjugate it to a situation where one of the two subgroups is the representative of its conjugacy class.
 * Further, before actually computing the join and checking whether it satisfies the property, we do a sanity check of whether either of the subgroups normalizes the other. This is to avoid unnecessary computation because we know that if either subgroup normalizes the other, then the join also has the property.

Possible modifications to the code

 * If the subgroup property is an identity-true subgroup property, i.e., if it is known that every group satisfies the property as a subgroup of itself, we can avoid checking things for all the maximal subgroups:

IsFiniteJoinClosedGivenNormalizingJoinClosedAndTrim := function(G,P) local H, K, L, R, S, D;       D := ConjugacyClassesMaximalSubgroups(G); L := Filtered(ConjugacyClassesSubgroups(G),C -> P(G,Representative(C)) and             not (C in D) and             not IsNormal(G,Representative(C))); for R in L do           H := Representative(R); for S in L do               for K in Filtered(AsList(S), W -> not IsNormal(W,H) and not IsNormal(H,W)) do                    if (not P(G,Group(Union(H,K)))) then return false; fi; od; od; od; return true; end;;