Blog on HomogeneousTools

Semisimple.jl 1.3.0

Sun, 16 Aug 2026 00:00:00 +0000

Semisimple.jl 1.3.0 is out. The 1.0.0 announcement was the last release post, so there is some catching up to do: 1.1.0 made everything faster, 1.2.0 added conveniences for Dynkin types, and 1.3.0 has one theme: everything that folds a weight into the dominant chamber can now fold into the dominant chamber of a root subsystem.

Relative folds

The functions conjugate_dominant_weight, conjugate_dominant_weight_with_elem, conjugate_dominant_weight_with_length, and is_singular all accept an optional set of nodes $S$ of the Dynkin diagram. They then reflect only in the simple roots indexed by $S$ , so the Weyl group element they produce lives in the parabolic subgroup $\mathrm{W}_S$ , and singularity means lying on a wall of that subsystem:

using Semisimple

λ = WeightLatticeElem(TypeA{3}, [-1, 2, -1])

conjugate_dominant_weight_with_length(λ) # (ω1 + ω3, 2)
conjugate_dominant_weight_with_length(λ, (2, 3)) # (-ω1 + ω2 + ω3, 1)

is_singular(λ) # true
is_singular(λ, (2, 3)) # false

Note how the relative fold is happy to leave a negative coordinate on node 1: dominance is only asked for on $S$ . And a weight can be singular for the full Weyl group while being regular for $\mathrm{W}_S$ , as above.

This is exactly the combinatorics behind the relative Borel–Weil–Bott theorem: the higher direct images along a projection of flag varieties are computed by the same $\rho$ -shifted fold, restricted to the nodes of the fibre. It is what powers pushforward in PartialFlagVarieties.jl 0.3.0, and with 1.3.0 the fold lives where it belongs, next to the Weyl group.

The releases in between

1.1.0 was a performance release. The Weyl group kernels (dominant-chamber folds, Freudenthal, orbit traversal) are now specialized per rank rather than per Dynkin type, all simple types up to rank 10 come precompiled, and Freudenthal multiplicities are BigInt, since the Int values could overflow.

1.2.0 added three conveniences for Dynkin types:

parse_dynkin_type("A3 x D5") turns a string into a type, accepting exactly the labels the package works with;
sub_dynkin_type(DT, vertices) reads off the type of the sub-diagram spanned by a set of vertices, which is how one finds the semisimple part of a Levi;
WeightLatticeElem(DT) is the zero weight, no vector of zeros needed.

The second one pairs well with the relative folds above: nodes picks the subsystem, and sub_dynkin_type tells you which type it has.

One rename

The unexported borel_weil_bott is now _borel_weil_bott: the underscore marks it as internal and outside semantic versioning. The theorem properly belongs to PartialFlagVarieties.jl, which builds it from the exported conjugate_dominant_weight_with_length; the copy in Semisimple.jl stays around to exercise the restricted fold from the tests.

Updating

Semisimple.jl is registered in the General registry, so:

using Pkg
Pkg.update("Semisimple")

As always, issues and feature requests are welcome on the repository.

ZeroLocus62, a label format for zero loci

Sun, 16 Aug 2026 00:00:00 +0000

ZeroLocus62 is a compact, canonical encoding for bundles, zero loci, and degeneracy loci of completely reducible vector bundles on partial flag varieties. The label 40.G is a quintic threefold, and 603.111 is the Fano 3-fold 1-10, the zero locus of $(\bigwedge^2 \mathcal{U}^\vee)^{\oplus 3}$ on $\mathrm{Gr}(3,7)$ .

The format

A label has the shape <ambient>.<bundle>. The part before the dot encodes a product of partial flag varieties, one Dynkin type, rank, and set of marked nodes per factor; the part after the dot encodes the highest weights of the summands of the bundle. A third form with two - separators encodes degeneracy loci. Everything is written in the Base62 alphabet, the 62 characters 0–9, A–Z, a–z, which is where the name comes from: labels stay short, and they are safe in URLs and filenames without any escaping.

The format is canonical: summands and ambient factors are put in a prescribed order before encoding, so two systems describing the same zero locus produce the same string. That is exactly what you want when storing them in a database or communicating them across systems.

Now in the General registry

The repository ships the specification (currently v3.1.2, for the v3.1 format) together with reference implementations in Python, Julia, JavaScript, and Macaulay2. The Julia one is now in the General registry, so installing it is simply

using Pkg
Pkg.add("ZeroLocus62")

instead of the Pkg.add(url=..., subdir="julia") incantation from the previous posts.

For the full specification, worked examples, and a live decoder, see the website.

