add colored info output

Author: vitktor

Project.toml

@@ -5,6 +5,7 @@ version = "1.0.0-DEV"
 
 [deps]
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
+Crayons = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
 DynamicPolynomials = "7c1d4256-1411-5781-91ec-d7bc3513ac07"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LinearAlgebraX = "9b3f67b0-2d00-526e-9884-9e4938f8fb88"

src/DecomposingRepresentations.jl

@@ -11,6 +11,7 @@ export @polyvar, Variable, Monomial, Polynomial, Commutative, CreationOrder, Gra
 using Combinatorics: partitions, multiset_permutations, combinations, with_replacement_combinations
 
 using Base.Iterators: product, flatten
+using Crayons
 
 include("utils/basic.jl")
 include("utils/Gauss-Jordan.jl")

src/decompositions/irred-decomp.jl

@@ -4,10 +4,14 @@ function ws_nullspace(
     X::AbstractLieAlgebraElem,
     a::AbstractGroupAction{Lie},
     ws::WeightSpace;
-    tol::Real=1e-5
+    tol::Real=1e-5,
+    logging::Bool=true
 )
     B = basis(space(ws))
     Bₐ = [act(X, a, f) for f in B]
+
+    logging && print(crayon"#f4d03f", "Applied 'act' method $(dim(space(ws))) times\n")
+
     if all(f -> isapprox(f, zero(f), atol=tol), Bₐ)
         return ws
     end
@@ -16,28 +20,43 @@ function ws_nullspace(
     isempty(Cs) && return nothing
     return WeightSpace(
         weight(ws),
-        PolySpace{field_type(ws)}([sum(c .* B) for c in Cs])
+        PolySpace{field_type(ws)}([div_by_smallest_coeff(sum(c .* B)) for c in Cs])
         )
 end
 
 function common_nullspace_as_weight_vectors(
     Xs::Vector{<:AbstractLieAlgebraElem},
     a::AbstractGroupAction{Lie},
-    ws::WeightSpace
+    ws::WeightSpace,
+    nhwv::Int;
+    logging::Bool=true
 )
+    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)
     wsₙ = ws
     for X in Xs
         wsₙ = ws_nullspace(X, a, wsₙ)
         isnothing(wsₙ) && return WeightVector[]
     end
-    return [WeightVector(weight(wsₙ), div_by_smallest_coeff(v)) for v in basis(space(wsₙ))]
+
+    @assert dim(wsₙ) == nhwv
+    logging && printstyled("Found: ", color=:green)
+    logging && printstyled("$(join(map(repr, basis(space(wsₙ))), ", "))\n", color=:green)
+
+    return [WeightVector(weight(wsₙ), div_by_smallest_coeff(v)) for v in basis(space(wsₙ))] # TODO: remove div_by_smallest_coeff
 end
 
-common_nullspace_as_weight_vectors(
+function common_nullspace_as_weight_vectors(
     Xs::Vector{<:AbstractLieAlgebraElem},
     a::AbstractGroupAction{Lie},
-    ws::WeightStructure
-) = vcat([common_nullspace_as_weight_vectors(Xs, a, w) for w in ws]...)
+    ws::WeightStructure,
+    cg_decomp::Dict{<:Weight, Int}
+)
+    return vcat([begin
+        common_nullspace_as_weight_vectors(Xs, a, ws[w], cg_decomp[w])
+    end for w in weights(ws)]...)
+end
 
 function irreducibles(
     ρ::GroupRepresentation{A, T}
@@ -50,135 +69,111 @@ function irreducibles(
 end
 
 function irreducibles(
-    ρ::GroupRepresentation{A, S}
+    ρ::GroupRepresentation{A, S};
+    logging::Bool=true
 ) where {A<:AbstractGroupAction{Lie}, S<:VariableSpace}
-    ws = weight_structure(action(ρ), space(ρ))
-    Xs = positive_root_elements(algebra(action(ρ)))
-    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), ws)
+    logging && printstyled("Decomposing the space of variables $(to_string(space(ρ))) into irreducibles...\n", color=:red)
+
+    hws = hw_spaces(action(ρ), space(ρ))
+    hw_vectors = [hwv for ws in hws for hwv in ws]
+
+    logging && printstyled("⟨$(join(map(repr, basis(space(ρ))), ", "))⟩ = ", color=:red)
+    logging && printstyled(join([str_irr("V", weight(hwv)) for hwv in hw_vectors], " ⊕ "), "\n", color=:red)
+    logging && printstyled("$(length(hw_vectors)) irreducibles\n", color=:red)
+    
     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, S}
