Merge pull request #13 from kalmarek/mk/update_PermutationGroups_etal

update permutation groups etal

Project.toml

@@ -1,29 +1,35 @@
 name = "PropertyT"
 uuid = "03b72c93-0167-51e2-8a1e-eb4ff1fb940d"
 authors = ["Marek Kaluba <kalmar@amu.edu.pl>"]
-version = "0.5.0"
+version = "0.6.0"
 
 [deps]
 Groups = "5d8bd718-bd84-11e8-3b40-ad14f4a32557"
+GroupsCore = "d5909c97-4eac-4ecc-a3dc-fdd0858a4120"
 IntervalArithmetic = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253"
 IntervalMatrices = "5c1f47dc-42dd-5697-8aaa-4d102d140ba9"
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+PermutationGroups = "8bc5a954-2dfc-11e9-10e6-cd969bffa420"
 ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+StarAlgebras = "0c0c59c1-dc5f-42e9-9a8b-b5dc384a6cd1"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 SymbolicWedderburn = "858aa9a9-4c7c-4c62-b466-2421203962a2"
 
 [compat]
 COSMO = "0.8"
-Groups = "0.7"
+Groups = "0.8"
+GroupsCore = "0.5"
 IntervalArithmetic = "0.20"
-IntervalMatrices = "0.8"
-JuMP = "1.3"
+IntervalMatrices = "0.10"
+JuMP = ">=1.3"
+PermutationGroups = "0.6.2"
 ProgressMeter = "1.7"
-SCS = "1.1"
+SCS = "2"
+StarAlgebras = "0.2.1"
 StaticArrays = "1"
-SymbolicWedderburn = "0.3.4"
+SymbolicWedderburn = "0.4"
 julia = "1.6"
 
 [extras]

src/PropertyT.jl

@@ -6,10 +6,10 @@ using SparseArrays
 using JuMP
 
 using Groups
-import Groups.GroupsCore
-using SymbolicWedderburn
-import SymbolicWedderburn.StarAlgebras
-import SymbolicWedderburn.PermutationGroups
+import GroupsCore
+import PermutationGroups as PG
+import SymbolicWedderburn as SW
+import StarAlgebras as SA
 
 include("constraint_matrix.jl")
 include("sos_sdps.jl")
@@ -31,9 +31,9 @@ function group_algebra(G::Groups.Group, S = gens(G); halfradius::Integer)
     @time E, sizes = Groups.wlmetric_ball(S; radius = 2halfradius)
     @info "sizes = $(sizes)"
     @info "computing the *-algebra structure for G"