PartialFlagVarieties.jl 0.3.1

Thu, 13 Aug 2026 00:00:00 +0000

Since the pre-release of PartialFlagVarieties.jl at v0.1.0: 0.2.0 and 0.2.1 were housekeeping, 0.3.0 adds maps between flag varieties and renames a few things while the leading zero still allows it, and 0.3.1 removes a dependency the package did not need. So the current version is 0.3.1, but 0.3.0 is the one worth reading about.

Maps between flag varieties

For $I \subseteq J$ we have $\mathrm{P}_J \subseteq \mathrm{P}_I$ , hence a projection $q \colon \mathrm{G}/\mathrm{P}_J \to \mathrm{G}/\mathrm{P}_I$ . You can now pull equivariant bundles back along $q$ , and push them forward:

X, D = Gr(3, 6), flag_variety(6, [1, 3])

F = pullback(D, universal_subbundle(X))
rank.(graded_pieces(F)) # [1, 2]
graded_pieces(F) == tautological_bundles(D) # true

pushforward(X, structure_sheaf(D)) # R⁰ = E(0)

The pullback is only filtered: the unipotent radical of $\mathrm{P}_J$ acts on the fibre, so $q^*\mathcal{E}$ does not split. Its associated graded is the branching of the fibre from $\mathrm{L}_I$ to $\mathrm{L}_J$ , and above it recovers the tautological filtration $0 \to \mathcal{U}_1 \to \mathcal{U}_3 \to \mathcal{U}_3/\mathcal{U}_1 \to 0$ on $\mathrm{Fl}(1,3;6)$ , subbundle first.

The pushforward is the Borel–Weil–Bott theorem for $\mathrm{L}_I$ instead of for $\mathrm{G}$ : the same $\rho$ -shifted fold into a dominant chamber, reflecting only in the nodes unmarked in $I$ . Taking $I = \emptyset$ , so that the target is a point, gives back cohomology. Since $\mathbf{R}q_*$ of an irreducible sits in a single degree, the Leray spectral sequence degenerates, and that identity is what the tests check across every type.

What moved

0.x means the names are not frozen, and several changed in 0.3.0:

rank_bundle is now rank, and fiber_dimension is now degree;
rank of a variety is gone, since a rank belongs to the group: write rank(dynkin_type(X));
Cohomology stores its top degree as max_degree rather than dim_variety, since for higher direct images it is the relative dimension.

Two behaviours changed as well. Bundles now compare as unordered direct sums, a direct sum having no order. And a weight that is not dominant for the Levi is rejected when a bundle is constructed: it is the highest weight of nothing, and it used to be tolerated, then read as zero by some functions and pushed through Borel–Weil–Bott by others.

Trying it out

The package is not in the General registry, because one of its dependencies is not either, so that one comes first, and rev pins the release rather than tracking main:

using Pkg
Pkg.add(url="https://github.com/HomogeneousTools/ZeroLocus62", subdir="julia")
Pkg.add(url="https://github.com/HomogeneousTools/PartialFlagVarieties.jl",
 rev="ea4aa9e") # v0.3.1

The documentation has the full API. Issues and suggestions on the repository remain very welcome, and still cheap to act on.

PartialFlagVarieties.jl, a first pre-release

Fri, 17 Jul 2026 00:00:00 +0000

PartialFlagVarieties.jl is now public, as a pre-release: v0.1.0. It is the second piece of the HomogeneousTools project, built on top of Semisimple.jl, and it is the one we have wanted to release for a long time.

Where Semisimple.jl handles the representation theory of semisimple Lie algebras, PartialFlagVarieties.jl uses it to do algebraic geometry on the partial flag varieties $G/P$ : equivariant vector bundles, sheaf cohomology via the Borel–Weil–Bott theorem, zero loci, Hodge numbers, Hochschild cohomology, exceptional collections, and more.

Here is the kind of thing it lets you write:

using PartialFlagVarieties

X = Gr(2, 5) # the Grassmannian Gr(2,5)
dimension(X) # 6
euler_characteristic(X) # 10

T = tangent_bundle(X) # its tangent bundle
cohomology(T) # H⁰ = 24

L = line_bundle(X, 1)
Z = zero_locus(L) # a hypersurface in Gr(2,5)
dimension(Z) # 5
is_calabi_yau(Z) # false

By default cohomology returns dimensions, so the tangent bundle line gives $\mathrm{h}^0 = 24$ . Pass characters=true and the Borel–Weil–Bott theorem hands back the sheaf cohomology as an honest $G$ -representation:

cohomology(T; characters=true) # H⁰ = A4(1, 0, 0, 1)

