add weight structure decomposition

Author: vitktor

src/DecomposingRepresentations.jl

@@ -10,7 +10,7 @@ export @polyvar, Variable, Monomial, Polynomial, Commutative, CreationOrder, Gra
 
 using Combinatorics: partitions, multiset_permutations, combinations, with_replacement_combinations
 
-using Base.Iterators: product
+using Base.Iterators: product, flatten
 
 include("utils/basic.jl")
 include("utils/Gauss-Jordan.jl")
@@ -19,9 +19,13 @@ include("types.jl")
 include("vector-spaces/basic.jl")
 include("vector-spaces/composite.jl")
 
-include("lie-groups/lie-algebras/weights.jl")
+include("lie-groups/lie-algebras/weights/weight.jl")
+include("lie-groups/lie-algebras/weights/weight-vector.jl")
+include("lie-groups/lie-algebras/weights/weight-space.jl")
+include("lie-groups/lie-algebras/weights/weight-struct.jl")
 include("lie-groups/lie-algebras/algebras.jl")
 include("lie-groups/lie-algebras/elements.jl")
+include("lie-groups/lie-algebras/weights/decompose-weights.jl")
 
 include("lie-groups/lie-groups/groups.jl")
 include("lie-groups/lie-groups/elements.jl")

src/decompositions/irred-decomp.jl

@@ -1,3 +1,5 @@
+export irreducibles, irreducibles_old
+
 function ws_nullspace(
     X::AbstractLieAlgebraElem,
     a::AbstractGroupAction{Lie},
@@ -14,7 +16,7 @@ function ws_nullspace(
     isempty(Cs) && return nothing
     return WeightSpace(
         weight(ws),
-        VectorSpace(field_type(ws), [sum(sparsify!(div_by_lowest_magnitude(c, tol), tol) .* B) for c in Cs]; in_rref=false)
+        VectorSpace(field_type(ws), [sum(c .* B) for c in Cs]; in_rref=false)
         )
 end
 
@@ -58,16 +60,54 @@ end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S}
+) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
+    V = space(ρ)
+    Vb = base_space(V)
+    power(V) == 1 && return [IrreducibleRepresentation(action(ρ), Vb)]
+    ws = weight_structure(Vb)
+    sym_ws = sym_weight_struct(highest_weight(Vb), algebra(action(ρ)), power(V), ws)
+    println("new nweights: ", nweights(sym_ws))
+    println("new sum of dims: ", sum([dim(space(sym_ws[w])) for w in weights(sym_ws)]))
+    Xs = positive_root_elements(algebra(action(ρ)))
+    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws)
+    return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
+end
+
+function irreducibles_old(
+    ρ::GroupRepresentation{A, S}
 ) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
     V = space(ρ)
     power(V) == 1 && return [IrreducibleRepresentation(action(ρ), base_space(V))]
     ws = weight_structure(base_space(V))
     sym_ws = sym(ws, power(V))
+    println("old nweights: ", nweights(sym_ws))
+    println("old sum of dims: ", sum([dim(space(sym_ws[w])) for w in weights(sym_ws)]))
     Xs = positive_root_elements(algebra(action(ρ)))
     hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws)
     return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
 end
 
+function irreducibles_old(
+    ρ::GroupRepresentation{A, T}
+) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}
+    V = space(ρ)
+    ρ_base = GroupRepresentation(action(ρ), base_space(V))
+    irreds_base = irreducibles(ρ_base)
+    if length(irreds_base) == 1
+        V = SymmetricPower(space(first(irreds_base)), power(V))
+        ρᵢ = GroupRepresentation(action(ρ), V)
+        return irreducibles_old(ρᵢ)
+    end
+    mexps = multiexponents(degree=power(V), nvars=length(irreds_base))
+    irreds = IrreducibleRepresentation{A}[]
+    for mexp in mexps
+        Vᵢ = TensorProduct([SymmetricPower(space(irreds_base[idx]), val) for (val, idx) in zip(mexp.nzval, mexp.nzind)])
+        ρᵢ = GroupRepresentation(action(ρ), Vᵢ)
+        append!(irreds, irreducibles(ρᵢ))
+    end
+    return irreds
+end
+
 function irreducibles(
     ρ::GroupRepresentation{A, T}
 ) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}

src/decompositions/isotypic-decomp.jl

