add tests for levels and their symmetrization

src/gradings.jl

@@ -67,13 +67,3 @@ function Sq(rootsystem::AbstractDict)
         init = zero(first(values(rootsystem))),
     )
 end
-
-function level(rootsystem, level::Integer)
-    1 ≤ level ≤ 4 || throw("level is implemented only for i ∈{1,2,3,4}")
-    level == 1 && return Adj(rootsystem, :C₁) # always positive
-    level == 2 && return Adj(rootsystem, :A₁) +
-           Adj(rootsystem, Symbol("C₁×C₁")) +
-           Adj(rootsystem, :C₂) # C₂ is not positive
-    level == 3 && return Adj(rootsystem, :A₂) + Adj(rootsystem, Symbol("A₁×C₁"))
-    level == 4 && return Adj(rootsystem, Symbol("A₁×A₁")) # positive
-end

test/Chevalley.jl

@@ -8,7 +8,8 @@ function countmap(f, v)
     return counts
 end
 
-@testset "classify_root_system" begin
+@testset "Chevalley" begin
+    @testset "classify_root_system" begin
         α = PropertyT.Roots.Root([1, -1, 0])
         β = PropertyT.Roots.Root([0, 1, -1])
         γ = PropertyT.Roots.Root([2, 0, 0])
@@ -17,11 +18,15 @@ end
         @test PropertyT.Roots.classify_root_system(α, γ, (false, true)) == :C₂
         @test PropertyT.Roots.classify_root_system(β, γ, (false, true)) ==
               Symbol("A₁×C₁")
-end
+    end
 
-@testset "Exceptional root systems" begin
+    @testset "Exceptional root systems" begin
         @testset "F4" begin
