FittingSubgroup or FrattiniSubgroup do not have HasIsNilpotentGroup

[hungaborhorvath]

I just came across the following:

gap> G := FittingSubgroup(DihedralGroup(12));;
gap> HasIsNilpotentGroup(G);
false

As the Fitting subgroup is, by definition, nilpotent, the method should set the IsNilpotentGroup property to true. TraceMethods says that lib/grp.gi:966 is used, and indeed, IsNilpotentGroup is not set.

The same happens with the FrattiniSubgroup (called from lib/grppcatr.gi:136):

gap> G := FrattiniSubgroup(SmallGroup(192, 30));;
gap> HasIsNilpotentGroup(G);
false

I wonder, in general what kind of properties/attributes should be set by methods?
For example, is it possible to let GAP know that Sylow subgroups of FrattiniSubgroup(G) are normal in G? Or, is it possible to let GAP know that Socle of a nilpotent group is always central?

[stevelinton]

The headline problem can, and probably should, be fixed by adding a SetIsNilpotentGroup( ,true) call to the method for FittingSubgroup.

I wonder though if there is any merit in introducing a more general mechanism? You could imagine, for instance a call to declare that when an object o has certain filters set, and a is some attribute then
a(o) should automatically have certain filters set, or even have something like immediate methods run on it.

Another approach would be to have a single filter

Is<Attr>Result

which is set in all objects (for which filters can be set, integers and fail and so on would have to be excluded) and then install implications or immediate methods from this. This doesn't allow you to access the type of the "source" object, but requires less new machinery.

[hungaborhorvath]

Actually, I was wondering what are the possible filters, properties, attributes that are more common to consider when one writes a new method computing something. More specifically, I was wondering if there is any kind of filter for a subgroup that is a subgroup of the center of another group (e.g. the socle of a nilpotent group). A method might find the socle in such a way that even the IsAbelian filter is not set, and then it needs to be set by hand. Similarly, if there were some properties about centralness (idk, like IsCentralInParent, if it exists at all), it should be set, as well.

I was wondering if there is a list of all existing properties somewhere?

[fingolfin]

@stevelinton This sounds related to what the "TODO lists" of the ToolsForHomalg project do. May want to talk to @mohamed-barakat @sebasguts about this (very interesting stuff).

@hungaborhorvath There is no way to automatically ensure that e.g. the object returned by Centre has the IsAbelian filter set.

As to listing all existing properties: Well, you could type "Is" in the GAP interpreter, then press the TAB key twice to get a rough idea ;-). Of course not all of the these are "properties", but then, you may actually want more than properties anyway.

[fingolfin]

While at it, I should also mention the operations UseFactorRelation, UseIsomorphismRelation, UseSubsetRelation, another (incomplete) attempt to solve one facet of the underlying bigger issue (namely that one should argue about the relations resp. maps between object, not the objects itself -- i.e. a more categorial point of view, as e.g. the Homalg project takes it).

Addressing this properly and in general would be very nice.

[fingolfin]

BTW, in the case discussed here, one of course also need to take extra care to not forget that there are also infinite groups, and for those, neither the Fitting nor the Frattini group need to be nilpotent.

[hungaborhorvath]

Hm, I did try the Is+TAB approach, and it is really hard to navigate there....

BTW, so how will the IsNilpotent property be remedied in practice? Will all corresponding library file maintainers add this to their files, or should someone do this for all library files and put in a pull request?

[fingolfin]

You can count the globals starting with Is:

gap> Number(NamesGVars(), x -> StartsWith(x, "Is"));
1511

Quite a lot. Of course not all are really for properties and other filters...

[olexandr-konovalov]

I think this produces a list of existing properties for objects in IsGroup. Here GAP started with -r -A:

