Implementation details

clear_all_caches!()

Clear all internal caches used by Semisimple.jl. Alias for clear_caches!.

Examples

julia> using Semisimple

julia> clear_all_caches!()

clear_caches!()

Empty every internal cache in Semisimple.jl (both bounded Dict caches and LRU caches).

Examples

julia> using Semisimple

julia> ω1 = fundamental_weight(TypeA{2}, 1);

julia> tensor_product(ω1, ω1);  # populates caches

julia> clear_caches!()

configure_caches!(; budget=nothing, dominant_frac=nothing, tensor_frac=nothing,
                    sym_power_frac=nothing, ext_power_frac=nothing)

Resize the LRU caches at runtime. Unspecified keyword arguments retain their current values. The budget is in bytes and controls the total memory envelope; the four fraction arguments determine how it is divided among the caches (they need not sum to 1 — each cache is sized independently as budget * frac).

Examples

julia> using Semisimple

julia> configure_caches!(budget = 512 * 1024^2)  # 512 MiB total

cache_info() -> NamedTuple

Return a snapshot of the current cache occupancy. Each entry is a NamedTuple with fields length (number of entries) and maxsize (capacity in bytes).

Examples

julia> using Semisimple

julia> info = cache_info();

julia> info.tensor.length >= 0
true

RootSystem(::Type{DT}) -> RootSystem{DT,R,N}

Return the root system for Dynkin type DT. A single instance is cached per Dynkin type, with small ranks using fully generated literals and larger ranks using a compact runtime builder.

Examples

julia> using Semisimple

julia> RootSystem(TypeA{2}) === RootSystem(TypeA{2})
true

Compute positive roots, coroots, and the reflection table from a Cartan matrix.

This uses the standard algorithm: start with simple roots and iteratively apply simple reflections to discover new positive roots.

Returns:

• pos_roots::Vector{SVector{R,Int}} — positive roots in simple root coordinates
• pos_coroots::Vector{SVector{R,Int}} — positive coroots
• refl::Matrix{UInt} — reflection table

_make_root_system_runtime(::Type{DT}) -> RootSystem{DT,R,N}

Compact runtime builder for root systems. This is used directly for higher ranks and via a small generated wrapper for larger mid-rank types to avoid emitting enormous tuple literals into method bodies.

_weyl_denominator(::Type{DT}) -> BigInt

Compute the Weyl dimension denominator ∏_{α>0} ⟨ρ, α⟩.

_weyl_dim_scaled_roots(::Type{DT}) -> NTuple{N, SVector{R,Int}}

Return the symmetrizer-scaled positive root vectors d .* α for Dynkin type DT.

Internal: determines what right-multiplication by s does to word x.

Returns (insert::Bool, position::Int, letter::UInt8):

• if insert=true: insert letter at position
• if insert=false: delete the element at position

weylloop(action!, ::Type{DT}, v::AbstractVector{<:Integer})

Call action!(w) once for each weight w in the Weyl orbit of v, where v and w are in the fundamental weight (ω) basis.

Uses LiE's ε-basis algorithm: converts to ε-coordinates where a classical subgroup acts by permutations (type A) or permutations + sign changes (types B/C/D), then enumerates orbits systematically via lexicographic permutation generation and Gray-code sign flips — with no hash set or BFS.

For exceptional types, coset representatives W / W_classical are precomputed as matrices.

All transforms dispatch on the Dynkin type, enabling the compiler to inline them and unroll fixed-size loops. The hot per-orbit workspace uses stack-allocated MVector from StaticArrays; the deduplicated suborbit representatives still live in a small heap vector because their count depends on the Dynkin type and the input weight.

action! receives a mutable workspace vector; it must NOT hold a reference to this vector across calls (copy if needed).

_positive_roots_runtime(C, R) -> Vector{Vector{Int}}

Compute positive roots using plain arrays (no StaticArrays).

_apply_cache_preferences!()

Read Preferences-based cache settings and resize caches accordingly. Called from __init__() so that user preferences take effect on load.

Recognised preferences (set via Preferences.set_preferences!):

dot_reduce(λ::WeightLatticeElem{DT,R}) -> Tuple{Int, WeightLatticeElem{DT,R}}

Compute the "dot-action reduction" of λ:

Return (ε, μ) where:

• μ is the dominant weight such that w ⋅ λ = μ under the dot action w ⋅ λ = w(λ + ρ) - ρ for some Weyl group element w
• ε = (-1)^{ℓ(w)} is the sign of w, or ε = 0 if λ + ρ is singular (lies on a Weyl chamber wall)

This is the key ingredient in the Brauer–Klimyk algorithm.

brauer_klimyk(char::Dict{SVector{R,Int}, <:Integer}, μ::WeightLatticeElem{DT,R}) -> WeylCharacter{DT,R}

Tensor the representation with weight multiplicities char (as from freudenthal_formula) with the irreducible representation $\mathrm{V}(μ)$, using the Brauer–Klimyk formula:

$\mathrm{V} \otimes \mathrm{V}(μ) = \sum_{\text{weights } λ \text{ of } \mathrm{V}} m(λ) \cdot ε(λ+μ) \cdot \mathrm{V}(ν(λ+μ))$

