Documentation contents

atlas Library · Script File

springer_table_D.at

Springer correspondence from nilpotent orbits to representations of W, type D
Source
atlas-scripts/springer_table_D.at (223 lines)
Definitions
12
Loads
Loaded by
sommers.at springer_tables_reductive.at

Definitions in source order

type D L10

Springer correspondence from nilpotent orbits to representations of W in type D
orbit: partition -> representation= pair of partitions
see Carter pg. 419
L12
diagram:

ComplexOrbit O            (for SO(2n))
Partition P               (for orbit of SO(2n))
D_irrep                   (for representation of W(SO(2n)))
L16
from combinatorics.at:

D_irrep = { from folding pairs of partitions under swapping }
  ( (Partition,Partition) unsplit_irr { unequal partitions, larger first }
  | (Partition,bool) split_irr { for pair of equal partitions, with sign }
  )
L22

partitions_D

L30partitions_D = (int->[Partition,bool])

freq_test_D

L39freq_test_D ([int] frequencies, bool flip) = [int]

nilpotent_orbit_SO

L49nilpotent_orbit_SO (Partition lambda, bool flip) = ComplexNilpotent
from (Jordan) partition (or composition) with possible even-even flip
to SO(2n) complex nilpotent orbit

also defined in springer_table_BC.at

nilpotent_orbit_D

L54nilpotent_orbit_D (RootDatum rd) = (Partition,bool->ComplexNilpotent)

diagram_D_to_partition

L70diagram_D_to_partition ([int] diagram) = (Partition,bool)
an inverse operation, starting from |stratified_diagram(orbit)|

partition_of_orbit_D

L89partition_of_orbit_D (ComplexNilpotent O) = (Partition,bool)
when |O| is an orbit for some |rd| passing |test_simple_type("D",rd)|, the
function |partition_of_orbit_D| will find the corresponding Jordan type and
for split orbits the Boolean value distinguishing the two (for other orbits
that value is always |false|). As in other classical cases, this function duly
ignores any radical component of |O.H| by using the (stratified) diagram.
The Springer map from nilpotent orbits to irreducible W(D_n)-representations
is for the most part governed by the map |core_quotient_2| from Jordan types
(partitions of $2n$ for type $D_n$) to pairs of partitions of sum $n$ (like
for $C_n$ the core is always empty for valid nilpotent Jordan types). The
subtle point is "doubly even" Jordan types (only even parts, each as always in
type $D_n$ repeated an even number of times, so they only occur when $n$ is
even) for which the $O(2n)$ nilpotent orbit splits into two $SO(2n)$ orbits,
and for which the 2-quotient is $(\lambda,\lambda)$ where $\lambda$ is the
partition of $n/2$ whose Young diagram is that of the Jordan type shrunk by a
factor 2 both horizontally and vertically. That partition pair determines a
"split irrep" for $W(D_n)$ and we need to consider the mapping from the
Boolean distinguishing the nilpotent orbits to the one distinguishing the
split irreducibles. The mapping is bijective, and in the end easy to describe:
it is the identity when the rank $n$ is divisible by 4, and Boolean NOT
(swapping |false| end |true|) when $n$ is (even but) not divisible by 4.

The following appears to be the justification for this choice. On page 423 of
Carter's book, a description is given couched in savant language of Richardson
classes, parabolic subgroups of G, and Macdonald representations (obtained
from the $j$-operation defined on page 368). For the doubly even Jordan types
this appears to translate into truncated induction of the sign representation
from the Bala-Carter Levi subgroup of $W(D_n)$ associated to the nilpotent
orbit, tensored (it appears one never misses an occasion for a twist) by the
sign representation of $W(D_n)$. Since we can focus on getting the information
distinguishing the two split irreducibles the evaluation on a particular split
class. We can take the "simplest" class with very even cycle type, namely the
class of $w=s_0s_2s_4..s_{n-2}$, whose signed cycle type has $n/2$ cycles,
each length $2$ and of positive cycle sign, and whose discriminating Boolean
value is |false|; the character of any split irrep on it is nonzero, and it is
negative if and only if that irrep has Boolean |true| attached (this can be
deduced from the formula implemented in |hyperoctahedral_character|). The
question then boils down to finding the Boolean attached to the truncated
induction of the Bala-Carter Levi subgroup associated to |O|, and this appears
to be the same as the discriminating Boolean attached to the split nilpotent
orbit; tensorsing with the sign representation then flips this with the sign
$(-1)^{n/2}$ of $w$, anf at is this flip that is implemented below (where
$n/2$ appears under the form of |sum(lambda)|). It may be noted that the
initial discriminating Boolean for |O| records the equivalent conditions (by
definition:) (0) |b| for which |O| is |nilpotent_orbit_D(rd)(Jordan_type,b)|,
(1) whether the final entry of |O.H| (dominant) is negative, (2) whether the
final entry of |diagram(O)| is zero. It is noteworthy that the condition
whether set of simple roots for the associated Bala-Carter Levi contains the
final node of the diagram is opposite to this condition whenever $n/2$ is odd,
a switch that apparently gets compensated to disappear in the truncated
induction process. The switch arises because, taking $S$ to be a disjoint
union of odd rank type $A$ sub-diagrams separated by a single absent node and
not containing the final node of the $D_n$ diagram, the unique associated
distinguished $H$ has half its entries negative, which is $n/2$ in number, and
making it dominant leaves a final negative entry if and only if $n/2$ is odd.
At this time I (MvL) don't understand how truncated induction undoes the flip.
L94

springer_D 2 overloads

L146springer_D (Partition Jordan,bool flip) = D_irrep
L155springer_D (ComplexNilpotent O) = D_irrep

duality L159

after the initial |assert| statement, |D_adjust| is identical to |B_adjust|
L161

D_adjust

L163D_adjust (Partition P) = Partition

D_dual

L199D_dual (Partition Jordan,bool flip) = (Partition,bool)
while |D_dual| is rather simpler than |C_to_B_dual| (no square is added to the
Jordan type, and so there is no need for an initial |D_adjust| as the argument
is assumed to be already valid), the way it works differs in some ways.
Notably the condition that after the transposition the parity of row lengths
does not change from an odd indexed row to the (even indexed) next is not
preserved in general (for instance |ones(2*n)| transposes to |[2*n]| which is
adjusted to [2*n-1,1]|, which is valid for type D but not the transpose of
another such valid partition). After transposition the initial part is always
even; if its multiplicity is odd, a square moves from an even indexed even row
to an odd indexed shorter even row, but doing so it may jump over some odd
length rows (an even number of them). If the initial even part has even
multiplicity, then next smaller part will be even; continuing, one sees at
least one pair of odd parts is created, unless one has a doubly even partition
initially. In the latter case nothing happens apart from the transposition. So
we get one of a split orbit if and only if we had one initially. In that case
the |flip| records whether the character of the associated split irrep takes a
negative value at the class of $w=s_0s_2s_4..s_{n-2}$, and tensoring with the
sign representation will affect this by the sign $(-1)^{n/2}$ of $w$, so we
negate |flip| if and only if the number |n\2=sum(Jordan)\4| is odd.

dual_map_D

L205dual_map_D (RootDatum rd) = (ComplexNilpotent->ComplexNilpotent)

springer_table_D

L215springer_table_D (RootDatum rd) = SpringerTable

Generated from atlas-scripts at commit 648506c (2026-10-13).