Merge a05a0798ec into f4936dd50a

2024-11-24 16:35:28 +01:00 · 2024-02-18 17:56:25 +01:00 · 2024-02-18 17:56:25 +01:00 · cb6c97a28d
commit cb6c97a28d
parent f4936dd50a a05a0798ec
4 changed files with 289 additions and 164 deletions
--- a/src/certify.jl
+++ b/src/certify.jl
@ -112,7 +112,7 @@ function certify_solution(
        !augmented && StarAlgebras.aug(elt) == StarAlgebras.aug(orderunit) == 0

    Q = should_we_augment ? augment_columns!(Q) : Q
-    @time sos = compute_sos(parent(elt), Q; augmented = augmented)
+    sos = compute_sos(parent(elt), Q; augmented = augmented)

    @info "Checking in $(eltype(sos)) arithmetic with" λ

@ -123,11 +123,9 @@ function certify_solution(
    end

    λ_int = IntervalArithmetic.@interval(λ)
-    Q_int = IntervalMatrices.IntervalMatrix([
-        IntervalArithmetic.@interval(q) for q in Q
-    ])
+    Q_int = IntervalMatrices.IntervalMatrix(IntervalArithmetic.Interval.(Q))

-    check, sos_int = @time if should_we_augment
+    check, sos_int = if should_we_augment
        @info("Projecting columns of Q to the augmentation ideal...")
        Q_int = augment_columns!(Q_int)
        @info "Checking that sum of every column contains 0.0..."
--- a/src/constraint_matrix.jl
+++ b/src/constraint_matrix.jl
@ -156,12 +156,8 @@ function constraints(
    mstr::StarAlgebras.MultiplicativeStructure;
    augmented = false,
 )
-    cnstrs = _constraints(
-        mstr;
-        augmented = augmented,
-        num_constraints = length(basis),
-        id = basis[one(first(basis))],
-    )
+    id = basis[one(first(basis))]
+    cnstrs = _constraints(mstr; augmented = augmented, id = mstr[id, id])

    return Dict(
        basis[i] => ConstraintMatrix(c, size(mstr)..., 1) for
@ -172,11 +168,11 @@ end
 function _constraints(
    mstr::StarAlgebras.MultiplicativeStructure;
    augmented::Bool = false,
-    num_constraints = maximum(mstr),
    id,
 )
-    cnstrs = [signed(eltype(mstr))[] for _ in 1:num_constraints]
+    cnstrs = [signed(eltype(mstr))[] for _ in 1:maximum(mstr)]
    LI = LinearIndices(size(mstr))
+    id_ = mstr[id, id]

    for ci in CartesianIndices(size(mstr))
        k = LI[ci]
@ -185,8 +181,8 @@ function _constraints(
        push!(cnstrs[a_star_b], k)
        if augmented
            # (1-a)'(1-b) = 1 - a' - b + a'b
-            push!(cnstrs[id], k)
-            a_star, b = mstr[-i, id], j
+            push!(cnstrs[id_], k)
+            a_star, b = mstr[-i, id], mstr[j, id]
            push!(cnstrs[a_star], -k)
            push!(cnstrs[b], -k)
        end
--- a/src/gradings.jl
+++ b/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
--- a/test/Chevalley.jl
+++ b/test/Chevalley.jl
@ -8,6 +8,7 @@ function countmap(f, v)
    return counts
 end

+@testset "Chevalley" begin
    @testset "classify_root_system" begin
        α = PropertyT.Roots.Root([1, -1, 0])
        β = PropertyT.Roots.Root([0, 1, -1])
@ -21,7 +22,11 @@ end

    @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
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
+                        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
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
+                        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
-                    γ in Ω if !PropertyT.Roots.isproportional(α, γ)
+                        PropertyT.Roots.classify_sub_root_system(Ω, α, γ)
+                        for γ in Ω if !PropertyT.Roots.isproportional(α, γ)
                    ])
                    @test Set(keys(counts)) == subtypes
                    d, r = divrem(counts[:A₂], 4)
@ -166,3 +176,134 @@ 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