that is $\mathrm{H}^0(\mathrm{Gr}(2,5), \mathrm{T}) = \mathfrak{sl}_5$ , the adjoint representation, of dimension $24 = \dim \mathrm{Aut}(\mathrm{Gr}(2,5))$ .

What “pre-release” means here

The version number is 0.1.0, and the leading zero is the important part. Under semantic versioning a 0.x.y version signals that the public API is not yet frozen: anything may still change before the first stable 1.0.

So “pre-release” is not a warning that the code is broken. The functionality listed below works, is covered by tests, and gives correct answers on the examples we have tried. What it means is that the names and signatures are not set in stone. A function might get renamed, an argument order might change, or a return type might be reworked before 1.0. If you pin 0.1 in your own Project.toml, an update will never silently break your code.

We are releasing it now, rather than waiting for a polished 1.0, because the package is already useful for real computations, and because feedback on the API is far more valuable while it can still change cheaply.

What is in v0.1.0

The core is in place:

partial flag varieties $G/P$ for all simple types, with named constructors (Gr, OGr, SGr, LGr, flag_variety, projective_space, quadric, cayley_plane, freudenthal_variety, adjoint_variety, and more);
equivariant vector bundles: tautological and spinor bundles, line bundles, tangent and cotangent bundles, exterior and symmetric powers, duals, twists, tensor products;
sheaf cohomology via the Borel–Weil–Bott theorem, both dimension- and character-valued;
zero loci of sections, with Koszul resolutions and Calabi–Yau detection;
Hodge numbers, twisted Hodge numbers, and Hochschild cohomology;
exceptional collections (Beilinson, Kapranov, Kapranov–Orlov).

The documentation has the full list, with worked examples for each.

We expect to tag a stable v1.0 after the summer holidays, and soon after that a v1.1 (or even a v2) with some more features.

Trying it out

Since this is a pre-release, the surest way to install it is directly from the repository:

using Pkg
Pkg.add(url="https://github.com/HomogeneousTools/ZeroLocus62", subdir="julia")
Pkg.add(url="https://github.com/HomogeneousTools/PartialFlagVarieties.jl")

If you compute with homogeneous varieties and their vector bundles, we would love to hear what works, what is missing, and what feels awkward. Issues and suggestions on the repository are very welcome: this is exactly the moment when they can shape the 1.0.

Representations with the same degree: smallest collisions

Mon, 15 Jun 2026 00:00:00 +0000

This is a follow-up to Representations with the same degree, about Frank Lübeck’s preprint and Andy Huchala’s undergraduate thesis on irreducible representations of a simple algebraic group that share their dimension. In the corrections to that post I noted that the clean construction sequences (such as A000891 in type $\mathrm{A}_l$ ) are not the smallest degrees at which two non-isomorphic, non-dual irreducibles coincide in dimension. This post collects the genuine smallest degrees.

For each classical type, here is the smallest degree carrying two irreducible representations of equal dimension that are not related by a diagram automorphism, for the ranks $l$ shown. They are kept as plain text so they are easy to copy into the OEIS:

A, l = 2..25: 15, 20, 70, 105, 210, 1512, 4620, 4950, 8008, 924, 52052, 80080, 928200, 495040, 271320, 3060, 5155080, 1009470, 10296594, 14805560, 20366500, 2884200, 37001250, 48976200
B, l = 2..25: 35, 112, 2772, 23595, 715, 6636630, 23984688, 66927861, 9585192960, 669442048, 251608500, 93475514149875, 2583610029, 2184324842700, 1107568, 59454145018522800, 3359934925776, 3078010375997128, 1255300994827620, 334620762580894464675, 2664821443401, 23398175753138864128, 67778385492333035520, 37701404492850988890000
D, l = 4..25: 672, 210, 352, 24024, 1067040, 2494206, 5457408, 26334, 460337701824, 14880153600, 13571131392000, 54627300, 234371284992, 30408171847680, 20123126100, 2327117992710356160, 547214951521155808800, 52569351652198318080, 34600877643532200000, 53524680, 49180016759537664000, 502382039575652375139000

These are wildly irregular — not monotone in $l$ , and nothing like the smooth construction sequences (in type $\mathrm{A}$ they coincide with A000891 only at $l=3$ ). The minima keep dipping back down: $\mathrm{A}_{11}$ falls to $924$ from the coincidence $\dim\mathrm{V}(\omega_6)=\dim\mathrm{V}(\omega_1+2\omega_{11})$ , and $\mathrm{A}_{17}$ all the way to $3060$ .