-    @time RG = StarAlgebras.StarAlgebra(
+    @time RG = SA.StarAlgebra(
         G,
-        StarAlgebras.Basis{UInt32}(E),
+        SA.Basis{UInt32}(E),
         (sizes[halfradius], sizes[halfradius]);
         precompute = false,
     )

src/actions/actions.jl

@@ -1,29 +1,24 @@
-import SymbolicWedderburn.action
-
 include("alphabet_permutation.jl")
 
 include("sln_conjugation.jl")
 include("spn_conjugation.jl")
 include("autfn_conjugation.jl")
 
-function SymbolicWedderburn.action(
-    act::SymbolicWedderburn.ByPermutations,
+function SW.action(
+    act::SW.ByPermutations,
     g::Groups.GroupElement,
-    α::StarAlgebras.AlgebraElement,
+    α::SA.AlgebraElement,
 )
-    res = StarAlgebras.zero!(similar(α))
-    B = basis(parent(α))
-    for (idx, val) in StarAlgebras._nzpairs(StarAlgebras.coeffs(α))
+    res = SA.zero!(similar(α))
+    B = SA.basis(parent(α))
+    for (idx, val) in SA._nzpairs(SA.coeffs(α))
         a = B[idx]
-        a_g = SymbolicWedderburn.action(act, g, a)
+        a_g = SW.action(act, g, a)
         res[a_g] += val
     end
     return res
 end
 
-function Base.:^(
-    w::W,
-    p::PermutationGroups.AbstractPerm,
-) where {W<:Groups.AbstractWord}
+function Base.:^(w::W, p::PG.AbstractPermutation) where {W<:Groups.AbstractWord}
     return W([l^p for l in w])
 end

src/actions/alphabet_permutation.jl

@@ -2,43 +2,37 @@
 
 import Groups: Constructions
 
-struct AlphabetPermutation{GEl,I} <: SymbolicWedderburn.ByPermutations
-    perms::Dict{GEl,PermutationGroups.Perm{I}}
+struct AlphabetPermutation{GEl,I} <: SW.ByPermutations
+    perms::Dict{GEl,PG.Perm{I}}
 end
 
 function AlphabetPermutation(
     A::Alphabet,
-    Γ::PermutationGroups.AbstractPermutationGroup,
+    Γ::PG.AbstractPermutationGroup,
     op,
 )
     return AlphabetPermutation(
-        Dict(γ => inv(PermutationGroups.Perm([A[op(l, γ)] for l in A])) for γ in Γ),
+        Dict(γ => inv(PG.Perm([A[op(l, γ)] for l in A])) for γ in Γ),
     )
 end
 
 function AlphabetPermutation(A::Alphabet, W::Constructions.WreathProduct, op)
     return AlphabetPermutation(
         Dict(
-            w => inv(PermutationGroups.Perm([A[op(op(l, w.p), w.n)] for l in A])) for
+            w => inv(PG.Perm([A[op(op(l, w.p), w.n)] for l in A])) for
             w in W
         ),
     )
 end
 
-function SymbolicWedderburn.action(
+function SW.action(
     act::AlphabetPermutation,
     γ::Groups.GroupElement,
     g::Groups.AbstractFPGroupElement,
 )
     G = parent(g)
-    w = SymbolicWedderburn.action(act, γ, word(g))
+    # w = SW.action(act, γ, word(g))
+    w = word(g)^(act.perms[γ])
     return G(w)
 end
 
-function SymbolicWedderburn.action(
-    act::AlphabetPermutation,
-    γ::Groups.GroupElement,
-    w::Groups.AbstractWord,
-)
-    return w^(act.perms[γ])
-end

src/actions/autfn_conjugation.jl

@@ -2,7 +2,7 @@
 
 function _conj(
     t::Groups.Transvection,
-    σ::PermutationGroups.AbstractPerm,
+    σ::PG.AbstractPermutation,
 )
     return Groups.Transvection(t.id, t.i^inv(σ), t.j^inv(σ), t.inv)
 end
@@ -22,5 +22,9 @@ function _conj(
     return _flip(t, x.elts[i])
 end
 
-action_by_conjugation(sautfn::Groups.AutomorphismGroup{<:Groups.FreeGroup}, Σ::Groups.Group) =
-    AlphabetPermutation(alphabet(sautfn), Σ, _conj)
+function action_by_conjugation(
+    sautfn::Groups.AutomorphismGroup{<:Groups.FreeGroup},
+    Σ::Groups.Group,
+)
+    return AlphabetPermutation(alphabet(sautfn), Σ, _conj)
+end

src/actions/sln_conjugation.jl

@@ -2,7 +2,7 @@
 
 function _conj(
     t::MatrixGroups.ElementaryMatrix{N},
-    σ::PermutationGroups.AbstractPerm,
+    σ::PG.AbstractPermutation,
 ) where {N}
     return MatrixGroups.ElementaryMatrix{N}(t.i^inv(σ), t.j^inv(σ), t.val)
 end
@@ -16,5 +16,9 @@ function _conj(
     return ifelse(just_one_flips, inv(t), t)
 end
 
-action_by_conjugation(sln::Groups.MatrixGroups.SpecialLinearGroup, Σ::Groups.Group) =
-    AlphabetPermutation(alphabet(sln), Σ, _conj)
+function action_by_conjugation(
+    sln::Groups.MatrixGroups.SpecialLinearGroup,
+    Σ::Groups.Group,
+)
+    return AlphabetPermutation(alphabet(sln), Σ, _conj)
+end

src/actions/spn_conjugation.jl

@@ -2,10 +2,10 @@
 
 function _conj(
     s::MatrixGroups.ElementarySymplectic{N,T},
-    σ::PermutationGroups.AbstractPerm,
+    σ::PG.AbstractPermutation,
 ) where {N,T}
     @assert iseven(N)
-    @assert PermutationGroups.degree(σ) == N ÷ 2 "Got degree = $(PermutationGroups.degree(σ)); N = $N"
+    @assert PG.degree(σ) ≤ N ÷ 2 "Got degree = $(PG.degree(σ)); N = $N"
     n = N ÷ 2
     @assert 1 ≤ s.i ≤ N
     @assert 1 ≤ s.j ≤ N
@@ -40,5 +40,9 @@ function _conj(
     return ifelse(just_one_flips, inv(s), s)
 end
 
-action_by_conjugation(sln::Groups.MatrixGroups.SymplecticGroup, Σ::Groups.Group) =
-    AlphabetPermutation(alphabet(sln), Σ, _conj)
+function action_by_conjugation(
+    sln::Groups.MatrixGroups.SymplecticGroup,
+    Σ::Groups.Group,
+)
+    return AlphabetPermutation(alphabet(sln), Σ, _conj)
+end

src/certify.jl

@@ -9,16 +9,16 @@ function augment_columns!(Q::AbstractMatrix)
 end
 
 function __sos_via_sqr!(
-    res::StarAlgebras.AlgebraElement,
+    res::SA.AlgebraElement,
     P::AbstractMatrix;
     augmented::Bool,
-    id = (b = basis(parent(res)); b[one(first(b))]),
+    id = (b = SA.basis(parent(res)); b[one(first(b))]),
 )
     A = parent(res)
     mstr = A.mstructure
     @assert size(mstr) == size(P)
 
-    StarAlgebras.zero!(res)
+    SA.zero!(res)
     for j in axes(mstr, 2)
         for i in axes(mstr, 1)
             p = P[i, j]
@@ -39,11 +39,11 @@ function __sos_via_sqr!(
 end
 
 function __sos_via_cnstr!(
-    res::StarAlgebras.AlgebraElement,
+    res::SA.AlgebraElement,
     Q²::AbstractMatrix,
     cnstrs,
 )
-    StarAlgebras.zero!(res)
+    SA.zero!(res)
     for (g, A_g) in cnstrs
         res[g] = dot(A_g, Q²)
     end
@@ -51,17 +51,17 @@ function __sos_via_cnstr!(
 end
 
 function compute_sos(
-    A::StarAlgebras.StarAlgebra,
+    A::SA.StarAlgebra,
     Q::AbstractMatrix;
     augmented::Bool,
 )
     Q² = Q' * Q
-    res = StarAlgebras.AlgebraElement(zeros(eltype(Q²), length(basis(A))), A)
+    res = SA.AlgebraElement(zeros(eltype(Q²), length(SA.basis(A))), A)
     res = __sos_via_sqr!(res, Q²; augmented = augmented)
     return res
 end
 
-function sufficient_λ(residual::StarAlgebras.AlgebraElement, λ; halfradius)
+function sufficient_λ(residual::SA.AlgebraElement, λ; halfradius)
     L1_norm = norm(residual, 1)
     suff_λ = λ - 2.0^(2ceil(log2(halfradius))) * L1_norm
 
@@ -77,8 +77,10 @@ function sufficient_λ(residual::StarAlgebras.AlgebraElement, λ; halfradius)
 
     info_strs = [
         "Numerical metrics of the obtained SOS:",
-        "ɛ(elt - λu - ∑ξᵢ*ξᵢ) $eq_sign $(StarAlgebras.aug(residual))",
-        "‖elt - λu - ∑ξᵢ*ξᵢ‖₁ $eq_sign $(L1_norm)",
+        "ɛ(elt - λu - ∑ξᵢ*ξᵢ) $eq_sign " *
+        sprint(show, SA.aug(residual); context = :compact => true),
+        "‖elt - λu - ∑ξᵢ*ξᵢ‖₁ $eq_sign " *
+        sprint(show, L1_norm; context = :compact => true),
         " λ $eq_sign $suff_λ",
     ]
     @info join(info_strs, "\n")
@@ -87,10 +89,10 @@ function sufficient_λ(residual::StarAlgebras.AlgebraElement, λ; halfradius)
 end
 
 function sufficient_λ(
-    elt::StarAlgebras.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement,
+    elt::SA.AlgebraElement,
+    order_unit::SA.AlgebraElement,
     λ,
-    sos::StarAlgebras.AlgebraElement;
+    sos::SA.AlgebraElement;
     halfradius,
 )
     @assert parent(elt) === parent(order_unit) == parent(sos)
@@ -100,16 +102,15 @@ function sufficient_λ(
 end
 
 function certify_solution(
-    elt::StarAlgebras.AlgebraElement,
-    orderunit::StarAlgebras.AlgebraElement,
+    elt::SA.AlgebraElement,
+    orderunit::SA.AlgebraElement,
     λ,
     Q::AbstractMatrix{<:AbstractFloat};
     halfradius,
-    augmented = iszero(StarAlgebras.aug(elt)) &&
-        iszero(StarAlgebras.aug(orderunit)),
+    augmented = iszero(SA.aug(elt)) && iszero(SA.aug(orderunit)),
 )
     should_we_augment =
-        !augmented && StarAlgebras.aug(elt) == StarAlgebras.aug(orderunit) == 0
+        !augmented && SA.aug(elt) == SA.aug(orderunit) == 0
 
     Q = should_we_augment ? augment_columns!(Q) : Q
     @time sos = compute_sos(parent(elt), Q; augmented = augmented)
@@ -122,10 +123,8 @@ function certify_solution(
         return false, λ_flpoint
     end
 
-    λ_int = IntervalArithmetic.@interval(λ)
-    Q_int = IntervalMatrices.IntervalMatrix([
-        IntervalArithmetic.@interval(q) for q in Q
-    ])
+    λ_int = IntervalArithmetic.interval(λ)
+    Q_int = IntervalMatrices.IntervalMatrix(IntervalArithmetic.interval.(Q))
 
     check, sos_int = @time if should_we_augment
         @info("Projecting columns of Q to the augmentation ideal...")

src/constraint_matrix.jl

@@ -147,13 +147,13 @@ function LinearAlgebra.dot(cm::ConstraintMatrix, m::AbstractMatrix{T}) where {T}
     return convert(eltype(cm), cm.val) * (pos - neg)
 end
 
-function constraints(A::StarAlgebras.StarAlgebra; augmented::Bool)
-    return constraints(basis(A), A.mstructure; augmented = augmented)
+function constraints(A::SA.StarAlgebra; augmented::Bool)
+    return constraints(SA.basis(A), A.mstructure; augmented = augmented)
 end
 
 function constraints(
-    basis::StarAlgebras.AbstractBasis,
-    mstr::StarAlgebras.MultiplicativeStructure;
+    basis::SA.AbstractBasis,
+    mstr::SA.MultiplicativeStructure;
     augmented = false,
 )
     cnstrs = _constraints(
@@ -170,7 +170,7 @@ function constraints(
 end
 
 function _constraints(
-    mstr::StarAlgebras.MultiplicativeStructure;
+    mstr::SA.MultiplicativeStructure;
     augmented::Bool = false,
     num_constraints = maximum(mstr),
     id,

src/gradings.jl

@@ -37,7 +37,7 @@ function _groupby(keys::AbstractVector{K}, vals::AbstractVector{V}) where {K,V}
     return d
 end
 
-function laplacians(RG::StarAlgebras.StarAlgebra, S, grading)
+function laplacians(RG::SA.StarAlgebra, S, grading)
     d = _groupby(grading, S)
     Δs = Dict(α => RG(length(Sα)) - sum(RG(s) for s in Sα) for (α, Sα) in d)
     return Δs

src/reconstruct.jl

@@ -1,16 +1,18 @@
-__outer_dim(wd::WedderburnDecomposition) = size(first(direct_summands(wd)), 2)
+function __outer_dim(wd::SW.WedderburnDecomposition)
+    return size(first(SW.direct_summands(wd)), 2)
+end
 
-function __group_of(wd::WedderburnDecomposition)
+function __group_of(wd::SW.WedderburnDecomposition)
     # this is veeeery hacky... ;)
     return parent(first(keys(wd.hom.cache)))
 end
 
 function reconstruct(
     Ms::AbstractVector{<:AbstractMatrix},
-    wbdec::WedderburnDecomposition,
+    wbdec::SW.WedderburnDecomposition,
 )
     n = __outer_dim(wbdec)
-    res = sum(zip(Ms, SymbolicWedderburn.direct_summands(wbdec))) do (M, ds)
+    res = sum(zip(Ms, SW.direct_summands(wbdec))) do (M, ds)
         res = similar(M, n, n)
         res = _reconstruct!(res, M, ds)
         return res
@@ -22,12 +24,12 @@ end
 function _reconstruct!(
     res::AbstractMatrix,
     M::AbstractMatrix,
-    ds::SymbolicWedderburn.DirectSummand,
+    ds::SW.DirectSummand,
 )
     res .= zero(eltype(res))
     if !iszero(M)
-        U = SymbolicWedderburn.image_basis(ds)
-        d = SymbolicWedderburn.degree(ds)
+        U = SW.image_basis(ds)
+        d = SW.degree(ds)
         res = (U' * M * U) .* d
     end
     return res
@@ -47,15 +49,15 @@ function average!(
     res::AbstractMatrix,
     M::AbstractMatrix,
     G::Groups.Group,
-    hom::SymbolicWedderburn.InducedActionHomomorphism{
-        <:SymbolicWedderburn.ByPermutations,
+    hom::SW.InducedActionHomomorphism{
+        <:SW.ByPermutations,
     },
 )
     res .= zero(eltype(res))
     @assert size(M) == size(res)
     o = Groups.order(Int, G)
     for g in G
-        p = SymbolicWedderburn.induce(hom, g)
+        p = SW.induce(hom, g)
         Threads.@threads for c in axes(res, 2)
             for r in axes(res, 1)
                 if !iszero(M[r, c])

src/sos_sdps.jl

@@ -5,8 +5,8 @@ Formulate the dual to the sum of squares decomposition problem for `X - λ·u`.
 See also [sos_problem_primal](@ref).
 """
 function sos_problem_dual(
-    elt::StarAlgebras.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement = zero(elt);
+    elt::SA.AlgebraElement,
+    order_unit::SA.AlgebraElement = zero(elt);
     lower_bound = -Inf,
 )
     @assert parent(elt) == parent(order_unit)
@@ -20,7 +20,7 @@ function sos_problem_dual(
     # Symmetrized:
     # 1 dual variable for every orbit of G acting on basis
     model = Model()
-    JuMP.@variable(model, y[1:length(basis(algebra))])
+    JuMP.@variable(model, y[1:length(SA.basis(algebra))])
     JuMP.@constraint(model, λ_dual, dot(order_unit, y) == 1)
     JuMP.@constraint(model, psd, y[moment_matrix] in PSDCone())
 
@@ -54,11 +54,10 @@ be added to the model. This may improve the accuracy of the solution if
 The default `u = zero(X)` formulates a simple feasibility problem.
 """
 function sos_problem_primal(
-    elt::StarAlgebras.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement = zero(elt);
+    elt::SA.AlgebraElement,
+    order_unit::SA.AlgebraElement = zero(elt);
     upper_bound = Inf,
-    augmented::Bool = iszero(StarAlgebras.aug(elt)) &&
-                      iszero(StarAlgebras.aug(order_unit)),
+    augmented::Bool = iszero(SA.aug(elt)) && iszero(SA.aug(order_unit)),
 )
     @assert parent(elt) === parent(order_unit)
 
@@ -80,11 +79,11 @@ function sos_problem_primal(
         end
         JuMP.@objective(model, Max, λ)
 
-        for b in basis(parent(elt))
+        for b in SA.basis(parent(elt))
             JuMP.@constraint(model, elt(b) - λ * order_unit(b) == dot(A[b], P))
         end
     else
-        for b in basis(parent(elt))
+        for b in SA.basis(parent(elt))
             JuMP.@constraint(model, elt(b) == dot(A[b], P))
         end
     end
@@ -94,7 +93,7 @@ end
 
 function invariant_constraint!(
     result::AbstractMatrix,
-    basis::StarAlgebras.AbstractBasis,
+    basis::SA.AbstractBasis,
     cnstrs::AbstractDict{K,<:ConstraintMatrix},
     invariant_vec::SparseVector,
 ) where {K}
@@ -128,14 +127,14 @@ function invariant_constraint(basis, cnstrs, invariant_vec)
     return sparse(I, J, V, size(_M)...)
 end
 
-function isorth_projection(ds::SymbolicWedderburn.DirectSummand)
-    U = SymbolicWedderburn.image_basis(ds)
+function isorth_projection(ds::SW.DirectSummand)
+    U = SW.image_basis(ds)
     return isapprox(U * U', I)
 end
 
 function sos_problem_primal(
-    elt::StarAlgebras.AlgebraElement,
-    wedderburn::WedderburnDecomposition;
+    elt::SA.AlgebraElement,
+    wedderburn::SW.WedderburnDecomposition;
     kwargs...,
 )
     return sos_problem_primal(elt, zero(elt), wedderburn; kwargs...)
@@ -176,31 +175,30 @@ import ProgressMeter
 __show_itrs(n, total) = () -> [(Symbol("constraint"), "$n/$total")]
 
 function sos_problem_primal(
-    elt::StarAlgebras.AlgebraElement,
-    orderunit::StarAlgebras.AlgebraElement,
-    wedderburn::WedderburnDecomposition;
+    elt::SA.AlgebraElement,
+    orderunit::SA.AlgebraElement,
+    wedderburn::SW.WedderburnDecomposition;
     upper_bound = Inf,
-    augmented = iszero(StarAlgebras.aug(elt)) &&
-        iszero(StarAlgebras.aug(orderunit)),
+    augmented = iszero(SA.aug(elt)) && iszero(SA.aug(orderunit)),
     check_orthogonality = true,
     show_progress = false,
 )
     @assert parent(elt) === parent(orderunit)
     if check_orthogonality
-        if any(!isorth_projection, direct_summands(wedderburn))
+        if any(!isorth_projection, SW.direct_summands(wedderburn))
             error(
                 "Wedderburn decomposition contains a non-orthogonal projection",
             )
         end
     end
 
-    id_one = findfirst(invariant_vectors(wedderburn)) do v
-        b = basis(parent(elt))
+    id_one = findfirst(SW.invariant_vectors(wedderburn)) do v
+        b = SA.basis(parent(elt))
         return sparsevec([b[one(first(b))]], [1 // 1], length(v)) == v
     end
 
     prog = ProgressMeter.Progress(
-        length(invariant_vectors(wedderburn));
+        length(SW.invariant_vectors(wedderburn));
         dt = 1,
         desc = "Adding constraints: ",
         enabled = show_progress,
@@ -225,7 +223,7 @@ function sos_problem_primal(
     end
 
     # semidefinite constraints as described by wedderburn
-    Ps = map(direct_summands(wedderburn)) do ds
+    Ps = map(SW.direct_summands(wedderburn)) do ds
         dim = size(ds, 1)
         P = JuMP.@variable(model, [1:dim, 1:dim], Symmetric)
         JuMP.@constraint(model, P in PSDCone())
@@ -238,14 +236,14 @@ function sos_problem_primal(
         _eps = 10 * eps(T) * max(size(parent(elt).mstructure)...)
     end
 
-    X = StarAlgebras.coeffs(elt)
-    U = StarAlgebras.coeffs(orderunit)
+    X = SA.coeffs(elt)
+    U = SA.coeffs(orderunit)
 
     # defining constraints based on the multiplicative structure
     cnstrs = constraints(parent(elt); augmented = augmented)
 
     # adding linear constraints: one per orbit
-    for (i, iv) in enumerate(invariant_vectors(wedderburn))
+    for (i, iv) in enumerate(SW.invariant_vectors(wedderburn))
         ProgressMeter.next!(prog; showvalues = __show_itrs(i, prog.n))
         augmented && i == id_one && continue
         # i == 500 && break
@@ -253,9 +251,9 @@ function sos_problem_primal(
         x = dot(X, iv)
         u = dot(U, iv)
 
-        spM_orb = invariant_constraint(basis(parent(elt)), cnstrs, iv)
+        spM_orb = invariant_constraint(SA.basis(parent(elt)), cnstrs, iv)
 
-        Ms = SymbolicWedderburn.diagonalize!(
+        Ms = SW.diagonalize!(
             Ms,
             spM_orb,
             wedderburn;

src/sqadjop.jl

@@ -1,30 +1,40 @@
-import SymbolicWedderburn.PermutationGroups.AbstractPerm
-
 # move to Groups
 Base.keys(a::Alphabet) = keys(1:length(a))
 
 ## the old 1812.03456 definitions
 
-isopposite(σ::AbstractPerm, τ::AbstractPerm, i=1, j=2) =
-    i^σ ≠ i^τ && i^σ ≠ j^τ && j^σ ≠ i^τ && j^σ ≠ j^τ
+function isopposite(
+    σ::PG.AbstractPermutation,
+    τ::PG.AbstractPermutation,
+    i = 1,
+    j = 2,
+)
+    return i^σ ≠ i^τ && i^σ ≠ j^τ && j^σ ≠ i^τ && j^σ ≠ j^τ
+end
 
-isadjacent(σ::AbstractPerm, τ::AbstractPerm, i=1, j=2) =
-    (i^σ == i^τ && j^σ ≠ j^τ) || # first equal, second differ
-    (j^σ == j^τ && i^σ ≠ i^τ) || # second equal, first differ
-    (i^σ == j^τ && j^σ ≠ i^τ) || # first σ equal to second τ
-    (j^σ == i^τ && i^σ ≠ j^τ)    # second σ equal to first τ
+function isadjacent(
+    σ::PG.AbstractPermutation,
+    τ::PG.AbstractPermutation,
+    i = 1,
+    j = 2,
+)
+    return (i^σ == i^τ && j^σ ≠ j^τ) || # first equal, second differ
+           (j^σ == j^τ && i^σ ≠ i^τ) || # second equal, first differ
+           (i^σ == j^τ && j^σ ≠ i^τ) || # first σ equal to second τ
+           (j^σ == i^τ && i^σ ≠ j^τ)    # second σ equal to first τ
+end
 
 function _ncycle(start, length, n=start + length - 1)
-    p = PermutationGroups.Perm(Int8(n))
+    p = Vector{UInt8}(1:n)
     @assert n ≥ start + length - 1
     for k in start:start+length-2
         p[k] = k + 1
     end
     p[start+length-1] = start
-    return p
+    return PG.Perm(p)
 end
 
-alternating_group(n::Integer) = PermutationGroups.PermGroup([_ncycle(i, 3) for i in 1:n-2])
+alternating_group(n::Integer) = PG.PermGroup([_ncycle(i, 3) for i in 1:n-2])
 
 function small_gens(G::MatrixGroups.SpecialLinearGroup)
     A = alphabet(G)
@@ -46,31 +56,31 @@ function small_gens(G::Groups.AutomorphismGroup{<:FreeGroup})
     return union!(S, inv.(S))
 end
 
-function small_laplacian(RG::StarAlgebras.StarAlgebra)
-    G = StarAlgebras.object(RG)
+function small_laplacian(RG::SA.StarAlgebra)
+    G = SA.object(RG)
     S₂ = small_gens(G)
     return length(S₂) * one(RG) - sum(RG(s) for s in S₂)
 end
 
-function SqAdjOp(A::StarAlgebras.StarAlgebra, n::Integer, Δ₂=small_laplacian(A))
+function SqAdjOp(A::SA.StarAlgebra, n::Integer, Δ₂ = small_laplacian(A))
     @assert parent(Δ₂) === A
 
     alt_n = alternating_group(n)
-    G = StarAlgebras.object(A)
+    G = SA.object(A)
     act = action_by_conjugation(G, alt_n)
 
-    Δ₂s = Dict(σ => SymbolicWedderburn.action(act, σ, Δ₂) for σ in alt_n)
+    Δ₂s = Dict(σ => SW.action(act, σ, Δ₂) for σ in alt_n)
 
     sq, adj, op = zero(A), zero(A), zero(A)
     tmp = zero(A)
 
     for σ in alt_n
-        StarAlgebras.add!(sq, sq, StarAlgebras.mul!(tmp, Δ₂s[σ], Δ₂s[σ]))
+        SA.add!(sq, sq, SA.mul!(tmp, Δ₂s[σ], Δ₂s[σ]))
         for τ in alt_n
             if isopposite(σ, τ)
-                StarAlgebras.add!(op, op, StarAlgebras.mul!(tmp, Δ₂s[σ], Δ₂s[τ]))
+                SA.add!(op, op, SA.mul!(tmp, Δ₂s[σ], Δ₂s[τ]))
             elseif isadjacent(σ, τ)
-                StarAlgebras.add!(adj, adj, StarAlgebras.mul!(tmp, Δ₂s[σ], Δ₂s[τ]))
+                SA.add!(adj, adj, SA.mul!(tmp, Δ₂s[σ], Δ₂s[τ]))
             end
         end
     end

test/1703.09680.jl

@@ -20,12 +20,12 @@
             optimizer = scs_optimizer(;
                 eps = 1e-10,
                 max_iters = 5_000,
-                accel = 50,
+                accel = -50,
                 alpha = 1.9,
             ),
         )
 
-        @test status == JuMP.ALMOST_OPTIMAL
+        @test status == JuMP.OPTIMAL
         @test !certified
         @test λ < 0
     end
@@ -33,7 +33,7 @@
     @testset "SL(3,F₅)" begin
         N = 3
         G = MatrixGroups.SpecialLinearGroup{N}(
-            SymbolicWedderburn.Characters.FiniteFields.GF{5},
+            SW.Characters.FiniteFields.GF{5},
         )
         RG, S, sizes = PropertyT.group_algebra(G; halfradius = 2)
 
@@ -53,7 +53,7 @@
             optimizer = scs_optimizer(;
                 eps = 1e-10,
                 max_iters = 5_000,
-                accel = 50,
+                accel = -50,
                 alpha = 1.9,
             ),
         )
@@ -65,15 +65,16 @@
         m = PropertyT.sos_problem_dual(elt, unit)
         PropertyT.solve(
             m,
-            cosmo_optimizer(;
-                eps = 1e-6,
+            scs_optimizer(;
+                eps = 1e-3,
                 max_iters = 5_000,
-                accel = 50,
+                accel = -50,
                 alpha = 1.9,
             ),
         )
 
-        @test JuMP.termination_status(m) in (JuMP.ALMOST_OPTIMAL, JuMP.OPTIMAL)
+        @test JuMP.termination_status(m) in
+              (JuMP.ITERATION_LIMIT, JuMP.ALMOST_OPTIMAL, JuMP.OPTIMAL)
         @test JuMP.objective_value(m) ≈ 1.5 atol = 1e-2
     end
 
@@ -98,12 +99,12 @@
             optimizer = scs_optimizer(;
                 eps = 1e-10,
                 max_iters = 5_000,
-                accel = 50,
+                accel = -50,
                 alpha = 1.9,
             ),
         )
 
-        @test status == JuMP.ALMOST_OPTIMAL
+        @test status in (JuMP.ALMOST_OPTIMAL, JuMP.ITERATION_LIMIT)
         @test λ < 0
         @test !certified
 
@@ -111,14 +112,14 @@
 
         status, _ = PropertyT.solve(
             sos_problem,
-            cosmo_optimizer(;
+            scs_optimizer(;
                 eps = 1e-7,
-                max_iters = 10_000,
-                accel = 0,
+                max_iters = 5_000,
+                accel = -50,
                 alpha = 1.9,
             ),
         )
-        @test status == JuMP.OPTIMAL
+        @test status in (JuMP.OPTIMAL, JuMP.ITERATION_LIMIT)
         P = JuMP.value.(sos_problem[:P])
         Q = real.(sqrt(P))
         certified, λ_cert =
@@ -149,11 +150,11 @@
 
             status, _ = PropertyT.solve(
                 opt_problem,
-                cosmo_optimizer(;
+                scs_optimizer(;
                     eps = 1e-10,
                     max_iters = 10_000,
-                    accel = 0,
-                    alpha = 1.5,
+                    accel = 50,
+                    alpha = 1.9,
                 ),
             )
 
@@ -173,7 +174,11 @@
             )
 
             @test certified
-            @test isapprox(λ_cert, λ, rtol = 1e-5)
+            @test isapprox(
+                PropertyT.IntervalArithmetic.inf(λ_cert),
+                λ,
+                rtol = 1e-5,
+            )
         end
 
         @testset "augmented formulation" begin
@@ -213,7 +218,11 @@
             )
 
             @test certified
-            @test isapprox(λ_cert, λ, rtol = 1e-5)
+            @test isapprox(
+                PropertyT.IntervalArithmetic.inf(λ_cert),
+                λ,
+                rtol = 1e-5,
+            )
             @test λ_cert > 2 // 10
         end
     end

test/1712.07167.jl

@@ -5,15 +5,15 @@
         @info "running tests for" G
         RG, S, sizes = PropertyT.group_algebra(G; halfradius = 2)
 
-        P = PermGroup(perm"(1,2)", Perm(circshift(1:N, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
+        Σ = Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         act = PropertyT.action_by_conjugation(G, Σ)
-        wd = WedderburnDecomposition(
+        wd = SW.WedderburnDecomposition(
             Float64,
             Σ,
             act,
-            basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            SA.basis(RG),
+            SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[2]]),
         )
         @info wd
 
@@ -54,15 +54,18 @@
         Δ = RSL(length(S)) - sum(RSL(s) for s in S)
 
         @testset "Wedderburn formulation" begin
-            P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+            Σ = Groups.Constructions.WreathProduct(
+                PG.PermGroup(PG.perm"(1,2)"),
+                P,
+            )
             act = PropertyT.action_by_conjugation(SL, Σ)
-            wd = WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Rational{Int},
                 Σ,
                 act,
-                basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.basis(RSL),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
             @info wd
 
@@ -78,12 +81,12 @@
                 augmented = false,
             )
 
-            wdfl = SymbolicWedderburn.WedderburnDecomposition(
+            wdfl = SW.WedderburnDecomposition(
                 Float64,
                 Σ,
                 act,
-                basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.basis(RSL),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
 
             model, varP = PropertyT.sos_problem_primal(
@@ -147,16 +150,19 @@
             unit = Δ
             ub = Inf
 
-            P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+            Σ = Groups.Constructions.WreathProduct(
+                PG.PermGroup(PG.perm"(1,2)"),
+                P,
+            )
             act = PropertyT.action_by_conjugation(SL, Σ)
 
-            wdfl = SymbolicWedderburn.WedderburnDecomposition(
+            wdfl = SW.WedderburnDecomposition(
                 Float64,
                 Σ,
                 act,
-                basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.basis(RSL),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
             @info wdfl
 
@@ -170,10 +176,10 @@
 
             status, _ = PropertyT.solve(
                 opt_problem,
-                scs_optimizer(;
+                cosmo_optimizer(;
                     eps = 1e-8,
                     max_iters = 20_000,
-                    accel = 0,
+                    accel = 50,
                     alpha = 1.9,
                 ),
             )

test/1812.03456.jl

@@ -8,11 +8,11 @@ using SparseArrays
     end
 
     @testset "unit tests" begin
-        @test PropertyT.isopposite(perm"(1,2,3)(4)", perm"(1,4,2)")
-        @test PropertyT.isadjacent(perm"(1,2,3)", perm"(1,2)(3)")
+        @test PropertyT.isopposite(PG.perm"(1,2,3)(4)", PG.perm"(1,4,2)")
+        @test PropertyT.isadjacent(PG.perm"(1,2,3)", PG.perm"(1,2)(3)")
 
-        @test !PropertyT.isopposite(perm"(1,2,3)", perm"(1,2)(3)")
-        @test !PropertyT.isadjacent(perm"(1,4)", perm"(2,3)(4)")
+        @test !PropertyT.isopposite(PG.perm"(1,2,3)", PG.perm"(1,2)(3)")
+        @test !PropertyT.isadjacent(PG.perm"(1,4)", PG.perm"(2,3)(4)")
 
         @test isconstant_on_orbit([1, 1, 1, 2, 2], [2, 3])
         @test !isconstant_on_orbit([1, 1, 1, 2, 2], [2, 3, 4])
@@ -29,19 +29,19 @@ using SparseArrays
             RG(length(S)) - sum(RG(s) for s in S)
         end
 
-        P = PermGroup(perm"(1,2)", Perm(circshift(1:N, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
+        Σ = Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         act = PropertyT.action_by_conjugation(G, Σ)
 
-        wd = WedderburnDecomposition(
+        wd = SW.WedderburnDecomposition(
             Float64,
             Σ,
             act,
-            basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            SA.basis(RG),
+            SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[2]]),
         )
         @info wd
-        ivs = SymbolicWedderburn.invariant_vectors(wd)
+        ivs = SW.invariant_vectors(wd)
 
         sq, adj, op = PropertyT.SqAdjOp(RG, N)
 
@@ -105,16 +105,16 @@ end
 
         Δ = RG(length(S)) - sum(RG(s) for s in S)
 
-        P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+        Σ = Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         act = PropertyT.action_by_conjugation(G, Σ)
 
-        wd = SymbolicWedderburn.WedderburnDecomposition(
+        wd = SW.WedderburnDecomposition(
             Float64,
             Σ,
             act,
-            basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            SA.basis(RG),
+            SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[2]]),
         )
         @info wd
 
@@ -130,7 +130,7 @@ end
                 wd;
                 upper_bound = UB,
                 halfradius = 2,
-                optimizer = cosmo_optimizer(; accel = 50, alpha = 1.9),
+                optimizer = scs_optimizer(; accel = -50, alpha = 1.9),
             )
             @test status == JuMP.OPTIMAL
             @test certified
@@ -156,7 +156,7 @@ end
             m, _ = PropertyT.sos_problem_primal(elt, wd)
             PropertyT.solve(
                 m,
-                scs_optimizer(; max_iters = 5000, accel = 50, alpha = 1.9),
+                scs_optimizer(; max_iters = 1000, accel = 50, alpha = 1.9),
             )
 
             @test JuMP.termination_status(m) in
@@ -193,16 +193,16 @@ end
 
         Δ = RG(length(S)) - sum(RG(s) for s in S)
 
-        P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+        Σ = Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         act = PropertyT.action_by_conjugation(G, Σ)
 
-        wd = SymbolicWedderburn.WedderburnDecomposition(
+        wd = SW.WedderburnDecomposition(
             Float64,
             Σ,
             act,
-            basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            SA.basis(RG),
+            SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[2]]),
         )
         @info wd
 

test/Chevalley.jl

@@ -20,8 +20,10 @@ end
 end
 
 @testset "Exceptional root systems" begin
+    Base.:^(t::NTuple{N}, p::PG.AbstractPermutation) where {N} =
+        ntuple(i -> t[i^p], N)
     @testset "F4" begin
-        F4 = let Σ = PermutationGroups.PermGroup(perm"(1,2,3,4)", perm"(1,2)")
+        F4 = let Σ = PG.PermGroup(PG.perm"(1,2,3,4)", PG.perm"(1,2)")
             long = let x = (1, 1, 0, 0) .// 1
                 PropertyT.Roots.Root.(
                     union(
@@ -50,7 +52,7 @@ end
 
         a = F4[1]
         @test isapprox(PropertyT.Roots.ℓ₂length(a), sqrt(2))
-        b = F4[6]
+        b = F4[4]
         @test isapprox(PropertyT.Roots.ℓ₂length(b), sqrt(2))
         c = a + b
         @test isapprox(PropertyT.Roots.ℓ₂length(c), 2.0)
@@ -90,9 +92,9 @@ end
 
     @testset "E6-7-8 exceptional root systems" begin
         E8 =
-            let Σ = PermutationGroups.PermGroup(
-                    perm"(1,2,3,4,5,6,7,8)",
-                    perm"(1,2)",
+            let Σ = PG.PermGroup(
+                    PG.perm"(1,2,3,4,5,6,7,8)",
+                    PG.perm"(1,2)",
                 )
                 long = let x = (1, 1, 0, 0, 0, 0, 0, 0) .// 1
                     PropertyT.Roots.Root.(
@@ -160,7 +162,6 @@ end
                 ])
                 @test Set(keys(counts)) == subtypes
                 d, r = divrem(counts[:A₂], 4)
-                @info d, r
                 @test r == 0 && d == 10
             end
         end

test/actions.jl

@@ -1,5 +1,5 @@
 function test_action(basis, group, act)
-    action = SymbolicWedderburn.action
+    action = SW.action
     return @testset "action definition" begin
         @test all(basis) do b
             e = one(group)
@@ -22,7 +22,7 @@ function test_action(basis, group, act)
             g_h
         end
 
-        action = SymbolicWedderburn.action
+        action = SW.action
         @test action(act, g, a) in basis
         @test action(act, h, a) in basis
         @test action(act, h, action(act, g, a)) == action(act, g * h, a)
@@ -33,7 +33,7 @@ function test_action(basis, group, act)
             return x == y
         end
 
-        if act isa SymbolicWedderburn.ByPermutations
+        if act isa SW.ByPermutations
             @test all(basis) do b
                 return action(act, g, b) ∈ basis && action(act, h, b) ∈ basis
             end
@@ -50,75 +50,73 @@ end
     RSL, S, sizes = PropertyT.group_algebra(SL; halfradius = 2)
 
     @testset "Permutation action" begin
-        Γ = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
+        Γ = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
         ΓpA = PropertyT.action_by_conjugation(SL, Γ)
 
-        test_action(basis(RSL), Γ, ΓpA)
+        test_action(SA.basis(RSL), Γ, ΓpA)
 
         @testset "mps is successful" begin
             charsΓ =
-                SymbolicWedderburn.Character{
+                SW.Character{
                     Rational{Int},
-                }.(SymbolicWedderburn.irreducible_characters(Γ))
+            }.(SW.irreducible_characters(Γ))
 
-            RΓ = SymbolicWedderburn._group_algebra(Γ)
+            RΓ = SW._group_algebra(Γ)
 
             @time mps, ranks =
-                SymbolicWedderburn.minimal_projection_system(charsΓ, RΓ)
+                SW.minimal_projection_system(charsΓ, RΓ)
             @test all(isone, ranks)
         end
 
         @testset "Wedderburn decomposition" begin
-            wd = SymbolicWedderburn.WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Rational{Int},
                 Γ,
                 ΓpA,
-                basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.basis(RSL),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
 
-            @test length(invariant_vectors(wd)) == 918
-            @test SymbolicWedderburn.size.(direct_summands(wd), 1) ==
-                  [40, 23, 18]
-            @test all(issimple, direct_summands(wd))
+            @test length(SW.invariant_vectors(wd)) == 918
+            @test size.(SW.direct_summands(wd), 1) == [23, 18, 40]
+            @test all(SW.issimple, SW.direct_summands(wd))
         end
     end
 
     @testset "Wreath action" begin
-        Γ = let P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-            PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Γ = let P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+            Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         end
 
         ΓpA = PropertyT.action_by_conjugation(SL, Γ)
 
-        test_action(basis(RSL), Γ, ΓpA)
+        test_action(SA.basis(RSL), Γ, ΓpA)
 
         @testset "mps is successful" begin
             charsΓ =
-                SymbolicWedderburn.Character{
+                SW.Character{
                     Rational{Int},
-                }.(SymbolicWedderburn.irreducible_characters(Γ))
+            }.(SW.irreducible_characters(Γ))
 
-            RΓ = SymbolicWedderburn._group_algebra(Γ)
+            RΓ = SW._group_algebra(Γ)
 
             @time mps, ranks =
-                SymbolicWedderburn.minimal_projection_system(charsΓ, RΓ)
+                SW.minimal_projection_system(charsΓ, RΓ)
             @test all(isone, ranks)
         end
 
         @testset "Wedderburn decomposition" begin
-            wd = SymbolicWedderburn.WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Rational{Int},
                 Γ,
                 ΓpA,
-                basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.basis(RSL),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
 
-            @test length(invariant_vectors(wd)) == 247
-            @test SymbolicWedderburn.size.(direct_summands(wd), 1) ==
-                  [14, 9, 6, 14, 12]
-            @test all(issimple, direct_summands(wd))
+            @test length(SW.invariant_vectors(wd)) == 247
+            @test size.(SW.direct_summands(wd), 1) == [9, 6, 14, 14, 12]
+            @test all(SW.issimple, SW.direct_summands(wd))
         end
     end
 end
@@ -130,75 +128,73 @@ end
     RSAutFn, S, sizes = PropertyT.group_algebra(SAutFn; halfradius = 1)
 
     @testset "Permutation action" begin
-        Γ = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
+        Γ = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
         ΓpA = PropertyT.action_by_conjugation(SAutFn, Γ)
 
-        test_action(basis(RSAutFn), Γ, ΓpA)
+        test_action(SA.basis(RSAutFn), Γ, ΓpA)
 
         @testset "mps is successful" begin
             charsΓ =
-                SymbolicWedderburn.Character{
+                SW.Character{
                     Rational{Int},
-                }.(SymbolicWedderburn.irreducible_characters(Γ))
+            }.(SW.irreducible_characters(Γ))
 
-            RΓ = SymbolicWedderburn._group_algebra(Γ)
+            RΓ = SW._group_algebra(Γ)
 
             @time mps, ranks =
-                SymbolicWedderburn.minimal_projection_system(charsΓ, RΓ)
+                SW.minimal_projection_system(charsΓ, RΓ)
             @test all(isone, ranks)
         end
 
         @testset "Wedderburn decomposition" begin
-            wd = SymbolicWedderburn.WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Rational{Int},
                 Γ,
                 ΓpA,
-                basis(RSAutFn),
-                StarAlgebras.Basis{UInt16}(@view basis(RSAutFn)[1:sizes[1]]),
+                SA.basis(RSAutFn),
+                SA.Basis{UInt16}(@view SA.basis(RSAutFn)[1:sizes[1]]),
             )
 
-            @test length(invariant_vectors(wd)) == 93
-            @test SymbolicWedderburn.size.(direct_summands(wd), 1) ==
-                  [4, 8, 5, 4]
-            @test all(issimple, direct_summands(wd))
+            @test length(SW.invariant_vectors(wd)) == 93
+            @test size.(SW.direct_summands(wd), 1) == [5, 4, 8, 4]
+            @test all(SW.issimple, SW.direct_summands(wd))
         end
     end
 
     @testset "Wreath action" begin
-        Γ = let P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
-            PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Γ = let P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
+            Groups.Constructions.WreathProduct(PG.PermGroup(PG.perm"(1,2)"), P)
         end
 
         ΓpA = PropertyT.action_by_conjugation(SAutFn, Γ)
 
-        test_action(basis(RSAutFn), Γ, ΓpA)
+        test_action(SA.basis(RSAutFn), Γ, ΓpA)
 
         @testset "mps is successful" begin
             charsΓ =
-                SymbolicWedderburn.Character{
+                SW.Character{
                     Rational{Int},
-                }.(SymbolicWedderburn.irreducible_characters(Γ))
+            }.(SW.irreducible_characters(Γ))
 
-            RΓ = SymbolicWedderburn._group_algebra(Γ)
+            RΓ = SW._group_algebra(Γ)
 
             @time mps, ranks =
-                SymbolicWedderburn.minimal_projection_system(charsΓ, RΓ)
+                SW.minimal_projection_system(charsΓ, RΓ)
             @test all(isone, ranks)
         end
 
         @testset "Wedderburn decomposition" begin
-            wd = SymbolicWedderburn.WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Rational{Int},
                 Γ,
                 ΓpA,
-                basis(RSAutFn),
-                StarAlgebras.Basis{UInt16}(@view basis(RSAutFn)[1:sizes[1]]),
+                SA.basis(RSAutFn),
+                SA.Basis{UInt16}(@view SA.basis(RSAutFn)[1:sizes[1]]),
             )
 
-            @test length(invariant_vectors(wd)) == 18
-            @test SymbolicWedderburn.size.(direct_summands(wd), 1) ==
-                  [1, 1, 2, 2, 1, 2, 2, 1]
-            @test all(issimple, direct_summands(wd))
+            @test length(SW.invariant_vectors(wd)) == 18
+            @test size.(SW.direct_summands(wd), 1) == [2, 1, 2, 1, 2, 1, 1, 2]
+            @test all(SW.issimple, SW.direct_summands(wd))
         end
     end
 end

test/check_positivity.jl

@@ -29,7 +29,7 @@ function check_positivity(
     halfradius = 2,
     optimizer,
 )
-    @assert aug(elt) == aug(unit) == 0
+    @assert SA.aug(elt) == SA.aug(unit) == 0
     @time sos_problem, Ps =
         PropertyT.sos_problem_primal(elt, unit, wd; upper_bound = upper_bound)
 

test/quick_tests.jl

@@ -4,7 +4,7 @@
         p = 7
         halfradius = 3
         G = MatrixGroups.SpecialLinearGroup{N}(
-            SymbolicWedderburn.Characters.FiniteFields.GF{p},
+            SW.Characters.FiniteFields.GF{p},
         )
         RG, S, sizes = PropertyT.group_algebra(G; halfradius = 3)
 
@@ -22,11 +22,11 @@
                 unit;
                 upper_bound = ub,
                 halfradius = 2,
-                optimizer = cosmo_optimizer(;
-                    eps = 1e-7,
-                    max_iters = 5_000,
-                    accel = 50,
-                    alpha = 1.95,
+                optimizer = scs_optimizer(;
+                    eps = 1e-8,
+                    max_iters = 20_000,
+                    accel = -50,
+                    alpha = 1.9,
                 ),
             )
 
@@ -37,32 +37,34 @@
             m = PropertyT.sos_problem_dual(elt, unit)
             PropertyT.solve(
                 m,
-                cosmo_optimizer(;
-                    eps = 1e-7,
+                scs_optimizer(;
+                    eps = 1e-8,
                     max_iters = 10_000,
-                    accel = 50,
-                    alpha = 1.95,
+                    accel = -50,
+                    alpha = 1.9,
                 ),
             )
 
             @test JuMP.termination_status(m) in
                   (JuMP.ALMOST_OPTIMAL, JuMP.OPTIMAL)
-            @test JuMP.objective_value(m) ≈ λ_cert atol = 1e-2
+            @test JuMP.objective_value(m) ≈
+                  PropertyT.IntervalArithmetic.mid(λ_cert) atol = 1e-2
         end
 
         @testset "Wedderburn decomposition" begin
-            P = PermGroup(perm"(1,2)", Perm(circshift(1:N, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
+            Σ = Groups.Constructions.WreathProduct(
+                PG.PermGroup(PG.perm"(1,2)"),
+                P,
+            )
             act = PropertyT.action_by_conjugation(G, Σ)
 
-            wd = WedderburnDecomposition(
+            wd = SW.WedderburnDecomposition(
                 Float64,
                 Σ,
                 act,
-                basis(RG),
-                StarAlgebras.Basis{UInt16}(
-                    @view basis(RG)[1:sizes[halfradius]]
-                ),
+                SA.basis(RG),
+                SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[halfradius]]),
             )
 
             status, certified, λ_cert = check_positivity(
@@ -71,10 +73,10 @@
                 wd;
                 upper_bound = ub,
                 halfradius = 2,
-                optimizer = cosmo_optimizer(;
-                    eps = 1e-7,
+                optimizer = scs_optimizer(;
+                    eps = 1e-8,
                     max_iters = 10_000,
-                    accel = 50,
+                    accel = -50,
                     alpha = 1.9,
                 ),
             )

test/runtests.jl

@@ -3,19 +3,18 @@ using LinearAlgebra
 using SparseArrays
 
 using Groups
-using Groups.GroupsCore
 import Groups.MatrixGroups
 
 using PropertyT
-using SymbolicWedderburn
-using SymbolicWedderburn.StarAlgebras
-using SymbolicWedderburn.PermutationGroups
+import SymbolicWedderburn as SW
+import StarAlgebras as SA
+import PermutationGroups as PG
 
 include("optimizers.jl")
 include("check_positivity.jl")
 include("quick_tests.jl")
 
-if haskey(ENV, "FULL_TEST") || haskey(ENV, "CI")
+if haskey(ENV, "CI")
     @testset "PropertyT" begin
         include("constratint_matrices.jl")
         include("actions.jl")