From a2b4319fbe7dea5fb0ead361fe0024efb55ee0d4 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Sun, 15 Nov 2026 10:54:35 +0100 Subject: [PATCH] Detect Spin(7,q) in Omega+(8,q) by its 4-form For d = 8, q = 3, 5, NonGenericOrthogonalPlus separated Omega+(8,q) and its overgroups from Spin(7,q) in its spin representation by a stabiliser chain of the projective action (RECOG.EstimateProjOrder). Once elements of orders 7, 13 (and 31 for q = 5) are seen, only the maximal subgroups of order |SO(7,q)| remain [Kle87, Table I], so an irreducible group not containing Omega+(8,q) normalises Spin(7,q). That normaliser fixes the line of the Cayley 4-form, acting on it by the squared multiplier, while Omega+(8,q) fixes no line of 4-forms. RECOG.FixesFourFormLine checks this with a 70-dimensional nullspace per generator. The order-312 shortcut for q = 5, a raw element order, goes. For q = 5, the 13 in [NP99, Table 4] stands for a splitting lppd(8,5;4)-element, so the comment calling the paper wrong is replaced. New tests: GO and Omega(+1,8,5), CGO^+(8,q) and Omega^+(8,q) with scalars, and the maximal subgroups of order |SO(7,q)| of Omega+(8,q) for q = 3, 5, via a filter argument for TestNamingMaximals. Setup, GAP 4.16.1, old code loaded: gap> MsPerCall := function(G, n) local t, i; t := NanosecondsSinceEpoch(); for i in [1 .. n] do RecogniseClassical(G); od; return Float((NanosecondsSinceEpoch() - t) / n / 10^6); end;; gap> G3 := Omega(+1, 8, 3);; G5 := Omega(+1, 8, 5);; Before: gap> MsPerCall(G3, 50); 44.0381 gap> MsPerCall(G5, 50); 218.351 After, same session, swap.g rebinding the new helper and method: gap> Read("swap.g"); gap> MsPerCall(G3, 50); 10.591 gap> MsPerCall(G5, 50); 17.7594 Assisted-by: Generative AI --- gap/matrix/classical.gi | 146 +++++++++++------- tst/naming.g | 20 ++- .../combined/ClassicalMaximalsNaming.tst | 6 + .../combined/ClassicalNaturalNaming.tst | 4 +- tst/working/combined/MoreNaming.tst | 8 + 5 files changed, 127 insertions(+), 57 deletions(-) diff --git a/gap/matrix/classical.gi b/gap/matrix/classical.gi index 0addc361..8ee27d7c 100644 --- a/gap/matrix/classical.gi +++ b/gap/matrix/classical.gi @@ -29,6 +29,11 @@ ## "A Recognition Algorithm for Non-Generic Classical Groups over ## Finite Fields", J. Austral. Math. Soc. (Series A)67 , 223-253, 1999. ## +## [Kle87] Peter B. Kleidman +## "The maximal subgroups of the finite 8-dimensional orthogonal groups +## POmega+(8,q) and of their automorphism groups", +## J. Algebra 110, 1987, 173-242. +## ## This implementation uses some algorithms described elsewhere: ## ## [CLG97a] Frank Celler and C.R. Leedham-Green @@ -260,6 +265,64 @@ RECOG.EstimateProjOrder := function(G) return size; end; +# Return true if there is a nonzero w in the fourth exterior power of the +# natural module such that w * g = c(g)^2 * w for all g in , where +# g * F * g^T = c(g) * F. The Cayley 4-form spans such a line for the +# normaliser of Spin(7,q) in its spin representation. +RECOG.FixesFourFormLine := function(gens, F) + local d, field, one, outer, pairs, quads, P2, L, a, b, S, T, J, sgn, + i, j, B, g, c, ext2, ext4, X; + + d := Length(F); + field := DefaultFieldOfMatrix(F); + one := One(field); + outer := {u, v} -> Concatenation(List(u, x -> x * v)); + pairs := Combinations([1 .. d], 2); + quads := Combinations([1 .. d], 4); + + # P2 maps u ⊗ v to u ∧ v + P2 := NullMat(d^2, Length(pairs), field); + for a in [1 .. Length(pairs)] do + P2[(pairs[a][1] - 1) * d + pairs[a][2], a] := one; + P2[(pairs[a][2] - 1) * d + pairs[a][1], a] := -one; + od; + P2 := ImmutableMatrix(field, P2); + + # L maps x ⊗ y in Λ²V ⊗ Λ²V to x ∧ y in Λ⁴V + L := NullMat(Length(pairs)^2, Length(quads), field); + for a in [1 .. Length(pairs)] do + for b in [1 .. Length(pairs)] do + S := pairs[a]; + T := pairs[b]; + if not IsEmpty(Intersection(S, T)) then + continue; + fi; + J := Union(S, T); + sgn := SignPerm(PermList(List(Concatenation(S, T), + x -> Position(J, x)))); + L[(a - 1) * Length(pairs) + b, Position(quads, J)] := sgn * one; + od; + od; + L := ImmutableMatrix(field, L); + + # B spans the common eigenspace of the generators seen so far + i := PositionProperty(F, row -> not IsZero(row)); + j := PositionNonZero(F[i]); + B := IdentityMat(Length(quads), field); + for g in gens do + c := (g * F * TransposedMat(g))[i, j] / F[i, j]; + ext2 := List(pairs, p -> outer(g[p[1]], g[p[2]])) * P2; + ext4 := List(quads, Q -> outer(ext2[Position(pairs, Q{[1, 2]})], + ext2[Position(pairs, Q{[3, 4]})])) * L; + X := NullspaceMat(B * ext4 - c^2 * B); + if IsEmpty(X) then + return false; + fi; + B := X * B; + od; + return true; +end; + # The naming algorithm for classical groups is divided into two # parts: A version that applies to classical groups for sufficiently # large parameters, called generic parameters, as described in [NP98, Def.3.2], @@ -2024,62 +2087,37 @@ function(recognise) recognise.isOmegaContained := false; return NeverApplicable; fi; - elif d = 8 and q = 3 then - if not HasElementsMultipleOf( recognise.orders, [7,13]) then - return TemporaryFailure; - fi; - if RECOG.EstimateProjOrder(grp) mod 4952179814400 = 0 then # compare to Size(POmega(+1,8,3)) - return CheckFlag(); - else - recognise.isOmegaContained := false; - return NeverApplicable; - fi; - elif d = 8 and q = 5 then - ## 2.July.2019: There is a mistake in the paper here - ## There are maximal subgroups of Omega+(8,5) that contain - ## elements of order 7,13,3 - ## 13.Jan.2021: Added 31 - # TODO: This means, in Table 4 of [NP99] the second column of the line "d = - # 8, q = 5" should be "3, 7, 13, 31 + perm.rep" - if not HasElementsMultipleOf( recognise.orders, [3,7,13,31]) then - return TemporaryFailure; - fi; - # Such elements also exist in maximal subgroups of - # Omega+(8,5) with composition factors being C_2 and Omega(0,7,5). - # So we need more work to distinguish them - # - # It turns out that these groups don't contain elements of - # order 312, so if we see one, we are good. - if HasElementsMultipleOf( recognise.orders, [312]) then - return CheckFlag(); + elif d = 8 and (q = 3 or q = 5) then + # For q = 5, the 13 in [NP99, Table 4] stands for a splitting + # lppd(8,5;4)-element (proportion 1/81, see the proof). Elements of + # order 13 also lie in Spin(7,5) and in the maximal subgroups of + # types GU(4,5) and 2.Sz(8); the latter have no elements of order 31. + if q = 3 and not HasElementsMultipleOf(recognise.orders, [7, 13]) then + return TemporaryFailure; + elif q = 5 and + not HasElementsMultipleOf(recognise.orders, [3, 7, 13, 31]) then + return TemporaryFailure; + fi; + + # The maximal subgroups of Omega+(8,q) of order divisible by 7*13 + # (q = 3) or 7*13*31 (q = 5) are two classes of <-1> x Omega(7,q), + # fixing a non-singular point, and their triality images, four + # classes of Spin(7,q) in its spin representation [Kle87, Table I]. + # A proper subgroup of Omega(7,q) of such order lies in G2(3) and + # fixes a unique point. So an irreducible G not containing + # Omega+(8,q) normalises Spin(7,q), hence fixes its Cayley 4-form up + # to scalars, while Omega+(8,q) fixes no line of 4-forms. This test + # replaces the permutation representation of [NP99]. + if recognise.isReducible = "unknown" or + IsEmpty(recognise.ClassicalForms) then + return CheckFlag(); fi; - # We generated 10000 random elements for all groups between - # Omega+(8,5) and Delta+(8, 5). The percentage of elements with orders - # divisible by 3, 7, 13, 31, and 312 respectively were at least: - # 56, 14, 31, 16, 5.71 - # Since elements of order divisible by 312 are relatively rare, we - # don't want to conclude too much from there not being such an - # element among those we generated randomly. - # - # Thus we compute the projective action of grp and then compare - # the size of resulting stabilizer chain to the size of POmega(+1,8,5). - # - # Note: Size(POmega(+1,8,5)) = 8911539000000000000 - - # HACK to avoid info message by orb of the form 'Have 38376 points' - # (in general one shouldn't ignore this kind of warning but here - # we know which groups are input, and it is acceptable) - ol := InfoLevel(InfoOrb); - SetInfoLevel(InfoOrb, 0); - ord := RECOG.EstimateProjOrder(grp); - SetInfoLevel(InfoOrb, ol); - - if ord mod 8911539000000000000 = 0 then - return CheckFlag(); - else - recognise.isOmegaContained := false; - return NeverApplicable; + if RECOG.FixesFourFormLine(GeneratorsOfGroup(grp), + First(recognise.ClassicalForms, isHypForm)!.matrix) then + recognise.isOmegaContained := false; + return NeverApplicable; fi; + return CheckFlag(); elif d = 8 and (q = 4 or q > 5) then if not 6 in recognise.LB then return TemporaryFailure; diff --git a/tst/naming.g b/tst/naming.g index 053f17d9..66e5ef48 100644 --- a/tst/naming.g +++ b/tst/naming.g @@ -68,7 +68,8 @@ end; # type (as in ClassicalMaximalsGeneric) 5 times, and return the number of # subgroups named as the full group. Naming one over a proper subfield is # right: a subfield subgroup contains the classical group over that field. -TestNamingMaximals := function(type, d, q) +# The optional argument is a filter selecting the subgroups to test. +TestNamingMaximals := function(type, d, q, filter...) local flag, fieldsize, failures, maxes, k, M, i, ri; flag := rec(L := "isSLContained", U := "isSUContained", S := "isSpContained", O := "isOmegaContained", @@ -79,6 +80,9 @@ TestNamingMaximals := function(type, d, q) fi; failures := 0; maxes := ValueGlobal("ClassicalMaximalsGeneric")(type, d, q); + if not IsEmpty(filter) then + maxes := Filtered(maxes, filter[1]); + fi; for k in [1..Length(maxes)] do M := maxes[k]; for i in [1..5] do @@ -94,6 +98,20 @@ TestNamingMaximals := function(type, d, q) return failures; end; +# The conformal group CGO^+(d,q), q odd: GO^+(d,q) and a similitude with +# non-square multiplier nu, mapping the form F to nu * F, which is isometric +# to F as d is even. +ConformalOrthogonalPlusGroup := function(d, q) + local G, field, F, nu, B1, B2; + G := GO(+1, d, q); + field := GF(q); + F := InvariantBilinearForm(G).matrix; + nu := PrimitiveRoot(field); + B1 := BaseChangeToCanonical(BilinearFormByMatrix(F, field)); + B2 := BaseChangeToCanonical(BilinearFormByMatrix(nu * F, field)); + return ClosureGroup(G, B2^-1 * B1); +end; + # Some maximal subgroups of the conformal group CGO^+(8,5), which # are particularly tricky for the naming functions diff --git a/tst/working/combined/ClassicalMaximalsNaming.tst b/tst/working/combined/ClassicalMaximalsNaming.tst index 660188ff..e18246a5 100644 --- a/tst/working/combined/ClassicalMaximalsNaming.tst +++ b/tst/working/combined/ClassicalMaximalsNaming.tst @@ -39,6 +39,12 @@ gap> d:=5;; for q in [5, 7, 9] do TestNamingMaximals("O", d, q); od; gap> d:=7;; for q in [3, 5, 7, 9] do TestNamingMaximals("O", d, q); od; gap> d:=6;; for q in [3, 4, 5, 8] do TestNamingMaximals("O+", d, q); od; gap> d:=8;; for q in [2] do TestNamingMaximals("O+", d, q); od; + +# For q = 3, 5 only the subgroups of order |SO(7,q)|, among them Spin(7,q), +# which the 4-form test must reject; the full sweep takes about a minute. +gap> d:=8;; for q in [3, 5] do +> TestNamingMaximals("O+", d, q, M -> Size(M) = Size(SO(d - 1, q))); +> od; gap> d:=4;; for q in [2, 4, 5, 7, 9] do TestNamingMaximals("O-", d, q); od; gap> d:=6;; for q in [2, 4, 5] do TestNamingMaximals("O-", d, q); od; gap> d:=8;; for q in [3] do TestNamingMaximals("O-", d, q); od; diff --git a/tst/working/combined/ClassicalNaturalNaming.tst b/tst/working/combined/ClassicalNaturalNaming.tst index 81a1402c..56da3fa2 100644 --- a/tst/working/combined/ClassicalNaturalNaming.tst +++ b/tst/working/combined/ClassicalNaturalNaming.tst @@ -63,8 +63,8 @@ gap> d:=4;; for q in [2, 3, 4, 5, 7, 8, 9, 11, 13] do TestNaming("GO", +1, d, q) gap> d:=6;; for q in [2, 3, 4, 5, 7, 8, 9, 11, 13] do TestNaming("GO", +1, d, q); od; gap> d:=4;; for q in [2, 3, 4, 5, 7, 8, 9, 11, 13] do TestNaming("Omega", +1, d, q); od; gap> d:=6;; for q in [2, 3, 4, 5, 7, 8, 9, 11, 13] do TestNaming("Omega", +1, d, q); od; -gap> d:=8;; for q in [2, 3, 4] do TestNaming("GO", +1, d, q); od; -gap> d:=8;; for q in [2, 3, 4] do TestNaming("Omega", +1, d, q); od; +gap> d:=8;; for q in [2, 3, 4, 5] do TestNaming("GO", +1, d, q); od; +gap> d:=8;; for q in [2, 3, 4, 5] do TestNaming("Omega", +1, d, q); od; #@fi # diff --git a/tst/working/combined/MoreNaming.tst b/tst/working/combined/MoreNaming.tst index 3010fcee..ce1f1b80 100644 --- a/tst/working/combined/MoreNaming.tst +++ b/tst/working/combined/MoreNaming.tst @@ -819,6 +819,14 @@ false gap> ri.isSpContained; "unknown" +# the conformal groups CGO^+(8,q), and Omega^+(8,q) with all scalars +gap> ForAll([3, 5], q -> RecogniseClassical( +> ConformalOrthogonalPlusGroup(8, q)).isOmegaContained = true); +true +gap> ForAll([3, 5], q -> RecogniseClassical(ClosureGroup(Omega(+1, 8, q), +> Z(q) * One(GL(8, q)))).isOmegaContained = true); +true + # gap> SetInfoLevel(InfoOrb, oldOrbInfoLevel); gap> SetInfoLevel(InfoRecog, oldRecogInfoLevel);