A witnessing pair for each entry (there can be more than two representations at the minimal degree; two suffice), here for the first ranks $l\leq10$ :

Dynkin type	first weight	second weight	common degree
$\mathrm{A}_{2}$	$4\omega_{2}$	$\omega_{1}+2\omega_{2}$	15
$\mathrm{A}_{3}$	$3\omega_{3}$	$\omega_{2}+\omega_{3}$	20
$\mathrm{A}_{4}$	$4\omega_{4}$	$\omega_{1}+2\omega_{4}$	70
$\mathrm{A}_{5}$	$2\omega_{4}$	$\omega_{3}+\omega_{5}$	105
$\mathrm{A}_{6}$	$4\omega_{6}$	$\omega_{4}+\omega_{6}$	210
$\mathrm{A}_{7}$	$\omega_{5}+2\omega_{7}$	$\omega_{4}+\omega_{6}$	1512
$\mathrm{A}_{8}$	$\omega_{5}+2\omega_{8}$	$2\omega_{2}+\omega_{8}$	4620
$\mathrm{A}_{9}$	$2\omega_{8}+\omega_{9}$	$2\omega_{7}$	4950
$\mathrm{A}_{10}$	$6\omega_{10}$	$\omega_{9}+3\omega_{10}$	8008
$\mathrm{B}_{2}$	$4\omega_{2}$	$\omega_{1}+2\omega_{2}$	35
$\mathrm{B}_{3}$	$3\omega_{3}$	$\omega_{2}+\omega_{3}$	112
$\mathrm{B}_{4}$	$4\omega_{4}$	$\omega_{2}+2\omega_{4}$	2772
$\mathrm{B}_{5}$	$2\omega_{4}$	$\omega_{3}+\omega_{4}$	23595
$\mathrm{B}_{6}$	$\omega_{4}$	$\omega_{1}+\omega_{2}$	715
$\mathrm{B}_{7}$	$\omega_{6}+2\omega_{7}$	$\omega_{5}+2\omega_{7}$	6636630
$\mathrm{B}_{8}$	$2\omega_{6}$	$\omega_{5}+\omega_{6}$	23984688
$\mathrm{B}_{9}$	$2\omega_{2}+\omega_{5}$	$8\omega_{1}+\omega_{2}$	66927861
$\mathrm{B}_{10}$	$\omega_{2}+3\omega_{10}$	$\omega_{2}+\omega_{7}+\omega_{10}$	9585192960
$\mathrm{D}_{4}$	$5\omega_{4}$	$\omega_{3}+3\omega_{4}$	672
$\mathrm{D}_{5}$	$\omega_{4}+\omega_{5}$	$3\omega_{1}$	210
$\mathrm{D}_{6}$	$\omega_{1}+\omega_{6}$	$3\omega_{1}$	352
$\mathrm{D}_{7}$	$\omega_{1}+\omega_{5}$	$\omega_{1}+2\omega_{2}$	24024
$\mathrm{D}_{8}$	$2\omega_{2}+\omega_{3}$	$4\omega_{1}+\omega_{3}$	1067040
$\mathrm{D}_{9}$	$2\omega_{1}+\omega_{6}$	$3\omega_{1}+2\omega_{2}$	2494206
$\mathrm{D}_{10}$	$\omega_{5}+\omega_{10}$	$2\omega_{2}+\omega_{10}$	5457408

The table and the sequences above come from a degree-bounded backtrack that enumerates every dominant weight below a candidate degree, quotienting out the diagram automorphisms — duality in type $\mathrm{A}$ , the spinor-node swap in $\mathrm{D}_l$ for $l\geq5$ , and triality in $\mathrm{D}_4$ :

# diagram automorphisms acting on coordinates
autos(::Type{TypeA{l}}) where l = [identity, reverse]
autos(::Type{TypeB{l}}) where l = [identity]
autos(::Type{TypeD{4}}) = [v -> v[[a,2,b,c]] for (a,b,c) in
 [(1,3,4),(1,4,3),(3,1,4),(3,4,1),(4,1,3),(4,3,1)]] # triality
autos(::Type{TypeD{l}}) where l = [identity, v -> v[[1:l-2; l; l-1]]]

# bin all dominant weights of degree <= bound by degree (pruning: degree is
# increasing in each coordinate, so trailing zeros give a lower bound)
function weights(::Type{T}, bound) where T <: DynkinType
 l = rank(T); bins = Dict{BigInt,Vector{Vector{Int}}}(); v = zeros(Int, l)
 rec(i) = i > l ? push!(get!(() -> Vector{Int}[], bins, degree(T, v)), copy(v)) :
 (while degree(T, v) <= bound; rec(i + 1); v[i] += 1 end; v[i] = 0)
 rec(1); bins
