improve new lie algebras model

Author: vitktor

src/MultivariateInterpolation.jl

@@ -30,8 +30,11 @@ include("on_varieties/sampling.jl")
 include("on_varieties/expression_map.jl")
 include("on_varieties/varieties/map_graph.jl")
 
+include("on_varieties/lie-symmetries/weights.jl")
 include("on_varieties/lie-symmetries/lie-algebras.jl")
+include("on_varieties/lie-symmetries/lie-reprs.jl")
 include("on_varieties/lie-symmetries/scalings.jl")
+
 include("on_varieties/interpolation.jl")
 
 end

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

@@ -1,3 +1,33 @@
+export AbstractLieAlgebra,
+    ScalingLieAlgebra,
+    name,
+    dim,
+    LieAlgebra,
+    basis,
+    cartan_subalgebra,
+    positive_roots,
+    negative_roots,
+    set_chevalley_basis!,
+    set_cartan_subalgebra!,
+    set_positive_roots!,
+    set_negative_roots!,
+    weight_structure,
+    weights,
+    nweights,
+    weight_spaces,
+    SumLieAlgebra,
+    ⊕,
+    AbstractLieAlgebraElem,
+    LieAlgebraElem,
+    as_matrix,
+    act,
+    SumLieAlgebraElem,
+    AbstractLieAlgebraAction,
+    LieAlgebraAction,
+    ScalingLieAction,
+    SumLieAlgebraAction
+
+
 abstract type AbstractLieAlgebra end
 
 struct ScalingLieAlgebra <: AbstractLieAlgebra
@@ -9,7 +39,7 @@ name(alg::ScalingLieAlgebra) = alg.name
 dim(alg::ScalingLieAlgebra) = alg.dim
 
 # Implements basic matrix Lie algebra
-struct LieAlgebra <: AbstractLieAlgebra
+mutable struct LieAlgebra <: AbstractLieAlgebra
     name::String
     basis::Vector{Matrix{ComplexF64}}
     chevalley_basis::Vector{Vector{Vector{ComplexF64}}} # given by coefficients in basis; [cartan, positive, negative]
@@ -96,6 +126,13 @@ struct SumLieAlgebra <: AbstractLieAlgebra
     algs::Vector{AbstractLieAlgebra}
 end
 
+algebras(g::SumLieAlgebra) = g.algs
+name(g::SumLieAlgebra) = join([name(alg) for alg in algebras(g)], " ⊕ ")
+
+⊕(
+    alg₁::LieAlgebra,
+    alg₂::LieAlgebra
+) = SumLieAlgebra([alg₁, alg₂])
 
 abstract type AbstractLieAlgebraElem end
 
@@ -191,6 +228,35 @@ struct LieAlgebraAction <: AbstractLieAlgebraAction
     vars::Vector{Vector{Variable}}
 end
 
+LieAlgebraAction(
+    alg::LieAlgebra,
+    vars::AbstractVecOrMat{Variable}
+) = LieAlgebraAction(alg, M2VV(hcat(vars)))
+
+LieAlgebraAction(
+    alg::LieAlgebra,
+    vars::AbstractArray
+) = LieAlgebraAction(alg, M2VV(hcat(vars...)))
+
+algebra(g::LieAlgebraAction) = g.alg
+action(g::LieAlgebraAction) = g.vars
+
+function Base.show(io::IO, g::LieAlgebraAction)
+    println(io, "LieAlgebraAction of $(name(algebra(g)))")
+    print(io, " action: [", join([join(vars, ", ") for vars in action(g)], "], ["), "]")
+end
+
+# TODO
+function are_commutative(g₁::LieAlgebraAction, g₂::LieAlgebraAction)
+    return true
+end
+
+function ⊕(g₁::LieAlgebraAction, g₂::LieAlgebraAction)
+    @assert are_commutative(g₁, g₂)
+    alg = algebra(g₁) ⊕ algebra(g₂)
+    return SumLieAlgebraAction(alg, [g₁, g₂])
+end
+
 struct ScalingLieAction{T<:AbstractMatrix{<:Integer}} <: AbstractLieAlgebraAction
     alg::ScalingLieAlgebra
     vars::Vector{Variable}
@@ -201,3 +267,16 @@ struct SumLieAlgebraAction <: AbstractLieAlgebraAction
     alg::SumLieAlgebra
     actions::Vector{AbstractLieAlgebraAction}
 end
