Blog on HomogeneousTools

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$ ):