end

# smallest degree shared by two weights in distinct diagram-automorphism orbits;
# the starting bound is only a guess — we keep growing it until a duplicate appears
function smallest_duplicate(::Type{T}) where T <: DynkinType
 G = autos(T); bound = big(2000)
 while true
 d = [k for (k, ws) in weights(T, bound)
 if length(unique(minimum(g(w) for g in G) for w in ws)) > 1]
 isempty(d) || return minimum(d)
 bound *= 4
 end
end

[smallest_duplicate(TypeA{l}) for l in 2:25]
[smallest_duplicate(TypeB{l}) for l in 2:25]
[smallest_duplicate(TypeD{l}) for l in 4:25]

Computing all three lists up to $l=25$ takes about a minute (≈56 s on my laptop, after compilation); it stays this fast because in high rank only few dominant weights have small dimension, so even the largest bounds — some entries exceed $10^{23}$ — still enclose comparatively few weights to enumerate.

Representations with the same degree

Thu, 04 Jun 2026 00:00:00 +0000

Time for the next installment of the arXiv series. Today’s preprint is from earlier this year, and it’s Frank Lübeck: Representations with the same degree. In fact, whilst preparing this blogpost, I discovered that this question was also already addressed by Andy Huchala in his 2018 undergraduate thesis. In what follows, I will (mostly) refer to the arXiv preprint.

As before, we will use Semisimple.jl to play with the constructions in the paper.

Added on June 15 2026: Frank Lübeck spotted two errors in the original post — see the Corrections at the end. There is also a follow-up post tabulating the genuine smallest collisions.

Infinitely many pairs

Theorem Let $G$ be a connected reductive simply-connected algebraic group over $\mathbb{C}$ of rank $\geq2$ . Then $G$ has infinitely many pairs of irreducible rational representations $\rho_1,\rho_2$ that are not related by an automorphism of $G$ but for which $\dim\rho_1=\dim\rho_2$ .

The rank- $1$ assumption is necessary: in type $\mathrm{A}_1$ the irreducible representations are determined by their dimension. Beyond that, Lübeck establishes the theorem by exhibiting one explicit same-degree pair in every simple type, and combining this with the following observation: the Weyl dimension formula immediately gives

\dim\mathrm{V}(k(\lambda+\rho)-\rho)=\dim\mathrm{V}(\lambda)\cdot k^N

for any $k\in\mathbb{Z}_{>0}$ , where $N$ is the number of positive roots. So one same-degree pair $(\lambda,\mu)$ produces infinitely many at degrees $d, d\cdot 2^N, d\cdot 3^N,\ldots$

This is a perfect paper to play around with in Semisimple.jl, because the only ingredient we really need is degree.

Proposition 2: an explicit pair in each exceptional type, and in A₂, B₂

Lübeck’s Proposition 2 collects the following same-degree pairs, found by brute force over the dominant weights with small coordinates:

using Semisimple

# (type, λ, μ, common degree)
explicit = [
 (TypeA{2}, [1, 2], [0, 4], 15),
 (TypeB{2}, [1, 2], [0, 4], 35),
 (TypeG2, [3, 0], [0, 2], 77),
 (TypeF4, [1, 0, 0, 1], [2, 0, 0, 0], 1053),
 (TypeE{6}, [2, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], 351),
 (TypeE{7}, [0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 0, 2, 3], 1903725824),
 (TypeE{8}, [1, 0, 1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 1], 8634368000),
]

for (DT, λ, μ, d) in explicit
 @assert degree(DT, λ) == degree(DT, μ) == d
end

Note that in type $\mathrm{E}_6$ the non-trivial diagram automorphism gives a second same-degree pair at $d=351$ , namely $\mathrm{V}(2\omega_6)$ and $\mathrm{V}(\omega_5)$ ; the other six pairs have no such automorphic explanation.

One can reproduce this brute-force search using Semisimple.jl:

# diagram automorphism on coordinates; trivial except for A_2 and E_6.
outer(::Type{TypeA{2}}, v) = reverse(v)
outer(::Type{TypeE{6}}, v) = (v[6], v[2], v[5], v[4], v[3], v[1])
outer(::Type{<:DynkinType}, v) = v

