mirror of
https://github.com/kalmarek/PropertyT.jl.git
synced 2024-11-25 16:50:27 +01:00
Merge 83fdd313c6 into f4936dd50a
This commit is contained in:
Marek Kaluba
GitHub
commit
e1d6cdb577
20
Project.toml
20
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"
|
||||
IntervalArithmetic = "0.20"
|
||||
IntervalMatrices = "0.8"
|
||||
JuMP = "1.3"
|
||||
Groups = "0.8"
|
||||
GroupsCore = "0.5"
|
||||
IntervalArithmetic = "0.21"
|
||||
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]
|
||||
|
||||
@ -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,
|
||||
)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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,9 +123,9 @@ function certify_solution(
|
||||
return false, λ_flpoint
|
||||
end
|
||||
|
||||
λ_int = IntervalArithmetic.@interval(λ)
|
||||
λ_int = IntervalArithmetic.interval(Float64, λ)
|
||||
Q_int = IntervalMatrices.IntervalMatrix([
|
||||
IntervalArithmetic.@interval(q) for q in Q
|
||||
IntervalArithmetic.interval(Float64, q) for q in Q
|
||||
])
|
||||
|
||||
check, sos_int = @time if should_we_augment
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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])
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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,
|
||||
),
|
||||
)
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
110
test/actions.jl
110
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
|
||||
|
||||
@ -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)
|
||||
|
||||
|
||||
@ -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,
|
||||
),
|
||||
)
|
||||
|
||||
@ -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")
|
||||
|
||||
Loading…
Reference in New Issue
Block a user