@@ -1,3 +1,5 @@
+export isotypic_dict
+
 function isotypic_components(
     irreds::Vector{T}
 ) where {T<:IrreducibleRepresentation}
@@ -19,4 +21,8 @@ function isotypic_components(
 ) where {A<:AbstractGroupAction{Lie}}
     irreds = irreducibles(ρ)
     return isotypic_components(irreds)
-end
+end
+
+isotypic_dict(
+    iso::Vector{T}
+) where T<:IsotypicComponent = Dict{Weight, T}(zip([highest_weight(ic) for ic in iso], iso))

src/lie-groups/lie-algebras/weights/decompose-weights.jl

@@ -0,0 +1,114 @@
+export sym_weight_dict
+
+# TODO: works only for so(3)
+function ⊗(hw₁::Weight, hw₂::Weight, ::LieAlgebra)
+    @assert length(hw₁) == length(hw₂) == 1
+    m, n = hw₁[1], hw₂[1]
+    m, n = m > n ? (m, n) : (n, m)
+    return [Weight([m+n-j]) for j in 0:2*n]
+end
+
+⊗(hw₁::Weight, hw₂::Weight, ::ScalingLieAlgebra) = [hw₁ + hw₂]
+
+
+function split_weight(w::T, A::SumLieAlgebra) where T<:Weight
+    inds = cumsum([rank(alg) for alg in algebras(A)])
+    st_ind = 1
+    ws = T[]
+    for end_ind in inds
+        push!(ws, Weight(w[st_ind:end_ind]))
+        st_ind = end_ind + 1
+    end
+    return ws
+end
+
+function ⊗(hw₁::Weight, hw₂::Weight, A::SumLieAlgebra)
+    ws₁ = split_weight(hw₁, A)
+    ws₂ = split_weight(hw₂, A)
+    sep_ws = [⊗(w₁, w₂, alg) for (w₁, w₂, alg) in zip(ws₁, ws₂, algebras(A))]
+    all_ws = product(sep_ws...)
+    return [vcat(collect(ws)...) for ws in all_ws][:]
+end
+
+# TODO: works only for so(3)
+hw2all(hw::Weight, ::LieAlgebra) = [Weight([j]) for j in -hw[1]:hw[1]]
+hw2all(hw::Weight, ::ScalingLieAlgebra) = [hw]
+
+function hw2all(hw::Weight, A::SumLieAlgebra)
+    ws = split_weight(hw, A)
+    all_ws = [hw2all(w, alg) for (w, alg) in zip(ws, algebras(A))]
+    all_ws = product(all_ws...)
+    return [vcat(collect(ws)...) for ws in all_ws][:]
+end
+
+function sym_weight_dict(hw::T, A::AbstractLieAlgebra, p::Int) where T<:Weight
+    ws = hw2all(hw, A)
+    combs = multiexponents(; degree=p, nvars=length(ws))
+    ws_dict = Dict{T, Int}()
+    for comb in combs
+        w = sum([val*ws[ind] for (ind, val) in zip(comb.nzind, comb.nzval)])
+        ws_dict[w] = get(ws_dict, w, 0) + 1
+    end
+    return p*hw, ws_dict
+end
+
+# # TODO: works only for so(3)
+# child_weights(hw::T, ::LieAlgebra) where T<:Weight = iszero(hw[1]) ? T[] : [Weight([hw[1]-1])]
+# child_weights(::T, ::ScalingLieAlgebra) where T<:Weight = T[]
+# function child_weights(hw::Weight, A::SumLieAlgebra)
+#     ws = split_weight(hw, A)
+#     all_child_ws = [child_weights(w, alg) for (w, alg) in zip(ws, algebras(A))]
+#     full_child_ws = [[copy(ws) for _ in child_ws] for child_ws in all_child_ws]
+#     for (i, child_ws) in enumerate(all_child_ws)
+#         for (j, w) in enumerate(child_ws)
+#             full_child_ws[i][j][i] = w
+#         end
+#     end
+#     return [vcat(ch_ws...) for ch_ws in flatten(full_child_ws)]
+# end
+
+function some_highest_weight(
+    ws_dict::Dict{W, Int},
+    A::AbstractLieAlgebra
+) where W<:Weight
+    w = first(keys(ws_dict))
+    while true
+        exists = false
+        for α in positive_roots(A)
+            if haskey(ws_dict, w + α)
+                w = w + α
+                exists = true
+                break
+            end
+        end
+        !exists && return w
+    end
+end
+
+function sym!(
+    hw::W,
+    A::AbstractLieAlgebra,
+    ws_dict::Dict{W, Int},
+    decomp_hws::Union{Set{W}, Vector{W}}
+) where W<:Weight
+    if ws_dict[hw] != 0
+        orbit_ws = hw2all(hw, A)
+        while ws_dict[hw] > 0
+            push!(decomp_hws, hw)
+            [ws_dict[w] -= 1 for w in orbit_ws]
+        end
+        for w in collect(keys(ws_dict))
+            ws_dict[w] == 0 && delete!(ws_dict, w)
+        end
+    end
+    isempty(ws_dict) && return decomp_hws
+    shw = some_highest_weight(ws_dict, A)
+    sym!(shw, A, ws_dict, decomp_hws)
+end
+
+function sym(hw::T, A::AbstractLieAlgebra, p::Int; with_muls::Bool=false) where T<:Weight
+    sym_hw, ws_dict = sym_weight_dict(hw, A, p)
+    decomp_hws = with_muls ? T[] : Set{T}()
+    sym!(sym_hw, A, ws_dict, decomp_hws)
+    return collect(decomp_hws)
+end