where (ε, ν) = dot_reduce(μ + λ). Accepts BigInt-valued multiplicities (as returned by freudenthal_formula); the resulting irreducible multiplicities are stored as Int in the returned WeylCharacter, so this will throw InexactError if any of them exceeds typemax(Int64).

_brauer_klimyk_dominant(dom_char::Dict{SVector{R,Int}, <:Integer}, μ::WeightLatticeElem{DT,R}) -> WeylCharacter{DT,R}

Like brauer_klimyk, but takes a dominant-only character dict (as returned by dominant_character) and expands Weyl orbits on-the-fly using weylloop. This avoids materializing the full weight system and eliminates hash-set overhead for large orbits.

The Brauer–Klimyk formula is: $\mathrm{V} \otimes \mathrm{V}(μ) = \sum_{\text{dom. wts } λ_d} m(λ_d) \sum_{w \in W \cdot λ_d} ε(w(λ_d)+μ) \cdot \mathrm{V}(ν(w(λ_d)+μ))$

Accepts BigInt-valued multiplicities; the resulting irreducible multiplicities are stored as Int in the returned WeylCharacter and will throw InexactError if any of them exceeds typemax(Int64).

_vdecomp(::Type{DT}, dom_char::Dict{SVector{R,Int},<:Integer}) -> WeylCharacter{DT,R}

Virtual decomposition: given a character as a dict of weight multiplicities (dominant weights only, as produced by Adams operators), decompose into irreducibles using the Weyl orbit / alternating-dominant method.

This is the analogue of LiE's Vdecomp function.

_tensor_characters(V::WeylCharacter{DT,R}, W::WeylCharacter{DT,R}) -> WeylCharacter{DT,R}

Tensor product of two virtual characters (each decomposed into irreducibles).

_weight_to_partition(λ::WeightLatticeElem{TypeA{N},N}) -> Vector{Int}

Convert a dominant weight in fundamental weight coordinates to a partition with $N+1$ parts (for $\mathrm{GL}_{N+1}$).

For $\mathrm{A}_N$, the dominant weight $λ = (λ_1, …, λ_N)$ in the fundamental weight basis corresponds to the partition $μ = (μ_1 ≥ μ_2 ≥ ⋯ ≥ μ_N ≥ 0)$ where $μ_i = λ_i + λ_{i+1} + ⋯ + λ_N$ (partial sums from right to left), with $μ_{N+1} = 0$.

_partition_to_weight(::Type{TypeA{N}}, p::Vector{Int}) -> WeightLatticeElem{TypeA{N},N}

Convert a partition back to a dominant weight in the fundamental weight basis for $\mathrm{SL}_{N+1}$. First reduces the partition by subtracting the minimum part (to pass from $\mathrm{GL}$ to $\mathrm{SL}$), then computes successive differences: $λ_i = μ_i - μ_{i+1}$.

_lr_coefficients(α::Vector{<:Integer}, β::Vector{<:Integer}, n::Integer) -> Dict{Vector{Int}, Int}

Compute all Littlewood–Richardson coefficients $c^ν_{αβ}$ for partitions α and β, where partitions have at most n parts.

Returns a dictionary mapping each partition ν (as Vector{Int}) to the LR coefficient $c^ν_{αβ}$.

The algorithm fills the skew shape $ν / α$ with content β row by row, enforcing:

1. Semistandard: entries weakly increase along rows, strictly increase down columns.
2. Ballot (lattice word) condition: reading the filling right-to-left, top-to-bottom, at every prefix the count of j ≥ count of j+1.

We enumerate valid fillings recursively row by row, which implicitly determines the partition ν.

_n_tableaux(λ::Vector{<:Integer}, l::Integer) -> BigInt

Compute the number of standard Young tableaux of shape $λ$ using the hook-length formula:

$f^λ = \frac{n!}{\prod_{\text{boxes}} h(b)}$

l is the number of (nonzero) rows.

_partitions(n::Integer) -> Vector{Vector{Int}}

Generate all partitions of n in decreasing order.

_classord(κ::Vector{Int}) -> BigInt

Compute the size of the conjugacy class in $S_n$ corresponding to cycle type $κ$:

$|\mathrm{Cl}(κ)| = \frac{n!}{\prod_{k>0} k^{c_k(κ)} \cdot c_k(κ)!}$

where $c_k(κ)$ is the number of parts of $κ$ equal to $k$. The parts of κ must be in weakly decreasing order.

_mn_char_val(λ::Vector{Int}, μ::Vector{Int}) -> BigInt

Compute the irreducible $S_n$-character value $χ^λ(μ)$ using the Murnaghan–Nakayama rule.

Both λ and μ are partitions of $n$ with parts in weakly decreasing order.

The algorithm represents the Young diagram of $λ$ as a Maya diagram (edge sequence of horizontal/vertical steps), then recursively removes rim hooks of the sizes given by the parts of $μ$ (largest first).

Recursive Murnaghan–Nakayama: remove rim hooks of sizes μ[i], μ[i+1], … from the Maya diagram edge, tracking leg-length parity in k.