add weight structure computation for SumLieAlgebraAction

Author: vitktor

src/on_varieties/lie-symmetries/lie-algebras/actions.jl

@@ -2,7 +2,8 @@ export AbstractLieAlgebraAction,
     LieAlgebraAction,
     ScalingLieAction,
     SumLieAlgebraAction,
-    var_groups
+    var_groups,
+    hw_spaces
 
 
 abstract type AbstractLieAlgebraAction end
@@ -26,22 +27,22 @@ function ScalingLieAction(action_vars::AbstractArray; variables::AbstractArray=a
     return ScalingLieAction(act_vars, all_vars)
 end
 
-algebra(g::ScalingLieAction) = g.alg
-variables(g::ScalingLieAction) = g.vars
-exponents(g::ScalingLieAction) = g.alg.exps
+algebra(a::ScalingLieAction) = a.alg
+variables(a::ScalingLieAction) = a.vars
+exponents(a::ScalingLieAction) = a.alg.exps
 
-function Base.show(io::IO, g::ScalingLieAction)
-    println(io, "ScalingLieAction of $(name(algebra(g)))")
+function Base.show(io::IO, a::ScalingLieAction)
+    println(io, "ScalingLieAction of $(name(algebra(a)))")
     print(io, " action:")
-    U = exponents(g)
+    U = exponents(a)
     if size(U, 1) == 1
         @var λ
         λ = [λ]
     else
         @var λ[1:size(U₀, 1)]
     end
     action = Vector{Vector{Tuple{Variable, Expression}}}([[] for _ in axes(U, 1)])
-    vars = variables(g)
+    vars = variables(a)
     for j in axes(U, 1)
         nzind, nzval = findnz(U[j, :])
         exprs = (λ[j].^nzval).*vars[nzind]
@@ -56,6 +57,44 @@ function Base.show(io::IO, g::ScalingLieAction)
     end
 end
 
+function act(elem::LieAlgebraElem{ScalingLieAlgebra}, f::Union{Expression, Monomial}, action::ScalingLieAction)
+    X = as_matrix(elem)
+    return expand(dot(differentiate(f, variables(action)), -X*variables(action)))
+end
+
+function weight_structure(a::ScalingLieAction, vars::Vector{Variable})
+    
+end
+
+function hw_spaces(a::ScalingLieAction, vars::Vector{Variable})
+    @assert variables(a) ⊆ vars
+    vars_dict = Dict(zip(vars, 1:length(vars)))
+    hw_spaces_dict = Dict{Vector{Int}, WeightSpace}()
+    for (i, var) in enumerate(variables(a))
+        weight = exponents(a)[:, i]
+        if haskey(hw_spaces_dict, weight)
+            sp = zeros(ComplexF64, length(vars))
+            sp[vars_dict[var]] = 1
+            hw_spaces_dict[weight].space = hcat(hw_spaces_dict[weight].space, sp)
+        else
+            hw_space = WeightSpace(weight, zeros(ComplexF64, length(vars)))
+            hw_space.space[vars_dict[var]] = 1
+            hw_spaces_dict[weight] = hw_space
+        end
+    end
+    inv_vars = setdiff(vars, variables(a))
+    isempty(inv_vars) && return collect(values(hw_spaces_dict))
+    inv_hw_space = WeightSpace(zeros(Int, rank(algebra(a))), zeros(ComplexF64, length(vars), length(inv_vars)))
+    for (i, var) in enumerate(inv_vars)
+        inv_hw_space.space[vars_dict[var], i] = 1
+    end
+    if haskey(hw_spaces_dict, weight(inv_hw_space))
+        hw_spaces_dict[weight(inv_hw_space)].space = hcat(hw_spaces_dict[weight(inv_hw_space)].space, inv_hw_space.space)
+    else
+        hw_spaces_dict[weight(inv_hw_space)] = inv_hw_space
+    end
+    return collect(values(hw_spaces_dict))
+end
 
 struct LieAlgebraAction <: AbstractLieAlgebraAction
     alg::LieAlgebra
@@ -72,16 +111,54 @@ LieAlgebraAction(
     var_groups::AbstractArray
 ) = LieAlgebraAction(alg, M2VV(hcat(var_groups...)))
 
-algebra(g::LieAlgebraAction) = g.alg
-var_groups(g::LieAlgebraAction) = g.var_groups
-variables(g::LieAlgebraAction) = vcat(var_groups(g)...)
-weights(g::LieAlgebraAction) = weights(g.alg)
-weights(g::LieAlgebraAction, inds...) = weights(g.alg, inds...)
-nweights(g::LieAlgebraAction) = nweights(g.alg)
+algebra(a::LieAlgebraAction) = a.alg
+var_groups(a::LieAlgebraAction) = a.var_groups
+nvar_groups(a::LieAlgebraAction) = length(var_groups(a))
+variables(a::LieAlgebraAction) = vcat(var_groups(a)...)
+weights(a::LieAlgebraAction) = weights(a.alg)
+weights(a::LieAlgebraAction, inds...) = weights(a.alg, inds...)
+nweights(a::LieAlgebraAction) = nweights(a.alg)
+
+function Base.show(io::IO, a::LieAlgebraAction)
+    println(io, "LieAlgebraAction of $(name(algebra(a)))")
+    print(io, " action: [", join([join(vars, ", ") for vars in var_groups(a)], "], ["), "]")
+end
 
-function Base.show(io::IO, g::LieAlgebraAction)
-    println(io, "LieAlgebraAction of $(name(algebra(g)))")
-    print(io, " action: [", join([join(vars, ", ") for vars in var_groups(g)], "], ["), "]")
+function act(elem::LieAlgebraElem{LieAlgebra}, f::Union{Expression, Monomial}, action::LieAlgebraAction)
+    X = as_matrix(elem)
+    return expand(sum([dot(differentiate(f, vars), -X*vars) for vars in var_groups(action)]))
+end
+
+function weight_structure(a::LieAlgebraAction, vars::Vector{Variable})
+    
+end
+
+function hw_spaces(a::LieAlgebraAction, vars::Vector{Variable})
+    @assert variables(a) ⊆ vars
+    vars_dict = Dict(zip(vars, 1:length(vars)))
+    hw_spaces_vec = WeightSpace[]
+    for hw_space in hw_spaces(algebra(a))
+        hws = WeightSpace(hw_space.weight, zeros(ComplexF64, length(vars), dim(hw_space)*nvar_groups(a)))
+        for (i, vars_group) in enumerate(var_groups(a))
+            for (j, var) in enumerate(vars_group)
+                hws.space[vars_dict[var], (i-1)*dim(hw_space)+1:i*dim(hw_space)] = hw_space.space[j, :]
+            end
+        end
+        push!(hw_spaces_vec, hws)
+    end
+    inv_vars = setdiff(vars, variables(a))
+    isempty(inv_vars) && return hw_spaces_vec
+    inv_hw_space = WeightSpace(zeros(Int, rank(algebra(a))), zeros(ComplexF64, length(vars), length(inv_vars)))
+    for (i, var) in enumerate(inv_vars)
+        inv_hw_space.space[vars_dict[var], i] = 1
+    end
+    hws_dict = Dict(zip([weight(hws) for hws in hw_spaces_vec], hw_spaces_vec))
+    if haskey(hws_dict, weight(inv_hw_space))
+        hws_dict[weight(inv_hw_space)].space = hcat(hws_dict[weight(inv_hw_space)].space, inv_hw_space.space)
+    else
+        push!(hw_spaces_vec, inv_hw_space)
+    end
+    return hw_spaces_vec
 end
 
 
@@ -90,13 +167,13 @@ struct SumLieAlgebraAction <: AbstractLieAlgebraAction
     actions::Vector{AbstractLieAlgebraAction}
 end
 
-algebra(g::SumLieAlgebraAction) = g.alg
-actions(g::SumLieAlgebraAction) = g.actions
-nsummands(g::SumLieAlgebraAction) = length(actions(g))
-Base.getindex(g::SumLieAlgebraAction, i::Int) = actions(g)[i]
+algebra(a::SumLieAlgebraAction) = a.alg
+actions(a::SumLieAlgebraAction) = a.actions
+nsummands(a::SumLieAlgebraAction) = length(actions(a))
+Base.getindex(a::SumLieAlgebraAction, i::Int) = actions(a)[i]
 
-function Base.show(io::IO, g::SumLieAlgebraAction)
-    println(io, "SumLieAlgebraAction of $(name(algebra(g)))")
+function Base.show(io::IO, a::SumLieAlgebraAction)
+    println(io, "SumLieAlgebraAction of $(name(algebra(a)))")
     # for (i, a) in enumerate(actions(g))
     #     print(io, " action of $(name(algebra(a))): [")
     #     print(io, join([join(vars, ", ") for vars in var_groups(a)], "], ["), "]")
@@ -106,36 +183,45 @@ function Base.show(io::IO, g::SumLieAlgebraAction)
 end
 
 # TODO
-function are_commutative(g₁::AbstractLieAlgebraAction, g₂::AbstractLieAlgebraAction)
+function are_commutative(a₁::AbstractLieAlgebraAction, a₂::AbstractLieAlgebraAction)
     return true
 end
 
-function ⊕(g₁::AbstractLieAlgebraAction, g₂::AbstractLieAlgebraAction)
-    @assert are_commutative(g₁, g₂)
-    alg = algebra(g₁) ⊕ algebra(g₂)
-    return SumLieAlgebraAction(alg, [g₁, g₂])
-end
-
-function ⊕(g₁::SumLieAlgebraAction, g₂::AbstractLieAlgebraAction)
-    @assert are_commutative(g₁, g₂)
-    alg = algebra(g₁) ⊕ algebra(g₂)
-    return SumLieAlgebraAction(alg, [actions(g₁)..., g₂])
-end
-
-function act(elem::LieAlgebraElem{LieAlgebra}, f::Union{Expression, Monomial}, action::LieAlgebraAction)
-    X = as_matrix(elem)
-    return expand(sum([dot(differentiate(f, vars), -X*vars) for vars in var_groups(action)]))
+function ⊕(a₁::AbstractLieAlgebraAction, a₂::AbstractLieAlgebraAction)
+    @assert are_commutative(a₁, a₂)
+    alg = algebra(a₁) ⊕ algebra(a₂)
+    return SumLieAlgebraAction(alg, [a₁, a₂])
 end
 
-function act(elem::LieAlgebraElem{ScalingLieAlgebra}, f::Union{Expression, Monomial}, action::ScalingLieAction)
-    X = as_matrix(elem)
-    return expand(dot(differentiate(f, variables(action)), -X*variables(action)))
+function ⊕(a₁::SumLieAlgebraAction, a₂::AbstractLieAlgebraAction)
+    @assert are_commutative(a₁, a₂)
+    alg = algebra(a₁) ⊕ algebra(a₂)
+    return SumLieAlgebraAction(alg, [actions(a₁)..., a₂])
 end
 
 function act(elem::SumLieAlgebraElem, f::Union{Expression, Monomial}, action::SumLieAlgebraAction)
     return expand(sum([act(elem[i], f, action[i]) for i in 1:nsummands(action)]))
 end
 
+hw_spaces(
+    a::SumLieAlgebraAction,
+    vars::Vector{Variable}
+) = ∩([hw_spaces(action, vars) for action in actions(a)])
+
+function weight_structure(a::AbstractLieAlgebraAction, vars::Vector{Variable})
+    hws = hw_spaces(a, vars)
+    mons = MonomialBasis{Int8,Int16}(vars, degree=1, upto=false)
+    ws = WeightStructure()
+    for hw_space in hws
+        for hwv in hw_space
+            wexpr = WeightExpression(hwv, mons)
+            orb = orbit(wexpr, a)
+            [push!(ws, WeightVector(we)) for we in orb]
+        end
+    end
+    return ws
+end
+
 function as_matrix(elem::AbstractLieAlgebraElem, B::MonomialBasis, action::AbstractLieAlgebraAction)
     @assert algebra(elem) == algebra(action)
     M = zeros(ComplexF64, length(B), length(B))

src/on_varieties/lie-symmetries/lie-algebras/algebras.jl

@@ -2,16 +2,13 @@ export AbstractLieAlgebra,
     ScalingLieAlgebra,
     name,
     dim,
+    exponents,
     rank,
     LieAlgebra,
     basis,
     cartan_subalgebra,
-    positive_roots,
-    negative_roots,
-    set_chevalley_basis!,
-    set_cartan_subalgebra!,
-    set_positive_roots!,
-    set_negative_roots!,
+    positive_root_elements,
+    negative_root_elements,
     weight_structure,
     weights,
     nweights,
@@ -29,15 +26,16 @@ struct ScalingLieAlgebra <: AbstractLieAlgebra
 end
 
 function ScalingLieAlgebra(exps::Matrix{Int})
-    name = size(exps, 1) == 1 ? "ℂˣ" : "(ℂˣ)$(superscript(size(exps, 1)))"
+    name = size(exps, 1) == 1 ? "ℂ" : "ℂ$(superscript(size(exps, 1)))"
     return ScalingLieAlgebra(name, sparse(exps))
 end
 
-ScalingLieAlgebra(size::Int) = ScalingLieAlgebra("ℂˣ", sparse(ones(Int, 1, size)))
+ScalingLieAlgebra(size::Int) = ScalingLieAlgebra("ℂ", sparse(ones(Int, 1, size)))
 
 name(alg::ScalingLieAlgebra) = alg.name
 dim(alg::ScalingLieAlgebra) = size(alg.exps, 1)
-LinearAlgebra.rank(alg::ScalingLieAlgebra) = dim(alg)
+exponents(alg::ScalingLieAlgebra) = alg.exps
+MultivariateInterpolation.rank(alg::ScalingLieAlgebra) = dim(alg)
 Base.size(alg::ScalingLieAlgebra) = size(alg.exps, 2)
 
 function basis(alg::ScalingLieAlgebra; as_matrices::Bool=false)
@@ -64,6 +62,7 @@ mutable struct LieAlgebra <: AbstractLieAlgebra
     name::String
     basis::ChevalleyBasis
     weight_structure::WeightStructure
+    hw_spaces::Vector{WeightSpace}
 end
 
 function Base.show(io::IO, alg::LieAlgebra)
@@ -83,7 +82,8 @@ function so3_lie_algebra()
     neg_roots = [[-1]]
     ch_basis = ChevalleyBasis([X₁, X₂, X₃], cartan, positive, negative, pos_roots, neg_roots)
     ws = WeightStructure([-1, 0, 1], [[1, -im, 0], [0, 0, 1], [1, im, 0]])
-    return LieAlgebra("𝖘𝖔(3,ℂ)", ch_basis, ws)
+    hw_spaces = [WeightSpace([1], [1, im, 0])]
+    return LieAlgebra("𝖘𝖔(3,ℂ)", ch_basis, ws, hw_spaces)
 end
 
 # TODO
@@ -97,7 +97,7 @@ end
 
 name(alg::LieAlgebra) = alg.name
 dim(alg::LieAlgebra) = length(alg.basis.std_basis)
-LinearAlgebra.rank(alg::LieAlgebra) = length(alg.basis.cartan)
+MultivariateInterpolation.rank(alg::LieAlgebra) = length(alg.basis.cartan)
 Base.size(alg::LieAlgebra) = size(alg.basis.std_basis[1], 1)
 
 function basis(alg::LieAlgebra; as_matrices::Bool=false)
@@ -109,35 +109,19 @@ function basis(alg::LieAlgebra; as_matrices::Bool=false)
 end
 
 cartan_subalgebra(alg::LieAlgebra) = [LieAlgebraElem(alg, coeffs) for coeffs in alg.basis.cartan]
-positive_root_elements(alg::LieAlgebra) = [LieAlgebraElem(alg, coeffs, root) for (coeffs, root) in zip(alg.basis.positive, alg.basis.positive_roots)]
-negative_root_elements(alg::LieAlgebra) = [LieAlgebraElem(alg, coeffs, root) for (coeffs, root) in zip(alg.basis.negative, alg.basis.negative_roots)]
-
-# set_chevalley_basis!(
-#     alg::LieAlgebra,
-#     B::NTuple{3, Vector{Vector{T}}} where T <: Number
-# ) = alg.chevalley_basis = B
-
-# set_cartan_subalgebra!(
-#     alg::LieAlgebra,
-#     B::Vector{Vector{T}} where T <: Number
-# ) = alg.chevalley_basis[1] = B
-
-# set_positive_roots!(
-#     alg::LieAlgebra,
-#     B::Vector{Vector{T}} where T <: Number
-# ) = alg.chevalley_basis[2] = B
-
-# set_negative_roots!(
-#     alg::LieAlgebra,
-#     B::Vector{Vector{T}} where T <: Number
-# ) = alg.chevalley_basis[3] = B
-
+positive_root_elements(
+    alg::LieAlgebra
+) = [LieAlgebraElem(alg, coeffs, root) for (coeffs, root) in zip(alg.basis.positive, alg.basis.positive_roots)]
+negative_root_elements(
+    alg::LieAlgebra
+) = [LieAlgebraElem(alg, coeffs, root) for (coeffs, root) in zip(alg.basis.negative, alg.basis.negative_roots)]
 weight_structure(alg::LieAlgebra) = alg.weight_structure
 weights(alg::LieAlgebra) = alg.weight_structure.weights
 weights(alg::LieAlgebra, inds...) = getindex(alg.weight_structure.weights, inds...)
 nweights(alg::LieAlgebra) = nweights(alg.weight_structure)
 weight_spaces(alg::LieAlgebra) = alg.weight_structure.weight_spaces
 weight_spaces(alg::LieAlgebra, inds...) = getindex(alg.weight_structure.weight_spaces, inds...)
+hw_spaces(alg::LieAlgebra) = alg.hw_spaces
 
 
 struct SumLieAlgebra <: AbstractLieAlgebra
@@ -148,7 +132,7 @@ end
 name(g::SumLieAlgebra) = g.name
 algebras(g::SumLieAlgebra) = g.algs
 dim(g::SumLieAlgebra) = sum([dim(alg) for alg in algebras(g)])
-LinearAlgebra.rank(g::SumLieAlgebra) = sum([rank(alg) for alg in algebras(g)])
+MultivariateInterpolation.rank(g::SumLieAlgebra) = sum([rank(alg) for alg in algebras(g)])
 
 ⊕(
     alg₁::AbstractLieAlgebra,