+
+algebra(g::SumLieAlgebraAction) = g.alg
+actions(g::SumLieAlgebraAction) = g.actions
+nsummands(g::SumLieAlgebraAction) = length(actions(g))
+
+function Base.show(io::IO, g::SumLieAlgebraAction)
+    println(io, "SumLieAlgebraAction of $(name(algebra(g)))")
+    for (i, a) in enumerate(actions(g))
+        print(io, " action of $(name(algebra(a))): [")
+        print(io, join([join(vars, ", ") for vars in action(a)], "], ["), "]")
+        i < nsummands(g) && print(io, "\n")
+    end
+end

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

@@ -1,3 +1,16 @@
+export AbstractLieAlgebraRepresentation,
+    IrreducibleRepresentation,
+    space_basis,
+    to_expressions,
+    IsotypicComponent,
+    mul,
+    irreducible_components,
+    PolynomialVectorSpace,
+    is_upto,
+    LieAlgebraRepresentation,
+    space,
+    isotypic_components
+
 abstract type AbstractLieAlgebraRepresentation end
 
 struct IrreducibleRepresentation{T<:AbstractLieAlgebraAction} <: AbstractLieAlgebraRepresentation
@@ -52,10 +65,10 @@ struct PolynomialVectorSpace
 end
 
 PolynomialVectorSpace(;
-    variables::Vector{Variable},
+    variables::AbstractArray,
     degree::Int,
     upto::Bool=true
-) = PolynomialVectorSpace(variables, degree, upto)
+) = PolynomialVectorSpace(Variable.(collect(flatten(variables))), degree, upto)
 
 variables(V::PolynomialVectorSpace) = V.vars
 nvariables(V::PolynomialVectorSpace) = length(V.vars)