# smallest dimension realised by two dominant weights of DT
# in different outer-automorphism orbits, searching coordinates in 0:N.
function smallest_pair(::Type{DT}; N=4) where {DT<:DynkinType}
 l = rank(DT)
 bins = Dict{BigInt,Vector{NTuple{l,Int}}}()
 for v in Iterators.product(ntuple(_ -> 0:N, l)...)
 push!(get!(() -> NTuple{l,Int}[], bins, degree(DT, collect(v))), v)
 end
 pairs = [(d, ws) for (d, ws) in bins
 if length(unique(min(v, outer(DT, v)) for v in ws)) >= 2]
 return argmin(first, pairs)
end

# the cases considered in Proposition 2
for DT in (TypeA{2}, TypeB{2}, TypeG2, TypeF4, TypeE{6}, TypeE{7}, TypeE{8})
 d, ws = smallest_pair(DT)
 println(rpad(string(DT), 12), " d = ", lpad(string(d), 12), " ", join(ws, " "))
end

Added on June 15 2026: as written, smallest_pair does not actually prove that the pair it returns is the smallest one — see Corrections below.

Theorem 3: infinite families in the classical types

For the classical types Lübeck exhibits closed-form families. In types $\mathrm{A}_l,\mathrm{B}_l,\mathrm{D}_l$ the pair is always of the shape $\mathrm{V}\bigl((c-1)\omega_2\bigr)$ vs. $\mathrm{V}\bigl(\omega_1+(c-2)\omega_2\bigr)$ , where $c$ depends on the type; verifying them up to any reasonable rank is straightforward. For $\mathrm{A}_l$ it would be as in Theorem 3(a):

for l in 2:15
 λ = zeros(Int, l); λ[2] = l - 1
 μ = zeros(Int, l); μ[1] = 1; μ[2] = l - 2
 expected =
 BigInt(2l - 1) *
 prod(BigInt(k)^2 for k in (l + 1):(2l - 2); init=BigInt(1)) ÷
 factorial(BigInt(l - 1))^2
 @assert degree(TypeA{l}, λ) == degree(TypeA{l}, μ) == expected
end

The same pattern works for $\mathrm{B}_l$ and $\mathrm{D}_l$ with the closed forms in Theorem 3(b) and 3(c) of the paper.

Type $\mathrm{C}_l$ takes an unexpectedly arithmetic turn: Lübeck shows that, again for $\lambda=a\omega_1+b\omega_2$ and $\mu=(a-2)\omega_1+(b+1)\omega_2$ , the equality $\dim\mathrm{V}(\lambda)=\dim\mathrm{V}(\mu)$ holds if and only if the generalised Pell equation

c^2-(4l-5)\,a^2=(2l-3)^2

admits a solution with $a\geq 3$ , in which case $b=\tfrac12(c+1-a-2l)$ . Because $4l-5\equiv 3\pmod 4$ is never a perfect square, this Pell equation has infinitely many solutions for every $l\geq 3$ , and the construction has the curious feature that the smallest $(a,b)$ one obtains can be enormous: for $l=159$ the corresponding common degree has 15728 decimal digits. Computing that degree directly in Semisimple.jl just works, since degree returns BigInt.

Some comments

The seven Proposition 2 pairs, together with the three Theorem 3 families, are part of the Semisimple.jl test suite, giving a slightly unusual but pretty cool set of unit tests!
Huchala claims in his Theorem 7 that there is an upper bound on how many irreducible representations of a given dimension can exist in type $\mathrm{B}_2$ and $\mathrm{G}_2$ . For $\mathrm{A}_2$ , a fun argument using the rank of an elliptic curve (explicit in Huchala’s thesis, whilst attributed to Deligne but not given in Lübeck’s preprint) shows that for any positive integer $m$ , you can find at least $m$ non-isomorphic irreducible representations of the same degree.

However, the proof of the upper bound in types B and G is not correct: there is a plane curve for every given degree, on which Faltings’ theorem gives a finite number of points. But to prove the claim, one would need that there is a uniform bound on the number of points all those plane curves, simultaneously. So there seems to be a fun open number-theoretical question here, unless I’m missing something?
There are fun OEIS sequences to add here: the degrees of Lübeck’s explicit family in type $\mathrm{A}_l$ are exactly A000891, and the analogous family degrees in types B and D are missing from the OEIS (in type C the chaotic behavior makes it hard to produce any clean sequence). The entries for these family sequences are computed both by Lübeck and Huchala. Added on June 15 2026: beware that these are the degrees of Lübeck’s construction, not the smallest degrees at which a duplicate occurs — again see Corrections.