-        F4 = let Σ = PermutationGroups.PermGroup(perm"(1,2,3,4)", perm"(1,2)")
+            F4 =
+                let Σ = PermutationGroups.PermGroup(
+                        perm"(1,2,3,4)",
+                        perm"(1,2)",
+                    )
                     long = let x = (1, 1, 0, 0) .// 1
                         PropertyT.Roots.Root.(
                             union(
@@ -54,9 +59,11 @@ end
             @test isapprox(PropertyT.Roots.ℓ₂length(b), sqrt(2))
             c = a + b
             @test isapprox(PropertyT.Roots.ℓ₂length(c), 2.0)
-        @test PropertyT.Roots.classify_root_system(b, c, (false, true)) == :C₂
+            @test PropertyT.Roots.classify_root_system(b, c, (false, true)) ==
+                  :C₂
 
-        long = F4[findfirst(r -> PropertyT.Roots.ℓ₂length(r) == sqrt(2), F4)]
+            long =
+                F4[findfirst(r -> PropertyT.Roots.ℓ₂length(r) == sqrt(2), F4)]
             short = F4[findfirst(r -> PropertyT.Roots.ℓ₂length(r) == 1.0, F4)]
 
             subtypes = Set([:C₂, :A₂, Symbol("A₁×C₁")])
@@ -105,11 +112,14 @@ end
                     end
 
                     signs = collect(
-                    p for p in Iterators.product(fill([-1, +1], 8)...) if
+                        p for
+                        p in Iterators.product(fill([-1, +1], 8)...) if
                         iseven(count(==(-1), p))
                     )
                     halfs = let x = (1, 1, 1, 1, 1, 1, 1, 1) .// 2
-                    rts = unique(PropertyT.Roots.Root(x .* sgn) for sgn in signs)
+                        rts = unique(
+                            PropertyT.Roots.Root(x .* sgn) for sgn in signs
+                        )
                     end
 
                     union(long, halfs)
@@ -123,8 +133,8 @@ end
 
                 let Ω = E8, α = first(Ω)
                     counts = countmap([
-                    PropertyT.Roots.classify_sub_root_system(Ω, α, γ) for
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        for γ in Ω if !PropertyT.Roots.isproportional(α, γ)
                     ])
                     @test Set(keys(counts)) == subtypes
                     d, r = divrem(counts[:A₂], 4)
@@ -137,8 +147,8 @@ end
 
                 let Ω = E7, α = first(Ω)
                     counts = countmap([
-                    PropertyT.Roots.classify_sub_root_system(Ω, α, γ) for
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        for γ in Ω if !PropertyT.Roots.isproportional(α, γ)
                     ])
                     @test Set(keys(counts)) == subtypes
                     d, r = divrem(counts[:A₂], 4)
@@ -155,8 +165,8 @@ end
 
                 let Ω = E6, α = first(Ω)
                     counts = countmap([
-                    PropertyT.Roots.classify_sub_root_system(Ω, α, γ) for
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        for γ in Ω if !PropertyT.Roots.isproportional(α, γ)
                     ])
                     @test Set(keys(counts)) == subtypes
                     d, r = divrem(counts[:A₂], 4)
@@ -165,4 +175,135 @@ end
                 end
             end
         end
+    end
+
+    @testset "Levels in Sp2n" begin
+        function level(rootsystem, level::Integer)
+            1 ≤ level ≤ 4 || throw("level is implemented only for i ∈{1,2,3,4}")
+            level == 1 && return PropertyT.Adj(rootsystem, :C₁) # always positive
+            level == 2 && return PropertyT.Adj(rootsystem, :A₁) +
+                   PropertyT.Adj(rootsystem, Symbol("C₁×C₁")) +
+                   PropertyT.Adj(rootsystem, :C₂) # C₂ is not positive
+            level == 3 && return PropertyT.Adj(rootsystem, :A₂) +
+                   PropertyT.Adj(rootsystem, Symbol("A₁×C₁"))
+            level == 4 && return PropertyT.Adj(rootsystem, Symbol("A₁×A₁")) # positive
+        end
+
+        n = 5
+        G = MatrixGroups.SymplecticGroup{2n}(Int8)
+        RG, S, sizes = PropertyT.group_algebra(G; halfradius = 1)
+
+        Weyl = let N = n
+            P = PermGroup(perm"(1,2)", Perm(circshift(1:N, -1)))
+            Groups.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        end
+        act = PropertyT.action_by_conjugation(G, Weyl)
+
+        function ^ᵃ(x, w::Groups.Constructions.WreathProductElement)
+            return SymbolicWedderburn.action(act, w, x)
+        end
+
+        Sₙ = S
+        Δsₙ = PropertyT.laplacians(
+            RG,
+            Sₙ,
+            x -> (gx = PropertyT.grading(x); Set([gx, -gx])),
+        )
+
+        function natural_embedding(i, Sp2m, Sp2n)
+            _dim(::MatrixGroups.ElementarySymplectic{N}) where {N} = N
+            n = _dim(first(alphabet(Sp2n))) ÷ 2
+            m = _dim(first(alphabet(Sp2m))) ÷ 2
+            l = alphabet(Sp2m)[i]
+            i, j = if l.symbol === :A
+                l.i, l.j
+            elseif l.symbol === :B
+                ifelse(l.i ≤ m, (l.i, l.j - m + n), (l.i - m + n, l.j))
+            else
+                throw("unknown type: $(l.symbol)")
+            end
+            image_of_l =
+                MatrixGroups.ElementarySymplectic{2n}(l.symbol, i, j, l.val)
+            return Groups.word_type(Sp2n)([alphabet(Sp2n)[image_of_l]])
+        end
+
+        @testset "Sp4 ↪ Sp12" begin
+            m = 2
+            Sₘ = let m = m, Sp2n = G
+                Sp2m = MatrixGroups.SymplecticGroup{2m}(Int8)
+                h = Groups.Homomorphism(
+                    natural_embedding,
+                    Sp2m,
+                    Sp2n;
+                    check = false,
+                )
+                S = h.(gens(Sp2m))
+                S = union!(S, inv.(S))
+            end
+
+            Δsₘ = PropertyT.laplacians(
+                RG,
+                Sₘ,
+                x -> (gx = PropertyT.grading(x); Set([gx, -gx])),
+            )
+
+            function k(n, m, i)
+                return 2^n * factorial(m) * factorial(n - i) ÷ factorial(m - i)
+            end
+
+            @testset "Level $i" for i in 1:4
+                Levᵢᵐ = level(Δsₘ, i)
+                Levᵢⁿ = level(Δsₙ, i)
+
+                if 1 ≤ i ≤ 2
+                    @test !iszero(Levᵢᵐ)
+                    @time Σ_W_Levᵢᵐ = sum(Levᵢᵐ^ᵃw for w in Weyl)
+
+                    @test isinteger(Σ_W_Levᵢᵐ[one(G)] / Levᵢⁿ[one(G)])
+                    @test Σ_W_Levᵢᵐ[one(G)] / Levᵢⁿ[one(G)] == k(n, m, i)
+                    @test Σ_W_Levᵢᵐ == k(n, m, i) * Levᵢⁿ
+                else
+                    @test iszero(Levᵢᵐ)
+                    @test !iszero(Levᵢⁿ)
+                end
+            end
+        end
+
+        @testset "Sp8 ↪ Sp12" begin
+            m = 4
+            Sₘ = let m = m, Sp2n = G
+                Sp2m = MatrixGroups.SymplecticGroup{2m}(Int8)
+                h = Groups.Homomorphism(
+                    natural_embedding,
+                    Sp2m,
+                    Sp2n;
+                    check = false,
+                )
+                S = h.(gens(Sp2m))
+                S = union!(S, inv.(S))
+            end
+
+            Δsₘ = PropertyT.laplacians(
+                RG,
+                Sₘ,
+                x -> (gx = PropertyT.grading(x); Set([gx, -gx])),
+            )
+
+            function k(n, m, i)
+                return 2^n * factorial(m) * factorial(n - i) ÷ factorial(m - i)
+            end
+
+            @testset "Level $i" for i in 1:4
+                Levᵢᵐ = level(Δsₘ, i)
+                Levᵢⁿ = level(Δsₙ, i)
+
+                @test !iszero(Levᵢᵐ)
+                @time Σ_W_Levᵢᵐ = sum(Levᵢᵐ^ᵃw for w in Weyl)
+
+                @test isinteger(Σ_W_Levᵢᵐ[one(G)] / Levᵢⁿ[one(G)])
+                @test Σ_W_Levᵢᵐ[one(G)] / Levᵢⁿ[one(G)] == k(n, m, i)
+                @test Σ_W_Levᵢᵐ == k(n, m, i) * Levᵢⁿ
+            end
+        end
+    end
 end