@@ -75,7 +88,9 @@ Base.:(==)(
 
 function Base.show(io::IO, V::PolynomialVectorSpace)
     println(io, "PolynomialVectorSpace of dimension $(dim(V))")
-    print(io, " variables: $(variables(V))")
+    println(io, " $(nvariables(V)) variables: ", join(variables(V), ", "))
+    println(io, " degree of polynomials: $(degree(V))")
+    print(io, " homogeneous: $(!is_upto(V))")
 end
 
 
@@ -85,6 +100,11 @@ struct LieAlgebraRepresentation{T<:AbstractLieAlgebraAction} <: AbstractLieAlgeb
     isotypic::Vector{IsotypicComponent{T}}
 end
 
+LieAlgebraRepresentation(
+    action::T,
+    V::PolynomialVectorSpace
+) where {T<:AbstractLieAlgebraAction} = LieAlgebraRepresentation{T}(action, V, [])
+
 function LieAlgebraRepresentation(
     alg::LieAlgebra,
     V::PolynomialVectorSpace,
@@ -104,20 +124,21 @@ function LieAlgebraRepresentation(
     return LieAlgebraRepresentation(alg, V, var_groups, iso_comps)
 end
 
-algebra(π::LieAlgebraRepresentation) = π.alg
+action(π::LieAlgebraRepresentation) = π.action
+algebra(π::LieAlgebraRepresentation) = algebra(π.action)
 space(π::LieAlgebraRepresentation) = π.V
 isotypic_components(π::LieAlgebraRepresentation) = π.isotypic
 irreducible_components(π::LieAlgebraRepresentation) = vcat([irreducible_components(iso) for iso in π.isotypic]...)
-dim(π::LieAlgebraRepresentation) = sum([dim(ic) for ic in isotypic_components(π)])
+dim(π::LieAlgebraRepresentation) = dim(space(π))
 
 # called by Shift+Enter
 function Base.show(io::IO, mime::MIME"text/plain", π::LieAlgebraRepresentation)
     println(
         io,
-        "LieAlgebraRepresentation of $(name(π.alg)) ",
+        "LieAlgebraRepresentation of $(name(algebra(π))) ",
         "on the $(dim(π))-dimensional vector space:"
     )
-    show(io, mime, π.var_groups)
+    show(io, mime, action(π))
     # print(io, " action on variables: $(π.var_groups)")
 end
 
@@ -133,6 +154,38 @@ function nullspace_as_weight_vectors(
     return wvs
 end
 
+function sym_weight_structure(alg::LieAlgebra, d::Integer, mexps::Vector{<:SparseVector})
+    d = Int(d)
+    d == 0 && return WeightStructure([0], [[1;;]])
+    d == 1 && return weight_structure(alg)
+    combs = multiexponents(; degree=d, nvars=nweights(alg))
+    new_weights_dict = Dict{Vector{Int}, Vector{typeof(combs[1])}}()
+    for comb in combs
+        w = sum([comb.nzval[i]*weights(alg, comb.nzind[i]) for i in 1:length(comb.nzind)])
+        val = get(new_weights_dict, w, nothing)
+        if isnothing(val)
+            new_weights_dict[w] = [comb]
+        else
+            push!(new_weights_dict[w], comb)
+        end
+    end
+    new_weights = [zeros(Int, 0) for _ in 1:length(new_weights_dict)]
+    new_weight_spaces = [zeros(ComplexF64, 0, 0) for _ in 1:length(new_weights_dict)]
+    for (i, (weight, combs)) in enumerate(new_weights_dict)
+        new_weights[i] = weight
+        Ms = [⊙(weight_spaces(alg, comb.nzind), comb.nzval, mexps) for comb in combs]
+        new_weight_spaces[i] = hcat(Ms...)
+    end
+    return WeightStructure(new_weights, new_weight_spaces)
+end
+
+tensor_weight_structure(
+    alg::LieAlgebra,
+    ds::AbstractVector{<:Integer},
+    v_mexps::Vector{<:Vector{<:SparseVector}},
+    tensor_basis # TODO: add type
+) = tensor_weight_structure([sym_weight_structure(alg, d, mexps) for (d, mexps) in zip(ds, v_mexps)], tensor_basis)
+
 function weight_module(
     alg::LieAlgebra,
     variables::Vector{Vector{Variable}},
@@ -159,9 +212,8 @@ end
 
 # TODO: supposes that all the vars in V occur in var_groups
 function LieAlgebraRepresentation(
-    alg::LieAlgebra,
-    V::PolynomialVectorSpace;
-    action::Vector{Vector{Variable}}
+    action::LieAlgebraAction,
+    V::PolynomialVectorSpace
 )
     @assert issetequal(vcat(action...), variables(V))
     groups_mexps = multiexponents(degree=degree(V), nvars=length(action), upto=is_upto(V))

src/on_varieties/lie-symmetries/weights.jl

@@ -1,3 +1,18 @@
+export WeightStructure,
+    weights,
+    nweights,
+    weight_spaces,
+    WeightVector,
+    weight,
+    vector,
+    WeightModule,
+    basis,
+    weight_structure,
+    HighestWeightModule,
+    highest_weight,
+    highest_weight_vector
+
+
 struct WeightStructure
     weights::Vector{Vector{Int}}
     weight_spaces::Vector{Matrix{ComplexF64}}
@@ -48,31 +63,6 @@ basis(hwm::HighestWeightModule) = hwm.basis
 highest_weight(hwm::HighestWeightModule) = weight(hwm.hw_vector)
 highest_weight_vector(hwm::HighestWeightModule) = hwm.hw_vector
 
-function sym_weight_structure(alg::LieAlgebra, d::Integer, mexps::Vector{<:SparseVector})
-    d = Int(d)
-    d == 0 && return WeightStructure([0], [[1;;]])
-    d == 1 && return weight_structure(alg)
-    combs = multiexponents(; degree=d, nvars=nweights(alg))
-    new_weights_dict = Dict{Vector{Int}, Vector{typeof(combs[1])}}()
-    for comb in combs
-        w = sum([comb.nzval[i]*weights(alg, comb.nzind[i]) for i in 1:length(comb.nzind)])
-        val = get(new_weights_dict, w, nothing)
-        if isnothing(val)
-            new_weights_dict[w] = [comb]
-        else
-            push!(new_weights_dict[w], comb)
-        end
-    end
-    new_weights = [zeros(Int, 0) for _ in 1:length(new_weights_dict)]
-    new_weight_spaces = [zeros(ComplexF64, 0, 0) for _ in 1:length(new_weights_dict)]
-    for (i, (weight, combs)) in enumerate(new_weights_dict)
-        new_weights[i] = weight
-        Ms = [⊙(weight_spaces(alg, comb.nzind), comb.nzval, mexps) for comb in combs]
-        new_weight_spaces[i] = hcat(Ms...)
-    end
-    return WeightStructure(new_weights, new_weight_spaces)
-end
-
 function tensor_weight_structure(
     v_ws::Vector{WeightStructure},
     tensor_basis # TODO: add type
@@ -98,10 +88,3 @@ function tensor_weight_structure(
     end
     return WeightStructure(new_weights, new_weight_spaces)
 end
-
-tensor_weight_structure(
-    alg::LieAlgebra,
-    ds::AbstractVector{<:Integer},
-    v_mexps::Vector{<:Vector{<:SparseVector}},
-    tensor_basis # TODO: add type
-) = tensor_weight_structure([sym_weight_structure(alg, d, mexps) for (d, mexps) in zip(ds, v_mexps)], tensor_basis)