If anyone is interested in adding these, here is some Julia code to determine them:
```
function dim_B(l::Integer)
 @assert l >= 2
 l == 2 && return 35
 l = BigInt(l)
 num = 3 * (4l - 5) * (6l - 5) * (6l - 7) *
 prod(k^2 for k in (2l):(4l - 6); init=BigInt(1))
 den = factorial(2l - 3)^2
 q, r = divrem(num, den); @assert iszero(r)
 return q
end

function dim_D(l::Integer)
 @assert l >= 4
 l = BigInt(l)
 num = 3 * (3l - 4) * (3l - 5) * (4l - 7) *
 prod(k^2 for k in (2l - 1):(4l - 8); init=BigInt(1))
 den = (l - 2)^2 * factorial(2l - 5)^2
 q, r = divrem(num, den); @assert iszero(r)
 return q
end
```
which gives
- 35, 3003, 383724, 58790875, 10011037452, 1827174287820, 350280152218800, 69656361253789275, 14250522671900707500, 2982164406170216424300, 635707916954453388942000, 137613009450274251664451148, resp.
- 32928, 4671810, 759230472, 134282273216, 25166658696000, 4919891369426550, 993186502108515000, 205625998084534750800, 43449470935521085094400, 9336731949069856461585000, 2034842637042393404135380128, 448826044126481544919237242240.

Corrections

After this post first appeared, Frank Lübeck kindly pointed out two mistakes. Both are corrected above; this section spells out what went wrong and how to fix it.

`smallest_pair` does not certify minimality

smallest_pair only loops over the box 0:N (with N=4), and nothing about it rules out that some weight with a coordinate larger than N has a smaller degree and forms a smaller pair. There is a cheap certificate, though. The Weyl dimension formula is strictly increasing in each coordinate, so every weight with some coordinate > N has degree at least $\min_i\deg\bigl((N+1)\omega_i\bigr)$ ; if that minimum already exceeds the degree d of the pair we found, then no weight outside the box can match or beat it, and the box was provably large enough:

function certified(::Type{DT}; N=4) where {DT<:DynkinType}
 d, ws = smallest_pair(DT; N)
 l = rank(DT)
 @assert minimum(degree(DT, [i == j ? N+1 : 0 for j in 1:l]) for i in 1:l) > d
 return d, ws
end

This check passes for $\mathrm{A}_2,\mathrm{B}_2,\mathrm{G}_2,\mathrm{F}_4,\mathrm{E}_6$ , but it fails for $\mathrm{E}_7$ and $\mathrm{E}_8$ at N=4. The cleanest example is in $\mathrm{E}_8$ : already $\deg(5\omega_8)=2\,642\,777\,280$ is smaller than the pair degree $8\,634\,368\,000$ from Proposition 2, so the box 0:4 is not certified — the search simply hasn’t looked at enough weights to know. A degree-bounded backtrack that enumerates every dominant weight whose degree is below the candidate settles it: doing so confirms that the tabulated $\mathrm{E}_7$ and $\mathrm{E}_8$ values really are the smallest, but that is a fact the box search alone never establishes.

A000891 is not the sequence of smallest degrees

I described A000891 as the smallest degrees in type $\mathrm{A}_l$ at which a duplicate occurs. That is wrong: A000891 is exactly the sequence of degrees of Lübeck’s explicit construction, and those are in general much larger than the genuine smallest — for instance the construction gives $175$ in $\mathrm{A}_4$ , whereas a same-degree pair already occurs at $70$ . The type B and D family sequences listed earlier are construction degrees in the same way, not the smallest.

Added on June 15 2026: the genuine smallest-degree sequences for types $\mathrm{A}$ , $\mathrm{B}$ and $\mathrm{D}$ — with witnessing weights and the code that finds them — are tabulated in a follow-up post.

Thanks to Frank Lübeck for both corrections!

Verifying Kostant's conjecture using Semisimple.jl

Fri, 29 May 2026 00:00:00 +0000

Here is a blogpost that is the first installment of something I would like to try.

Looking at today’s arXiv feed, I noticed a new and interesting preprint: Rekha Biswal, Sam Jeralds: Components of $\mathrm{V}(m\rho)\otimes\mathrm{V}(n\rho)$ ), for which Semisimple.jl can be used to experiment and verify the conjectures in some explicit cases. Because I think it is useful to see how to do such experiments, let us quickly discuss how we can verify Kostant’s conjecture using Semisimple.jl.

I plan this to be a series! I can even take requests.

Kostant’s conjecture

Conjecture (Kostant) Let $\mathfrak{g}$ be a complex semisimple Lie algebra. Let $\lambda\in\mathrm{P}^+$ be a dominant integral weight such that $\lambda\leq 2\rho$ in the dominance order. Then $\mathrm{V}(\lambda)\subset\mathrm{V}(\rho)\otimes\mathrm{V}(\rho)$ .