+    ρ::GroupRepresentation{A, S};
+    logging::Bool=true
 ) 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)
-    sym_ws = sym_weight_struct(highest_weight(Vb), algebra(action(ρ)), power(V), ws)
+    
+    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)
+    logging && printstyled(to_string(V), " = ", str_irr_decomp("V", cg_decomp), "\n", color=:blue)
+
     Xs = positive_root_elements(algebra(action(ρ)))
-    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws)
+    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), sym_ws, cg_decomp)
     return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
 end
 
 function irreducibles(
-    ρ::GroupRepresentation{A, T}
+    ρ::GroupRepresentation{A, T};
+    logging::Bool=true
 ) 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)
     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(ρᵢ)
     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]
+    if logging
+        printstyled("Sym$(superscript(power(V)))(", color=:magenta)
+        printstyled(join([to_string(space(irr)) for irr in irreds_base], " ⊕ "), ") = ", color=:magenta)
+        printstyled(join(["(" * to_string(V) * ")" for V in Vs], " ⊕ "), color=:magenta)
+        println()
+    end
+
     irreds = IrreducibleRepresentation{A}[]
-    for mexp in mexps
-        Vᵢ = TensorProduct([SymmetricPower(space(irreds_base[idx]), val) for (val, idx) in zip(mexp.nzval, mexp.nzind)])
+    for Vᵢ in Vs
         ρᵢ = GroupRepresentation(action(ρ), Vᵢ)
         append!(irreds, irreducibles(ρᵢ))
     end
     return irreds
 end
 
 function irreducibles(
-    ρ::GroupRepresentation{A, S}
-) where {T, F, A<:AbstractGroupAction{Lie}, S<:TensorProduct{T, F, <:HighestWeightModule}}
+    ρ::GroupRepresentation{A, S};
+    logging::Bool=true
+) 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(ρ)
-    if nfactors(V) == 2
-        ws₁, ws₂ = weight_structure(factor(V, 1)), weight_structure(factor(V, 2)) # TODO: save once computed
-        # println("nweights 1: ", nweights(ws₁))
-        # println("nweights 2: ", nweights(ws₂))
-        tensor_ws = tensor(ws₁, ws₂)
-        # println("nweights 1 ⊗ 2: ", nweights(tensor_ws))
-        Xs = positive_root_elements(algebra(action(ρ)))
-        hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), tensor_ws)
-        return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
-    end
-    W = TensorProduct(factors(V, [1,2]))
-    ρW = GroupRepresentation(action(ρ), W)
-    irrs = irreducibles(ρW)
-    irreds = IrreducibleRepresentation{A}[]
-    for irr in irrs
-        Vᵣ = TensorProduct(space(irr), factors(V, 3:nfactors(V)))
-        ρᵣ = GroupRepresentation(action(ρ), Vᵣ)
-        append!(irreds, irreducibles(ρᵣ))
-    end
-    return irreds
+    hw₁, hw₂ = highest_weight(first(V)), highest_weight(second(V))
+    
+    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₂)
+    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(ρ)))
+    hw_vectors = common_nullspace_as_weight_vectors(Xs, action(ρ), tensor_ws, cg_decomp)
+    return [IrreducibleRepresentation(action(ρ), hwv) for hwv in hw_vectors]
 end
 
 function irreducibles(
-    ρ::GroupRepresentation{A, S}
+    ρ::GroupRepresentation{A, S};
+    logging::Bool=true
 ) where {A<:AbstractGroupAction{Lie}, S<:TensorProduct}
-    if nfactors(space(ρ)) == 2
-        irrs₁ = irreducibles(GroupRepresentation(action(ρ), factor(space(ρ), 1)))
-        irrs₂ = irreducibles(GroupRepresentation(action(ρ), factor(space(ρ), 2)))
-        irreds = IrreducibleRepresentation{A}[]
-        for irr₁ in irrs₁, irr₂ in irrs₂
-            V = TensorProduct([space(irr₁), space(irr₂)])
-            ρV = GroupRepresentation(action(ρ), V)
-            append!(irreds, irreducibles(ρV))
-        end
-        return irreds
-    end
-    V = TensorProduct(factors(space(ρ), 2:nfactors(space(ρ))))
-    ρV = GroupRepresentation(action(ρ), V)
-    irrs = irreducibles(ρV)
+    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(ρ))))
+
+    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)
+    logging && printstyled("($(join([to_string(space(irr)) for irr in irrs₂], " ⊕ "))) = ", color=:magenta)
+    logging && printstyled(join(["($(to_string(space(irr₁))) ⊗ $(to_string(space(irr₂))))" for (irr₁, irr₂) in product(irrs₁, irrs₂)], " ⊕ "), "\n", color=:magenta)
+
     irreds = IrreducibleRepresentation{A}[]
