import packages as ... instead of using

This includes:
* PermutationGroups as PG
* SymbolicWedderburn as SW
* StarAlgebras as SA

src/PropertyT.jl

@@ -7,9 +7,9 @@ using JuMP
 
 using Groups
 import GroupsCore
-using SymbolicWedderburn
+import PermutationGroups as PG
-import SymbolicWedderburn.StarAlgebras
+import SymbolicWedderburn as SW
-import SymbolicWedderburn.PermutationGroups
+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(
+function SW.action(
-    act::SymbolicWedderburn.ByPermutations,
+    act::SW.ByPermutations,
     g::Groups.GroupElement,
-    α::StarAlgebras.AlgebraElement,
+    α::SA.AlgebraElement,
 )
-    res = StarAlgebras.zero!(similar(α))
+    res = SA.zero!(similar(α))
-    B = basis(parent(α))
+    B = SA.basis(parent(α))
-    for (idx, val) in StarAlgebras._nzpairs(StarAlgebras.coeffs(α))
+    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.:^(
+function Base.:^(w::W, p::PG.AbstractPermutation) where {W<:Groups.AbstractWord}
-    w::W,
-    p::PermutationGroups.AbstractPerm,
-) 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
+struct AlphabetPermutation{GEl,I} <: SW.ByPermutations
-    perms::Dict{GEl,PermutationGroups.Perm{I}}
+    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) =
+function action_by_conjugation(
-    AlphabetPermutation(alphabet(sautfn), Σ, _conj)
+    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) =
+function action_by_conjugation(
-    AlphabetPermutation(alphabet(sln), Σ, _conj)
+    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) =
+function action_by_conjugation(
-    AlphabetPermutation(alphabet(sln), Σ, _conj)
+    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
 
@@ -87,10 +87,10 @@ function sufficient_λ(residual::StarAlgebras.AlgebraElement, λ; halfradius)
 end
 
 function sufficient_λ(
-    elt::StarAlgebras.AlgebraElement,
+    elt::SA.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement,
+    order_unit::SA.AlgebraElement,
     λ,
-    sos::StarAlgebras.AlgebraElement;
+    sos::SA.AlgebraElement;
     halfradius,
 )
     @assert parent(elt) === parent(order_unit) == parent(sos)
@@ -100,16 +100,15 @@ function sufficient_λ(
 end
 
 function certify_solution(
-    elt::StarAlgebras.AlgebraElement,
+    elt::SA.AlgebraElement,
-    orderunit::StarAlgebras.AlgebraElement,
+    orderunit::SA.AlgebraElement,
     λ,
     Q::AbstractMatrix{<:AbstractFloat};
     halfradius,
-    augmented = iszero(StarAlgebras.aug(elt)) &&
+    augmented = iszero(SA.aug(elt)) && iszero(SA.aug(orderunit)),
-        iszero(StarAlgebras.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)

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)
+function constraints(A::SA.StarAlgebra; augmented::Bool)
-    return constraints(basis(A), A.mstructure; augmented = augmented)
+    return constraints(SA.basis(A), A.mstructure; augmented = augmented)
 end
 
 function constraints(
-    basis::StarAlgebras.AbstractBasis,
+    basis::SA.AbstractBasis,
-    mstr::StarAlgebras.MultiplicativeStructure;
+    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)
+        U = SW.image_basis(ds)
-        d = SymbolicWedderburn.degree(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{
+    hom::SW.InducedActionHomomorphism{
-        <:SymbolicWedderburn.ByPermutations,
+        <: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,
+    elt::SA.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement = zero(elt);
+    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,
+    elt::SA.AlgebraElement,
-    order_unit::StarAlgebras.AlgebraElement = zero(elt);
+    order_unit::SA.AlgebraElement = zero(elt);
     upper_bound = Inf,
-    augmented::Bool = iszero(StarAlgebras.aug(elt)) &&
+    augmented::Bool = iszero(SA.aug(elt)) && iszero(SA.aug(order_unit)),
-                      iszero(StarAlgebras.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)
+function isorth_projection(ds::SW.DirectSummand)
-    U = SymbolicWedderburn.image_basis(ds)
+    U = SW.image_basis(ds)
     return isapprox(U * U', I)
 end
 
 function sos_problem_primal(
-    elt::StarAlgebras.AlgebraElement,
+    elt::SA.AlgebraElement,
-    wedderburn::WedderburnDecomposition;
+    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,
+    elt::SA.AlgebraElement,
-    orderunit::StarAlgebras.AlgebraElement,
+    orderunit::SA.AlgebraElement,
-    wedderburn::WedderburnDecomposition;
+    wedderburn::SW.WedderburnDecomposition;
     upper_bound = Inf,
-    augmented = iszero(StarAlgebras.aug(elt)) &&
+    augmented = iszero(SA.aug(elt)) && iszero(SA.aug(orderunit)),
-        iszero(StarAlgebras.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
+    id_one = findfirst(SW.invariant_vectors(wedderburn)) do v
-        b = basis(parent(elt))
+        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)
+    X = SA.coeffs(elt)
-    U = StarAlgebras.coeffs(orderunit)
+    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) =
+function isopposite(
-    i^σ ≠ i^τ && i^σ ≠ j^τ && j^σ ≠ i^τ && j^σ ≠ j^τ
+    σ::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) =
+function isadjacent(
-    (i^σ == i^τ && j^σ ≠ j^τ) || # first equal, second differ
+    σ::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)
+function small_laplacian(RG::SA.StarAlgebra)
-    G = StarAlgebras.object(RG)
+    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

@@ -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)
 

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)))
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Σ = 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),
+            SA.basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            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)))
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            Σ = 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),
+                SA.basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                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),
+                SA.basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                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)))
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            Σ = 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),
+                SA.basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
             @info wdfl
 

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.isopposite(PG.perm"(1,2,3)(4)", PG.perm"(1,4,2)")
-        @test PropertyT.isadjacent(perm"(1,2,3)", perm"(1,2)(3)")
+        @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.isopposite(PG.perm"(1,2,3)", PG.perm"(1,2)(3)")
-        @test !PropertyT.isadjacent(perm"(1,4)", perm"(2,3)(4)")
+        @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)))
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Σ = 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),
+            SA.basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            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)))
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Σ = 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),
+            SA.basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[2]]),
         )
         @info wd
 