This conjecture can be read as saying that every irreducible representation that could appear in this specific tensor product, actually does appear. And it is a perfect conjecture to play around with in Semisimple.jl, one simply writes:

using Semisimple

function kostant_conjecture_holds(::Type{DT}) where {DT<:DynkinType}
 ρ = weyl_vector(DT)
 T = tensor_product(ρ, ρ)
 return all(λ -> get(T.terms, λ, 0) > 0, dominant_weights(DT, 2 * ρ))
end

Instead of tensor_product(ρ, ρ) in type A, it would be much faster to use Semisimple._brauer_klimyk_dominant: usually the Littlewood–Richardson approach in type A is much faster, but this is a case where the generic Brauer–Klimyk is actually better! For more on this, see below.

We can then check it for all (simple) Dynkin types up to rank 7:

# simple Dynkin types of rank ≤ 7, sorted by rank then by name.
simple_types = sort!(
 SimpleDynkinType[
 (TypeA{r}() for r in 1:7)...,
 (TypeB{r}() for r in 2:7)...,
 (TypeC{r}() for r in 3:7)...,
 (TypeD{r}() for r in 4:7)...,
 (TypeE{r}() for r in 6:7)...,
 TypeF4(),
 TypeG2(),
 ];
 by=dt -> (rank(dt), string(dt)),
)

for dt in simple_types
 t = @elapsed @assert kostant_conjecture_holds(typeof(dt)) "Conjecture 1 fails for $dt"
 println(rpad(string(dt), 24), " ", round(t; digits=2), "s")
end

This verifies Kostant’s conjecture for all simple Dynkin types up to rank 7, in a bit more than a minute on my laptop. Cool!

I stopped before rank 8 because it’ll take significant time for type $\mathrm{A}_8$ (because the default tensor product algorithm is bad in this case) and $\mathrm{E}_8$ (because this is simply such a vast case to consider.

It is now easy to also experimentally verify the generalization that Biswal–Jeralds propose, but this would make the blogpost longer, and let’s try to keep things short.

What this means for Semisimple.jl

As an added bonus of doing this, I discovered two interesting things:

In type A, Semisimple.jl provides 2 algorithms to compute tensor products; one is the Brauer–Klimyk algorithm, the other uses Littlewood–Richardson coefficients. In small cases, the Littlewood–Richardson approach is vastly superior, which is why it is the default. However, starting from $\mathrm{A}_8$ , I noticed that the computation got very slow, and switching to Brauer–Klimyk was actually a good thing! I will investigate this further, maybe there is an improvement to be made in the Littlewood–Richardson approach, maybe we should add the option to choose your algorithm in type A.
The computation for $\mathrm{E}_8$ used integers that got so big they overflowed Int64: I never expected Freudenthal’s formula to compute multiplicities that got so big, but it turns out, it does in some interesting cases! This is now fixed by dcd0a7d.

Lie.jl is now Semisimple.jl

Tue, 12 May 2026 00:00:00 +0000

The Julia package previously known as Lie.jl has been renamed to Semisimple.jl. This was needed, because the Julia registry rejected the name Lie.jl as being too short. I doubt many people have started using the package, I just have some renaming to do in the (not yet public) downstream packages.

The package should within the next 3 days be part of the Julia registry, so that you can install it in the usual way for Julia packages. Stay tuned for an update on that!

Lie.jl 1.0.0 is out

Mon, 11 May 2026 00:00:00 +0000

Note: This package was originally released under the name Lie.jl and has since been renamed to Semisimple.jl. See the rename announcement for details.

Semisimple.jl 1.0.0 is now available!

This first stable release focuses on efficient computations with semisimple Lie algebras, of the type that are most useful to an algebraic geometry who wants to do computations for completely reducible vector bundles on partial flag varieties. A large part of that efficiency comes from leaning into Julia’s type system and specialization, so fairly high-level code can still run very fast.

Here is a short session:

It is not yet at feature parity with LiE, LieART, or the corresponding functionality in SageMath, but the foundations are now in place. Let us know which features you would like to see implemented next!

HomogeneousTools is now live

Fri, 08 May 2026 00:00:00 +0000

We are happy to announce that the HomogeneousTools website is now live. HomogeneousTools is a collection of software for working with homogeneous varieties and homogeneous vector bundles, with applications to sheaf cohomology, Fano geometry, and related areas.

More tools, documentation, and posts are to come soon. Stay tuned.

As a small example of the kind of computation one can do with Semisimple.jl (formerly Lie.jl, see the rename announcement), here is a short session using the root system of type $\mathrm{A}_2$ (i.e. $\mathfrak{sl}_3$ ):