src/lie-groups/lie-algebras/weights/weight-space.jl

@@ -0,0 +1,37 @@
+export WeightSpace,
+    space
+
+struct WeightSpace{T <: AbstractVectorSpace, W<:Weight}
+    weight::W
+    space::T
+end
+
+WeightSpace(weight::Vector, space::Vector) = WeightSpace(Weight(weight), MatrixVectorSpace(space))
+WeightSpace{T,W}(wv::WeightVector) where {T,W} = WeightSpace{T,W}(weight(wv), T(vector(wv)))
+
+Base.convert(
+    ::Type{WeightSpace{T, W}},
+    ws::WeightSpace
+) where {T<:AbstractVectorSpace, W<:Weight} = WeightSpace(
+    convert(W, weight(ws)),
+    convert(T, space(ws))
+)
+
+weight(ws::WeightSpace) = ws.weight
+space(ws::WeightSpace) = ws.space
+dim(ws::WeightSpace) = dim(space(ws))
+field_type(::WeightSpace{T}) where {T} = field_type(T)
+
+function Base.show(io::IO, ::MIME"text/plain", ws::WeightSpace)
+    println(io, "WeightSpace of dimension $(dim(ws))")
+    print(io, " weight: $(weight(ws))")
+end
+
+function Base.show(io::IO, ws::WeightSpace)
+    print(io, "WeightSpace of dimension $(dim(ws))")
+end
+
+function Base.iterate(ws::WeightSpace, state=1)
+    state > dim(ws) && return nothing
+    return (WeightVector(weight(ws), basis(space(ws), state)), state+1)
+end

src/lie-groups/lie-algebras/weights.jl …ps/lie-algebras/weights/weight-struct.jlsrc/lie-groups/lie-algebras/weights.jl renamed to src/lie-groups/lie-algebras/weights/weight-struct.jl src/lie-groups/lie-algebras/weights.jl renamed to src/lie-groups/lie-algebras/weights/weight-struct.jl

@@ -1,86 +1,7 @@
-export Weight,
-    WeightVector,
-    weight,
-    vector,
-    WeightSpace,
-    space,
-    WeightStructure,
+export WeightStructure,
     weight_space,
     sym
 
