Add new weight structures and enhance decomposition functions

Author: vitktor

src/DecomposingRepresentations.jl

@@ -40,6 +40,8 @@ include("representations/irred-reprs.jl")
 include("representations/isotypic-comps.jl")
 include("representations/reprs.jl")
 
+include("decompositions/abs-weight-struct.jl")
+
 include("decompositions/irred-decomp.jl")
 include("decompositions/isotypic-decomp.jl")
 

src/decompositions/abs-weight-struct.jl

@@ -0,0 +1,17 @@
+abstract type AbstractWeightStruct end
+
+struct TensorWeightStruct <: AbstractWeightStruct
+    w₁::Weight
+    w₂::Weight
+end
+
+Base.hash(s::TensorWeightStruct, h::UInt) = Base.hash((s.w₁, s.w₂), h)
+Base.:(==)(s₁::TensorWeightStruct, s₂::TensorWeightStruct) = ((s₁.w₁ == s₂.w₁) && (s₁.w₂ == s₂.w₂)) || ((s₁.w₁ == s₂.w₂) && (s₁.w₂ == s₂.w₁))
+
+struct SymWeightStruct <: AbstractWeightStruct
+    w::Weight
+    p::Int
+end
+
+Base.hash(s::SymWeightStruct, h::UInt) = Base.hash((s.w, s.p), h)
+Base.:(==)(s₁::SymWeightStruct, s₂::SymWeightStruct) = (s₁.w == s₂.w) && (s₁.p == s₂.p)

src/decompositions/irred-decomp.jl

@@ -33,14 +33,19 @@ function common_nullspace_as_weight_vectors(
 )
     dim(ws) == 1 && return [WeightVector(weight(ws), v) for v in basis(space(ws))]
 
-    logging && printstyled("Looking for the highest weight vectors in $(str_irr("W", weight(ws))) of dimension $(dim(ws))...\n", color=:green)
+    logging && printstyled("Looking for $(nhwv) highest weight vectors in $(str_irr("W", weight(ws))) of dimension $(dim(ws))...\n", color=:green)
     wsₙ = ws
     for X in Xs
         wsₙ = ws_nullspace(X, a, wsₙ)
-        isnothing(wsₙ) && return WeightVector[]
+        if isnothing(wsₙ)
+            logging && printstyled("Found no common nullspace, smth is wrong!\n", color=:red)
+            return WeightVector[] # error("Didn't find any highest weight vectors, had to find $(nhwv)")
+        end
     end
 
-    @assert dim(wsₙ) == nhwv
+    if dim(wsₙ) != nhwv
+        error("Found $(dim(wsₙ)) highest weight vectors, expected $(nhwv)")
+    end
     logging && printstyled("Found: ", color=:green)
     logging && printstyled("$(join(map(repr, basis(space(wsₙ))), ", "))\n", color=:green)
 
@@ -70,7 +75,8 @@ end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S};
-    logging::Bool=true
+    logging::Bool=true,
+    decomp_count::Union{Dict{AbstractWeightStruct, Int},Nothing}=nothing
 ) where {A<:AbstractGroupAction{Lie}, S<:VariableSpace}
     logging && printstyled("Decomposing the space of variables $(to_string(space(ρ))) into irreducibles...\n", color=:red)
 
@@ -86,14 +92,19 @@ end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S};
-    logging::Bool=true
+    logging::Bool=true,
+    decomp_count::Dict{AbstractWeightStruct, Int}=nothing
 ) where {T, F, A<:AbstractGroupAction{Lie}, S<:SymmetricPower{T, F, <:HighestWeightModule}}
     V = space(ρ)
     logging && printstyled("Decomposing $(to_string(V)) into irreducibles...\n", color=:blue)
 
     Vb = base_space(V)
-    power(V) == 1 && return [IrreducibleRepresentation(action(ρ), Vb)]
     ws = weight_structure(Vb)
+
+    if !isnothing(decomp_count)
+        t = SymWeightStruct(highest_weight(Vb), power(V))
+        decomp_count[t] = get(decomp_count, t, 0) + 1
+    end
 
     logging && printstyled("Applying Clebsch-Gordan to decompose $(to_string(V)) into irreducibles...\n", color=:blue)
     sym_ws, cg_decomp = sym_weight_struct(highest_weight(Vb), algebra(action(ρ)), power(V), ws)
@@ -106,22 +117,24 @@ end
 
 function irreducibles(
     ρ::GroupRepresentation{A, T};
-    logging::Bool=true
+    logging::Bool=true,
+    decomp_count::Dict{AbstractWeightStruct, Int}=nothing
 ) where {A<:AbstractGroupAction{Lie}, T<:SymmetricPower}
     V = space(ρ)
     logging && printstyled("Decomposing $(to_string(V)) into irreducibles...\n", color=:magenta)
 
     ρ_base = GroupRepresentation(action(ρ), base_space(V))
