Verifying the GVZ Property in GAP: A Computational Approach

As part of our research with Dr. Harmon, we aim to verify whether certain finite groups satisfy the GVZ property, meaning that for every nonlinear irreducible character , the subgroups defined by the values of coincide:

We implemented this test in GAP, a system for computational discrete algebra with powerful character theory tools.

Full Flowchart of the Algorithm

START
  │
  ▼
Get character table of G:
  tbl := CharacterTable(G)
  │
  ▼
Get all irreducible characters:
  chars := Irr(tbl)
  │
  ▼
For each χ ∈ chars:
  ├─► Is χ nonlinear? (χ(1) > 1)
  │     ├─► No → skip this χ
  │     └─► Yes
  │           │
  │           ▼
  │     Initialize empty sets:
  │       V_elements := []
  │       Z_elements := []
  │           │
  │           ▼
  │     For each conjugacy class c_i:
  │       For each g ∈ c_i:
  │         ├─► If χ(c_i) ≠ 0 → add g to V_elements
  │         └─► If |χ(c_i)| = χ(1) → add g to Z_elements
  │           │
  │           ▼
  │     Form subgroups:
  │       V(χ) := Subgroup(G, V_elements)
  │       Z(χ) := Subgroup(G, Z_elements)
  │           │
  │           ▼
  │     Compare:
  │       Is V(χ) = Z(χ)?
  │         ├─► No → print failure info
  │         └─► Yes → continue
  │
  ▼
If all χ passed, return TRUE (G is GVZ)
Else, return FALSE

Working GAP Code

IsGVZGroup := function(G)
  local tbl, chars, chi, vchi, zchi, isGVZ, g, v_elements, z_elements, i, ccl, class_pos;

  tbl := CharacterTable(G);
  chars := Irr(tbl);
  ccl := ConjugacyClasses(tbl);
  isGVZ := true;

  for i in [1..Length(chars)] do
    chi := chars[i];
    if chi[1] > 1 then
      v_elements := [];
      z_elements := [];

      for class_pos in [1..Length(ccl)] do
        for g in Elements(ccl[class_pos]) do
          if chi[class_pos] <> 0 then
            Add(v_elements, g);
          fi;
          if AbsoluteValue(chi[class_pos]) = chi[1] then
            Add(z_elements, g);
          fi;
        od;
      od;

      vchi := Length(v_elements) > 0 
              and Subgroup(G, v_elements) or TrivialSubgroup(G);
      zchi := Length(z_elements) > 0 
              and Subgroup(G, z_elements) or TrivialSubgroup(G);

      if vchi <> zchi then
        Print("Character ", i, " fails GVZ condition.\n");
        Print("Character degree: ", chi[1], "\n");
        Print("V(chi) size: ", Size(vchi), "\n");
        Print("Z(chi) size: ", Size(zchi), "\n");
        isGVZ := false;
      fi;
    fi;
  od;

  return isGVZ;
end;

What the Code Does

We’re checking the GVZ condition:

For each nonlinear irreducible character , define:

Then:

GVZ condition:
for all nonlinear

If this holds for all nonlinear irreducible characters, then is a GVZ-group.

What We Learned So Far

• We only need to test nonlinear irreducible characters because for linear ones (i.e., ), the GVZ condition is vacuously true:

• CharacterTable(G) pulls precomputed symbolic data, which is much faster and avoids looping over elements of .

• Irr(tbl) gives us a list of irreducible characters as arrays of values over conjugacy classes, not group elements.

• ConjugacyClasses(tbl) returns symbolic class identifiers (not concrete sets), which is ideal for character-theoretic computation.

Next Steps

We’ll begin running this script across batches of known o-basis groups to test our conjecture empirically.

We’ll log each result in a .csv file including:

• Group ID (e.g. SmallGroup(32,27))
• Character degrees
• Whether the GVZ condition holds
• Number of characters that fail the condition (if any)

Once we gather enough data, we’ll explore:

• Machine learning tools to detect deeper structural traits
• Visualizations comparing GVZ vs. o-basis patterns
• Discovering counterexamples or formulating improved conjectures