-    for irr in irrs
-        ρ₁ = GroupRepresentation(action(ρ), factor(space(ρ), 1))
-        irrs₁ = irreducibles(ρ₁)
-        for irr₁ in irrs₁
-            W = TensorProduct([space(irr₁), space(irr)])
-            ρW = GroupRepresentation(action(ρ), W)
-            append!(irreds, irreducibles(ρW))
-        end
+    for irr₁ in irrs₁, irr₂ in irrs₂
+        V = TensorProduct([space(irr₁), space(irr₂)])
+        ρV = GroupRepresentation(action(ρ), V)
+        append!(irreds, irreducibles(ρV))
     end
     return irreds
 end
@@ -201,14 +196,19 @@ end
 struct IrreducibleDecomposition{A<:AbstractGroupAction{Lie}, T<:GroupRepresentation{A}, Ir<:IrreducibleRepresentation{A}}
     ρ::T
     irreds::Vector{Ir}
+
+    function IrreducibleDecomposition(
+        ρ::T,
+        irreds::Vector{Ir}
+    ) where {A<:AbstractGroupAction{Lie}, T<:GroupRepresentation{A}, Ir<:IrreducibleRepresentation{A}}
+        @assert dim(space(ρ)) == sum([dim(space(irr)) for irr in irreds])
+        new{A, T, Ir}(ρ, irreds)
+    end
 end
 
-function IrreducibleDecomposition(
+IrreducibleDecomposition(
     ρ::GroupRepresentation
-)
-    irreds = irreducibles(ρ)
-    return IrreducibleDecomposition(ρ, irreds)
-end
+) = IrreducibleDecomposition(ρ, irreducibles(ρ))
 
 representation(ID::IrreducibleDecomposition) = ID.ρ
 action(ID::IrreducibleDecomposition) = action(ID.ρ)

src/decompositions/isotypic-decomp.jl

@@ -6,6 +6,24 @@ struct IsotypicDecomposition{A<:AbstractGroupAction{Lie}, T<:GroupRepresentation
     iso_dict::Dict{W, Ic}
 end
 
+function IsotypicDecomposition(
+    irreds::Vector{T},
+    ρ::GroupRepresentation{A}
+) where {A<:AbstractGroupAction{Lie}, T<:IrreducibleRepresentation{A}}
+    a = action(first(irreds))
+    W = weight_type(algebra(a))
+    iso_dict = Dict{W, IsotypicComponent}()
+    for irr in irreds
+        hw = highest_weight(irr)
+        if haskey(iso_dict, hw)
+            push!(iso_dict[hw], irr)
+        else
+            iso_dict[hw] = IsotypicComponent(a, hw, [irr])
+        end
+    end
+    return IsotypicDecomposition(ρ, iso_dict)
+end
+
 function IsotypicDecomposition(
     irr_decomp::IrreducibleDecomposition{A, T, Ir}
 ) where {A, T, Ir}
@@ -37,6 +55,9 @@ isotypic_components(ID::IsotypicDecomposition) = values(ID.iso_dict)
 nisotypic(ID::IsotypicDecomposition) = length(ID.iso_dict)
 dim(ID::IsotypicDecomposition) = dim(ID.ρ)
 Base.getindex(ID::IsotypicDecomposition, w::Weight) = ID.iso_dict[w]
+Base.length(ID::IsotypicDecomposition) = length(ID.iso_dict)
+Base.iterate(ID::IsotypicDecomposition) = iterate(isotypic_components(ID))
+Base.iterate(ID::IsotypicDecomposition, state) = iterate(isotypic_components(ID), state)
 
 function Base.show(io::IO, iso::IsotypicDecomposition)
     println(io, "IsotypicDecomposition of $(name(group(iso)))-action on $(dim(iso))-dimensional vector space")