-
-struct Weight{T}
-    weight::Vector{T}
-end
-
-Base.show(io::IO, ::MIME"text/plain", w::Weight) = print(io, "Weight: ", w.weight)
-Base.show(io::IO, w::Weight) = print(io, w.weight)
-Base.zero(::Type{Weight{T}}, n) where T = Weight(zeros(T, n))
-Base.zero(w::Weight) = Weight(zero(w.weight))
-Base.vcat(w₁::Weight{T}, w₂::Weight{T}) where T = Weight(vcat(w₁.weight, w₂.weight))
-Base.vcat(ws::Weight{T}...) where T = Weight(vcat([w.weight for w in ws]...))
-Base.hash(w::Weight, h::UInt) = hash(w.weight, h)
-Base.:(==)(w₁::Weight, w₂::Weight) = w₁.weight == w₂.weight
-Base.:*(n::Number, w::Weight) = Weight(n*w.weight)
-Base.:+(w₁::Weight{T}, w₂::Weight{T}) where {T} = Weight{T}(w₁.weight + w₂.weight)
-Base.promote_rule(::Type{Weight{T}}, ::Type{Weight{S}}) where {T,S} = Weight{promote_type(T, S)}
-Base.getindex(w::Weight, i::Integer) = w.weight[i]
-Base.getindex(w::Weight, inds...) = getindex(w.weight, inds...)
-Base.length(w::Weight) = length(w.weight)
-Base.eachindex(w::Weight) = eachindex(w.weight)
-
-struct WeightVector{T, W<:Weight}
-    weight::W
-    vector::T
-end
-
-weight(wv::WeightVector) = wv.weight
-vector(wv::WeightVector) = wv.vector
-
-function Base.show(io::IO, ::MIME"text/plain", wv::WeightVector)
-    println(io, "WeightVector with weight $(weight(wv))")
-    print(io, " vector: $(repr(vector(wv)))")
-end
-
-function Base.show(io::IO, wv::WeightVector)
-    print(io, "WeightVector with weight $(weight(wv))")
-end
-
-struct WeightSpace{T <: AbstractVectorSpace, W<:Weight}
-    weight::W
-    space::T
-end
-
-WeightSpace(weight::Vector, space::Vector) = WeightSpace(Weight(weight), MatrixVectorSpace(space))
-WeightSpace{T,W}(wv::WeightVector) where {T,W} = WeightSpace{T,W}(weight(wv), T(vector(wv)))
-
-Base.convert(
-    ::Type{WeightSpace{T, W}},
-    ws::WeightSpace
-) where {T<:AbstractVectorSpace, W<:Weight} = WeightSpace(
-    convert(W, weight(ws)),
-    convert(T, space(ws))
-)
-
-weight(ws::WeightSpace) = ws.weight
-space(ws::WeightSpace) = ws.space
-dim(ws::WeightSpace) = dim(space(ws))
-field_type(::WeightSpace{T}) where {T} = field_type(T)
-
-function Base.show(io::IO, ::MIME"text/plain", ws::WeightSpace)
-    println(io, "WeightSpace of dimension $(dim(ws))")
-    print(io, " weight: $(weight(ws))")
-end
-
-function Base.show(io::IO, ws::WeightSpace)
-    print(io, "WeightSpace of dimension $(dim(ws))")
-end
-
-function Base.iterate(ws::WeightSpace, state=1)
-    state > dim(ws) && return nothing
-    return (WeightVector(weight(ws), basis(space(ws), state)), state+1)
-end
-
 struct WeightStructure{T<:AbstractVectorSpace, W<:Weight}
     weights::Vector{W} # Ordering needed for sym_weight_structure
     dict::Dict{W, WeightSpace{T, W}} # TODO: new type for WeightSpace{F,T,W}? Do all spaces have to be of the same type?
@@ -180,6 +101,32 @@ end
 
 Base.push!(ws::WeightStructure{T,W}, wv::WeightVector) where {T,W} = push!(ws, WeightSpace{T,W}(wv))
 
+function sym_weights_dict(ws::Vector{W}, p::Int) where W<:Weight
+    combs = multiexponents(; degree=p, nvars=length(ws))
+    ws_dict = Dict{W, Vector{typeof(first(combs))}}()
+    for comb in combs
+        w = sum([val*ws[ind] for (val, ind) in zip(comb.nzval, comb.nzind)])
+        if haskey(ws_dict, w)
+            push!(ws_dict[w], comb)
+        else
+            ws_dict[w] = [comb]
+        end
+    end
+    return ws_dict
+end
+
+function sym_weight_struct(hw::W, A::AbstractLieAlgebra, p::Int, ws::WeightStructure{T,W}) where {T, W<:Weight}
+    dir_sum_hws = sym(hw, A, p)
+    ws_dict = sym_weights_dict(weights(ws), p)
+    new_ws = WeightStructure{T,W}()
+    for hw in dir_sum_hws
+        combs = ws_dict[hw]
+        w_sps = [*(weight_spaces(ws, comb.nzind; as_spaces=true), comb.nzval; in_rref=false) for comb in combs]
+        push!(new_ws, WeightSpace(hw, +(w_sps...; in_rref=false)))
+    end
+    return new_ws
+end
+
 function sym(ws::WeightStructure{T,W}, d::Int) where {T, W}
     d == 0 && return WeightStructure([WeightSpace(zero_weight(ws), field_space(ws))])
     d == 1 && return ws