Testing for isomorphism between normal subgroup lattices

Question

The question is whether we can use GAP to construct the normal subgroup lattice of a finite group $G$, call it $\mathcal{N}(G)$, and to then test whether $\mathcal{N}(G) \cong \mathcal{N}(H)$, where $G, H$ are non-isomorphic finite groups. An easy example of a pair $(G,H)$ such that $\mathcal{N}(G) \cong \mathcal{N}(H)$ and $|G|=|H|$ is the obvious $(Q_8,D_8)$, but for groups of larger size the task becomes unmanageable to carry out by hand.

---

I will provide here a little background on how and where this question comes up.

Assume that for a finite group $G$ we are given the following information: the normal subgroup lattice $\mathcal{N}(G)$, where each node representing a normal subgroup displays the order of that subgroup. The bigger question to answer here is which characteristic subgroups of $G$ can be located in $\mathcal{N}(G)$ by using only the information above.

It is clear that some subgroups can be located and sometimes this can be done with virtually no effort. For example, we can easily locate $\operatorname{F}(G)$ because the various $\operatorname{O}_p(G)$'s are directly visible in the lattice. Some other subgroups can still be located, but that requires more effort on our part. In case $G$ is soluble for instance, we can detect $\operatorname{\Phi}(G)$, the Frattini subgroup of $G$. (If $G$ is not soluble, then it is not possible to locate $\operatorname{\Phi}(G)$ and to see this one needs only look at the two perfect groups of order $1344$.) We can also locate $G'$ because there is a systematic way to tell if a group is abelian by looking at the normal subgroup lattice with orders.

The question I would like to answer is whether $\operatorname{Z}(G)$ can be located if we assume that $G$ is soluble. I suspect that the answer is "no" in general and that $p$-groups alone should suffice as sources of counterexamples. (Interestingly, if $G$ is soluble and we detect that $\operatorname{\Phi}(G) =1$ then it is possible to locate $\operatorname{Z}(G)$.)

Answer 1

Here is a very basic implementation that takes two lists of sets (e.g. lists of normal subgroups if the two groups) and tries to find an inclusion and order preserving map between them, returning fail if no such map can be found. It arranges the subgroups according to orders, calculates minimal inclusion relations, and then tries to map the one set of relations to the other one. It should do better than hand, but likely will fail if there are dozens of subgroups of a given order.

# take two lists of subsets, inclusion+order-preserving bijection, if any
InclusionOrderPreservingBijection:=function(l,m)
local inclusionSet,lsz,msz,lp,mp,lpair,mpair,c,G,i,f,e;

  # compute minimal inclusion releations
  inclusionSet:=function(a)
  local ai,i,j,apair;
    ai:=[];
    for i in [1..Length(a)] do
      ai[i]:=[];
      for j in [i+1..Length(a)] do
        if Size(a[j])>Size(a[i]) and IsSubset(a[j],a[i]) then
          AddSet(ai[i],j);
        fi;
      od;
    od;

    # minimal inclusions
    apair:=[];
    for i in [1..Length(a)] do
      for j in ShallowCopy(ai[i]) do
        ai[i]:=Difference(ai[i],ai[j]);
      od;
      for j in ai[i] do
        AddSet(apair,Immutable([i,j]));
      od;
    od;
    return apair;
  end;

  lsz:=List(l,Size);
  msz:=List(m,Size);

  # normalize arrangement
  lp:=Sortex(lsz);
  l:=Permuted(l,lp);
  mp:=Sortex(msz);
  m:=Permuted(m,mp);

  if lsz<>msz then
    return fail; # different orders
  fi;

  # inclusion sets
  lpair:=inclusionSet(l);
  mpair:=inclusionSet(m);

  if Length(lpair)<>Length(mpair) then
    return fail; # different inclusions
  fi;

  # mapping group
  c:=List(Collected(lsz),x->x[2]); # count how many of same sizes
  G:=[];
  f:=1;
  for i in c do
    Append(G,GeneratorsOfGroup(SymmetricGroup([f..f+i-1])));
    f:=f+i;
  od;
  G:=Group(G);

  # now G is the direct product of symmetric groups on the different sizes

  e:=RepresentativeAction(G,lpair,mpair,OnSetsSets);

  if e=fail then return fail;
  else
    return lp*e/mp;
  fi;
end;