gap> isg := WITH_IMPS_FLAGS(FLAGS_FILTER(IsGroup));
<flag list>
gap> gatts := List(Filtered(ATTRIBUTES, a-> IS_SUBSET_FLAGS(isg,FLAGS_FILTER(a[2]))),a->a[1]);;
gap> Filtered(gatts, x ->x{[1,2]}="Is");
[ "IsImpossible", "IsEmpty", "IsTrivial", "IsNonTrivial", "IsFinite", "IsWholeFamily", 
  "IsDuplicateFree", "IsIntegralCyclotomic", "IsGeneratorsOfMagmaWithInverses", 
  "IsAssociative", "IsCommutative", "IsGeneratorsOfSemigroup", "IsZeroGroup", 
  "IsSimpleSemigroup", "IsZeroSimpleSemigroup", "IsReesCongruenceSemigroup", 
  "IsRegularSemigroup", "IsInverseSemigroup", "IsBand", "IsBrandtSemigroup", 
  "IsCliffordSemigroup", "IsCommutativeSemigroup", "IsCompletelyRegularSemigroup", 
  "IsCompletelySimpleSemigroup", "IsGroupAsSemigroup", "IsIdempotentGenerated", 
  "IsLeftZeroSemigroup", "IsMonogenicSemigroup", "IsMonoidAsSemigroup", 
  "IsOrthodoxSemigroup", "IsRectangularBand", "IsRightZeroSemigroup", "IsSemiband", 
  "IsSemilatticeAsSemigroup", "IsZeroSemigroup", "IsCyclic", "IsElementaryAbelian", 
  "IsFinitelyGeneratedGroup", "IsSubsetLocallyFiniteGroup", "IsPGroup", "IsNilpotentGroup", 
  "IsPerfectGroup", "IsSporadicSimpleGroup", "IsSimpleGroup", "IsAlmostSimpleGroup", 
  "IsSupersolvableGroup", "IsMonomialGroup", "IsSolvableGroup", "IsPolycyclicGroup", 
  "IsInfiniteAbelianizationGroup", "IsNormalInParent", 
  "IsomorphismTypeInfoFiniteSimpleGroup", "IsomorphismPcGroup", "IsomorphismSpecialPcGroup",
  "IsomorphismPermGroup", "IsomorphismFpGroup", "IsGeneratorsOfInverseSemigroup", 
  "IsNormalForm", "IsWeylGroup", "IsBuiltFromAdditiveMagmaWithInverses", "IsBuiltFromMagma",
  "IsBuiltFromMagmaWithOne", "IsBuiltFromMagmaWithInverses", "IsBuiltFromGroup", 
  "IsBuiltFromSemigroup", "IsBuiltFromMonoid", "IsomorphismRefinedPcGroup", 
  "IsAlternatingGroup", "IsSymmetricGroup", "IsDihedralGroup", "IsQuaternionGroup", 
  "IsQuasiDihedralGroup", "IsPSL", "IsCentralFactor", "IsFrattiniFree", 
  "IsHandledByNiceMonomorphism", "IsGroupOfAutomorphisms", 
  "IsGroupOfAutomorphismsFiniteGroup", "IsGeneralLinearGroup", "IsSpecialLinearGroup", 
  "IsomorphismFpSemigroup", "IsomorphismFpMonoid", "IsFullTransformationSemigroup", 
  "IsomorphismTransformationSemigroup", "IsomorphismTransformationMonoid", 
  "IsReesMatrixSemigroup", "IsReesZeroMatrixSemigroup", "IsomorphismReesMatrixSemigroup", 
  "IsomorphismPartialPermSemigroup", "IsomorphismPartialPermMonoid", "IsBergerCondition", 
  "IsSubnormallyMonomial", "IsMinimalNonmonomial" ]

[hungaborhorvath]

@alex-konovalov Hm, now I really start to wonder.... If one really meticulously wants to properly set these properties, then e.g. after figuring out that a group is abelian or nilpotent, then a lot of these properties should automatically set to false, e.g. IsSimpleGroup, IsSymmetricGroup, IsPSL, etc. (with a possible few exceptions). I am guessing that immediate methods could be written for such cases, but it would be tedious, never ending, and parts of it may already exist somewhere in the code.

Not to mention the situations, like when (anywhere, anytime) a nontrivial normal subgroup is computed, and then IsSimpleGroup should be set to false. But I guess nobody can expect the developers to keep track of all these properties....

[hulpke]

What would (apart from a stab-collecting urge) be the gain of having e.g. IsSimpleGroup be set automatically? There is no method selection on a filter being set to false.
Also even if they are set to true, there are in practice only a few property filters for which there are better methods. E.g. IsSolvableGroup often has better methods, but there are typically none implemented for IsNilpotentGroup. So setting such filters automatically would not yield any improvement.

[hungaborhorvath]

@hulpke Apart from the urge (which I guess is rather important), I can imagine that a later algorithm called by the user calls for IsSimpleGroup (e.g. for a similar situation: Socle currently calls for IsPrimitiveGroup and exits if its result is false), and this call might be costly (compared to being already set), because the algorithms for IsSimpleGroup will look at something else, not the fact that GAP has already computed a nontrivial normal subgroup. (This might be a wrong example, considering IsSimpleGroup is probably rather fast all the time).

Further, setting properties costs only 1 bit of memory, i.e. cheap. I can understand not setting attributes which may use up bigger chunks of memory.

About IsNilpotentGroup you are right. I found only 5 instances in the main library files where method selection checks whether this property is set. However, issue #385 is exactly about a situation, where current methods implemented for solvable groups is significantly slower than for nilpotent groups. Finally, considering that (statistically) most groups are p-groups, and therefore nilpotent, GAP probably should try to treat them a bit more favourably, if possible. (However, I would not argue that most interesting groups may not be nilpotent.)