-    irreds_base = irreducibles(ρ_base)
+    irreds_base = irreducibles(ρ_base; decomp_count=decomp_count)
     if length(irreds_base) == 1
         logging && printstyled("$(to_string(base_space(V))) is already irreducible, decomposing its symmetric power directly...\n", color=:magenta)
         V = SymmetricPower(space(first(irreds_base)), power(V))
         ρᵢ = GroupRepresentation(action(ρ), V)
-        return irreducibles(ρᵢ)
+        return irreducibles(ρᵢ; decomp_count=decomp_count)
     end
     mexps = multiexponents(degree=power(V), nvars=length(irreds_base))
 
     Vs = [TensorProduct([SymmetricPower(space(irreds_base[idx]), val) for (val, idx) in zip(mexp.nzval, mexp.nzind)]) for mexp in mexps]
+    @assert dim(V) == sum([dim(Vᵢ) for Vᵢ in Vs])
     if logging
         printstyled("Sym$(superscript(power(V)))(", color=:magenta)
         printstyled(join([to_string(space(irr)) for irr in irreds_base], " ⊕ "), ") = ", color=:magenta)
@@ -132,22 +145,40 @@ function irreducibles(
     irreds = IrreducibleRepresentation{A}[]
     for Vᵢ in Vs
         ρᵢ = GroupRepresentation(action(ρ), Vᵢ)
-        append!(irreds, irreducibles(ρᵢ))
+        append!(irreds, irreducibles(ρᵢ; decomp_count=decomp_count))
     end
     return irreds
 end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S};
-    logging::Bool=true
+    logging::Bool=true,
+    decomp_count::Dict{AbstractWeightStruct, Int}=nothing
 ) where {T, F, A<:AbstractGroupAction{Lie}, S<:TensorProduct{T, F, <:HighestWeightModule, <:HighestWeightModule}}
-    logging && printstyled("Decomposing $(to_string(V)) into irreducibles...\n", color=:blue)
     V = space(ρ)
-    hw₁, hw₂ = highest_weight(first(V)), highest_weight(second(V))
+    logging && printstyled("Decomposing $(to_string(V)) into irreducibles...\n", color=:blue)
+
+    V₁, V₂ = first(V), second(V)
+    if dim(V₁) == 1 || dim(V₂) == 1
+        logging && printstyled("One of the factors is 1-dimensional, returning the tensor product of the highest weight vectors\n", color=:red)
+        return [IrreducibleRepresentation(action(ρ), hw_vector(V₁)*hw_vector(V₂))]
+    end
+
+    hw₁, hw₂ = highest_weight(V₁), highest_weight(V₂)
+    if !isnothing(decomp_count)
+        t = TensorWeightStruct(hw₁, hw₂)
+        decomp_count[t] = get(decomp_count, t, 0) + 1
+    end
 
     logging && printstyled("Applying Clebsch-Gordan to decompose $(to_string(V)) into irreducibles...\n", color=:blue)
-    ws₁, ws₂ = weight_structure(first(V)), weight_structure(second(V)) # TODO: save once computed
-    tensor_ws, cg_decomp = tensor_weight_struct(hw₁, hw₂, algebra(action(ρ)), ws₁, ws₂)
+    cg_decomp = tensor(hw₁, hw₂, algebra(action(ρ)))
+    if length(cg_decomp) == 1
+        logging && printstyled("The tensor product is irreducible, returning the tensor product of the highest weight vectors\n", color=:red)
+        return [IrreducibleRepresentation(action(ρ), hw_vector(V₁)*hw_vector(V₂))]
+    end
+
+    ws₁, ws₂ = weight_structure(V₁), weight_structure(V₂) # TODO: speed up, but how?
+    tensor_ws = tensor_weight_struct(cg_decomp, ws₁, ws₂)
     logging && printstyled(to_string(V), " = ", join([str_irr("V", w) for w in weights(tensor_ws)], " ⊕ "), "\n", color=:blue)
 
     Xs = positive_root_elements(algebra(action(ρ)))
@@ -157,12 +188,17 @@ end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S};
-    logging::Bool=true
+    logging::Bool=true,
+    decomp_count::Dict{AbstractWeightStruct, Int}=nothing
 ) where {A<:AbstractGroupAction{Lie}, S<:TensorProduct}
     V = space(ρ)
     logging && printstyled("Decomposing $(to_string(V)) into irreducibles...\n", color=:magenta)