@@ -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)))
+        P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-        Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+        Σ = 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),
+            SA.basis(RG),
-            StarAlgebras.Basis{UInt16}(@view basis(RG)[1:sizes[2]]),
+            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(
@@ -90,9 +92,9 @@ end
 
     @testset "E6-7-8 exceptional root systems" begin
         E8 =
-            let Σ = PermutationGroups.PermGroup(
+            let Σ = PG.PermGroup(
-                    perm"(1,2,3,4,5,6,7,8)",
+                    PG.perm"(1,2,3,4,5,6,7,8)",
-                    perm"(1,2)",
+                    PG.perm"(1,2)",
                 )
                 long = let x = (1, 1, 0, 0, 0, 0, 0, 0) .// 1
                     PropertyT.Roots.Root.(

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,69 +50,68 @@ 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),
+                SA.basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
 
-            @test length(invariant_vectors(wd)) == 918
+            @test length(SW.invariant_vectors(wd)) == 918
-            @test SymbolicWedderburn.size.(direct_summands(wd), 1) ==
+            @test size.(SW.direct_summands(wd), 1) == [23, 18, 40]
-                  [40, 23, 18]
+            @test all(SW.issimple, SW.direct_summands(wd))
-            @test all(issimple, direct_summands(wd))
         end
     end
 
     @testset "Wreath action" begin
-        Γ = let P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
+        Γ = let P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-            PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            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),
+                SA.basis(RSL),
-                StarAlgebras.Basis{UInt16}(@view basis(RSL)[1:sizes[2]]),
+                SA.Basis{UInt16}(@view SA.basis(RSL)[1:sizes[2]]),
             )
 
             @test length(invariant_vectors(wd)) == 247
@@ -130,31 +129,31 @@ 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),
+                SA.basis(RSAutFn),
-                StarAlgebras.Basis{UInt16}(@view basis(RSAutFn)[1:sizes[1]]),
+                SA.Basis{UInt16}(@view SA.basis(RSAutFn)[1:sizes[1]]),
             )
 
             @test length(invariant_vectors(wd)) == 93
@@ -165,34 +164,34 @@ end
     end
 
     @testset "Wreath action" begin
-        Γ = let P = PermGroup(perm"(1,2)", Perm(circshift(1:n, -1)))
+        Γ = let P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:n, -1)))
-            PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            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),
+                SA.basis(RSAutFn),
-                StarAlgebras.Basis{UInt16}(@view basis(RSAutFn)[1:sizes[1]]),
+                SA.Basis{UInt16}(@view SA.basis(RSAutFn)[1:sizes[1]]),
             )
 
             @test length(invariant_vectors(wd)) == 18

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)
 
@@ -51,18 +51,19 @@
         end
 
         @testset "Wedderburn decomposition" begin
-            P = PermGroup(perm"(1,2)", Perm(circshift(1:N, -1)))
+            P = PG.PermGroup(PG.perm"(1,2)", PG.Perm(circshift(1:N, -1)))
-            Σ = PropertyT.Constructions.WreathProduct(PermGroup(perm"(1,2)"), P)
+            Σ = 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),
+                SA.basis(RG),
-                StarAlgebras.Basis{UInt16}(
+                SA.Basis{UInt16}(@view SA.basis(RG)[1:sizes[halfradius]]),
-                    @view basis(RG)[1:sizes[halfradius]]
-                ),
             )
 
             status, certified, λ_cert = check_positivity(

test/runtests.jl

@@ -7,9 +7,9 @@ using Groups.GroupsCore
 import Groups.MatrixGroups
 
 using PropertyT
-using SymbolicWedderburn
+import SymbolicWedderburn as SW
-using SymbolicWedderburn.StarAlgebras
+import StarAlgebras as SA
-using SymbolicWedderburn.PermutationGroups
+import PermutationGroups as PG
 
 include("optimizers.jl")
 include("check_positivity.jl")