-    irrs₁ = irreducibles(GroupRepresentation(action(ρ), first(space(ρ))))
-    irrs₂ = irreducibles(GroupRepresentation(action(ρ), second(space(ρ))))
+    
+    irrs₁ = irreducibles(GroupRepresentation(action(ρ), first(space(ρ))); decomp_count=decomp_count)
+    @assert sum([dim(space(irr)) for irr in irrs₁]) == dim(first(space(ρ)))
+    
+    irrs₂ = irreducibles(GroupRepresentation(action(ρ), second(space(ρ))); decomp_count=decomp_count)
+    @assert sum([dim(space(irr)) for irr in irrs₂]) == dim(second(space(ρ)))
 
     logging && printstyled("Decomposing tensor product knowing irreducibles of the factors...\n", color=:magenta)
     logging && printstyled("($(join([to_string(space(irr)) for irr in irrs₁], " ⊕ "))) ⊗ ", color=:magenta)
@@ -173,7 +209,9 @@ function irreducibles(
     for irr₁ in irrs₁, irr₂ in irrs₂
         V = TensorProduct([space(irr₁), space(irr₂)])
         ρV = GroupRepresentation(action(ρ), V)
-        append!(irreds, irreducibles(ρV))
+        irrs = irreducibles(ρV; decomp_count=decomp_count)
+        @assert sum([dim(space(irr)) for irr in irrs]) == dim(V)
+        append!(irreds, irrs)
     end
     return irreds
 end
@@ -182,14 +220,16 @@ function irreducibles(
     ρ::GroupRepresentation{A, S}
 ) where {A<:AbstractGroupAction{Lie}, S<:FixedDegreePolynomials}
     V = space(ρ)
-    return irreducibles(GroupRepresentation(action(ρ), SymmetricPower(var_space(V), degree(V))))
+    d = Dict{AbstractWeightStruct, Int}()
+    return irreducibles(GroupRepresentation(action(ρ), SymmetricPower(var_space(V), degree(V))); decomp_count=d), d
 end
 
 function irreducibles(
     ρ::GroupRepresentation{A, S}
 ) where {A<:AbstractGroupAction{Lie}, S<:FixedMultidegreePolynomials}
     V = space(ρ)
-    return irreducibles(GroupRepresentation(action(ρ), TensorProduct([SymmetricPower(Vᵢ, dᵢ) for (Vᵢ, dᵢ) in zip(var_spaces(V), degrees(V))])))
+    d = Dict{AbstractWeightStruct, Int}()
+    return irreducibles(GroupRepresentation(action(ρ), TensorProduct([SymmetricPower(Vᵢ, dᵢ) for (Vᵢ, dᵢ) in zip(var_spaces(V), degrees(V))])); decomp_count=d), d
 end
 
 

src/decompositions/isotypic-decomp.jl

@@ -1,5 +1,6 @@
 export IsotypicDecomposition,
-    invariant_component
+    invariant_component,
+    representation
 
 struct IsotypicDecomposition{A<:AbstractGroupAction{Lie}, T<:GroupRepresentation{A}, W<:Weight, Ic<:IsotypicComponent}
     ρ::T
@@ -62,8 +63,8 @@ Base.iterate(ID::IsotypicDecomposition, state) = iterate(isotypic_components(ID)
 function Base.show(io::IO, iso::IsotypicDecomposition)
     println(io, "IsotypicDecomposition of $(name(group(iso)))-action on $(dim(iso))-dimensional vector space")
     println(io, " number of isotypic components: ", nisotypic(iso))
-    println(io, " multiplicities of irreducibles: ", join([mul(ic) for ic in isotypic_components(iso)], ", "))
-    print(io, " dimensions of isotypic components: ", join([dim(ic) for ic in isotypic_components(iso)], ", "))
+    println(io, " maximum multiplicity of irreducibles: ", maximum([mul(ic) for ic in isotypic_components(iso)]))
+    print(io, " maximum dimension of isotypic components: ", maximum([dim(ic) for ic in isotypic_components(iso)]))
 end
 
 invariant_component(

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

@@ -1,4 +1,4 @@
-export sym_weight_muls_dict
+export sym_weight_muls_dict, ⊗
 
 # TODO: works only for so(3)
 function ⊗(hw₁::Weight, hw₂::Weight, ::LieAlgebra)
@@ -32,9 +32,16 @@ end
 
 function tensor(hw₁::Weight, hw₂::Weight, A::AbstractLieAlgebra)
     ws = ⊗(hw₁, hw₂, A)
-    return Dict(zip(ws, ones(Int, length(ws)))) # TODO: Each weight has multiplicity 1
+    ws_muls = Dict(zip(ws, ones(Int, length(ws)))) # TODO: Each weight has multiplicity 1
+    @assert weyl_dim(ws_muls, A) == weyl_dim(hw₁, A)*weyl_dim(hw₂, A)
+    return ws_muls
 end
 
+weyl_dim(
+    ws_muls::Dict{W, Int},
+    A::AbstractLieAlgebra
+) where W<:Weight = sum([weyl_dim(w, A)*m for (w, m) in ws_muls])
+
 # TODO: works only for so(3)
 hw2all(hw::Weight, ::LieAlgebra) = [Weight([j]) for j in -hw[1]:hw[1]]
 hw2all(hw::Weight, ::ScalingLieAlgebra) = [hw]
@@ -114,5 +121,6 @@ function sym(hw::W, A::AbstractLieAlgebra, p::Int) where W<:Weight
     sym_hw, ws_dict = sym_weight_muls_dict(hw, A, p)
     decomp_hws = Dict{W, Int}() # for the weight key gives its multiplicity
     sym!(sym_hw, A, ws_dict, decomp_hws)
+    @assert weyl_dim(decomp_hws, A) == binomial(weyl_dim(hw, A) + p - 1, p)
     return decomp_hws
 end

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

@@ -142,20 +142,17 @@ function tensor_weight_combs_dict(ws₁::Vector{W}, ws₂::Vector{W}) where W<:W
 end
 
 function tensor_weight_struct(
-    hw₁::W,
-    hw₂::W,
-    A::AbstractLieAlgebra,
+    cg_decomp::Dict{W, Int},
     ws₁::WeightStructure{T,W},
     ws₂::WeightStructure{T,W}
 ) where {T, W<:Weight}
-    dir_sum_hws = tensor(hw₁, hw₂, A)
     ws_dict = tensor_weight_combs_dict(weights(ws₁), weights(ws₂))
     new_ws = WeightStructure{T,W}()
-    for hw in keys(dir_sum_hws)
+    for hw in keys(cg_decomp)
         combs = ws_dict[hw]
         w_sps = [*([weight_space(ws₁, comb[1]; as_space=true), weight_space(ws₂, comb[2]; as_space=true)]) for comb in combs]
         total_ws = +(w_sps...)
         push!(new_ws, WeightSpace(hw, total_ws))
     end
-    return new_ws, dir_sum_hws
+    return new_ws
 end

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

@@ -17,4 +17,9 @@ end
 
 function Base.show(io::IO, wv::WeightVector)
     print(io, "WeightVector with weight $(weight(wv))")
-end
+end
+
+Base.:*(
+    wv₁::WeightVector{T, W},
+    wv₂::WeightVector{T, W}
+) where {T<:Polynomial, W<:Weight} = WeightVector(wv₁.weight + wv₂.weight, wv₁.vector * wv₂.vector)

src/representations/irred-reprs.jl

@@ -19,7 +19,7 @@ action(ρ::IrreducibleRepresentation) = ρ.action
 hw_vector(ρ::IrreducibleRepresentation) = hw_vector(ρ.hw_module)
 space(ρ::IrreducibleRepresentation) = HighestWeightModule(action(ρ), hw_vector(ρ))
 highest_weight(ρ::IrreducibleRepresentation) = weight(hw_vector(ρ))
-irreducibles(ρ::IrreducibleRepresentation) = [ρ]
+irreducibles(ρ::IrreducibleRepresentation; decomp_count=nothing) = [ρ]
 isotypic_components(ρ::IrreducibleRepresentation) = [IsotypicComponent(ρ)]
 
 function Base.show(io::IO, ::MIME"text/plain", ρ::IrreducibleRepresentation)

src/representations/isotypic-comps.jl

@@ -1,5 +1,6 @@
 export IsotypicComponent,
-    mul
+    mul,
+    hw_vectors
 
 
 struct IsotypicComponent{
@@ -18,7 +19,7 @@ mul(ρ::IsotypicComponent) = length(ρ.irreds)
 space(ρ::IsotypicComponent) = DirectSum([space(ρᵢ) for ρᵢ in irreducibles(ρ)])
 basis(ρ::IsotypicComponent) = basis(space(ρ))
 dim(ρ::IsotypicComponent) = sum([dim(ρᵢ) for ρᵢ in irreducibles(ρ)])
-hw_vectors(ρ::IsotypicComponent) = [hw_vector(ρᵢ) for ρᵢ in irreducibles(ρ)]
+hw_vectors(ρ::IsotypicComponent; as_vectors::Bool=false) = [as_vectors ? vector(hw_vector(ρᵢ)) : hw_vector(ρᵢ) for ρᵢ in irreducibles(ρ)]
 isotypic_components(ρ::IsotypicComponent) = [ρ]
 
 function Base.show(io::IO, ::MIME"text/plain", ρ::IsotypicComponent)