Levi_subgroups.at

alternatively, with (rd,select):LI
let rho2_L = two_rho(Levi_info)
in list(rd.nr_of_posroots,(int i): select(i) and coroot(rd,i)*rho2_L=2)

It turns out that Levi subsystems (whether or not standard) are conjugate in
$W$ if and only if their |two_rho| weights are in the same $W$-orbit.

The following functions, up to |classify_standard_Levis|, aim to classify
standard Levis under conjugation _and_ find conjugators for each one from the
first of their class. The Levi orbit table produced is used in some functions
in W_classes.at; the ultimate goal of efficiently classifying Weyl group
elements up to conjugation, with witnesses, is also achieved there.

For each standard Levi system |standard_Levi| (a list of simple root indices)
we determine the dominant orbit representative |rho2_dom| of its $2\rho$, a
Weyl group element |w0| that witnesses this (|w0*rho2_dom=two_rho(rd,Levi)|),
and the (non standard) image $L$ under |inverse(w0)| of |standard_Levi|, which
has |two_rho(Levi_info(L))=rho2_dom| (this holds because the Levi system
remains positive throughout the action by letters of |inverse(w0)|). A
conjugate standard Levi system will give the same |rho2_dom|, but will not
necessarily transform to the same system $L$; therefore we generate the orbit
of $L$ under the stabiliser subgroup of the |rho2_dom|, which is also a Levi
subgroup (of unrelated type) and therefore generated by the reflections that
stabilise |rho2_dom|. The generation also finds witnesses of the conjugation.

Next task: given a standard Levi, list the non-standard Levis conjugate to it
whose $2\rho$-value is dominant

The following function facilitates identifying all Levi subgroups conjugate to
|standard_Levi|, by providing a full list of those (non standard) Levi
subgroups whose $2\rho$-value is dominant, with witnesses of the action from
|standard_Levi| to them; in other words it returns a list of |(L,w)| where
|two_rho(L)=dominant(two_rho(standard_Levi)) and |L=w*standard_Levi| (but with
|L| encoded as an integer, so these are not actually valid expressions).

The orbit is generated for the stabiliser in the Weyl group of the mentioned
dominant weight, called |rho2_dom| below. The values acted upon are
fixed-sized sets of posroots (each set generating a subsystem whose sum of
posroots equals |rho2_dom|) which are represented by a single integer for
faster comparison. The encoding is done using |combination_encode| which
generally produces smaller values than |to_bitset| (one could make the values
even smaller by expointing the fact that only root numbers whose coroots are
at level |2| for |rho@_dom| are involved, but no gain would be obtained).

The acting stabiliser is a Levi subgroup (of unrelated type) so generated by
involutions (root reflections for |simples| below). Orbit elements are
generated while keeping track of the (first found) acting Weyl group element
to each point. Since orbits can be very large (notably for E8), it pays to try
to reduce equality testing by proceeding by shells defined by the distance (in
the Cayley graph) from the initial point: each newly generated element needs
to be tested for presence in the previous shell (a backwards move) or in the
current shell (a move that does not change the distance). All new elements not
thus filtered out are gathered, and passed through |sort_u| to remove
duplicates before being integrated as a new shell. Each shell being sorted,
looking up in each shell can be done using binary search.

Levi subgroups are conjugate if and only if they have |two_rho| values in the
same W-orbit; however if two (standard) Levi subgroups are transformed so as
to have the same (dominant) value of |two_rho|, they have not necessarily
become equal. However one Levi subgroup is necessarily found in the
|rho_stabiliser_orbit| of the other, with a witnessing Weyl group element, and
this allows finding a conjugator from one Levi to the other. The
classification of standard Levi subgroups then proceeds by transforming each
to a situation with dominant |two_rho|, grouping together those with the same
value pf |two_rho|; then in each group the first one is chosen to represent
the orbit, |rho_stabiliser_orbit| is applied to it, and all other elements in
the group are looked up in this orbit.

From $w$ we find the associated non-standard Levi subsystem, the minimal one
in whose Weyl group $w$ occurs. Our next task, surprisingly difficult, is to
find a standard Levi system conjugate to it, and a conjugating element of $W$.

The difficulty that the set of generators for our system may contain negative
roots, so that the sum of positive roots of the system is not a positive sum
of the given generators, but of a different set |Levi_datum(rd,Levi).simples|
(defining the same subsystem). That set is in the orbit of the former (even
under the Weyl group of just the Levi itself), but using it woudtl be quite
cumbersome. However the function |two_rho@(rd,[int])| from basic/at is defined
in a positivity-agnostic way, so we can use that and proceed very similarly to
how we looked up standard Levis (but using already computed |StdLeviTable|).

For looking up arbitrary Levi subgroups, we need a slightly different table
than |StdLeviTable|: a list of one |orbit_data| for each |rho2_dom| value

given |StdLeviTable|: tabled representative of any Levi, and conjugator

Here is another approach that we previously used instead of using |two_rho|;
we keep it because the implemented functionality might have other uses. For
one, the function |from_standard_Levi| below is a fast way to find some
conjugate standrad Levi of an arbitrary one, without doing classification.

For the case where we are given a non standard list of simple generators (not
all positive, and in arbitrary order) for the _full_ root system, there is an
easy algorithm to find $w$ (called |chamber| below) that maps the set of
simple roots of |rd| to those generators, and the permutation of them (map
from positions to simple root index being mapped to it) so obtained. It goes:
as long as the system contains a negative root, select one (recording its
position) and apply the corresponding (non simple) root reflection to all
roots; ultimately all roots become positive, and as a set we have obtained the
simple roots. The list of their indices is our permutation; as letters of $w$,
from right to left, take for each reflection applied the simple generator that
ended up at the recorded position. This is done in |chamber_max_system| below.

Our approach is then to extend the Levi system one root at a time to a maximal
system, and then apply this algorithm; once this is, done we get a standard
Levi conjugate to our original by truncating the above permutation to as many
initial entries as the rank of our original Levi was, and a Weyl group element
conjugating that standard Levi to the original (|from_standard_Levi | below).
The classification of the standard Levi subgroups finally allows us to replace
the standard Levi by the elected representative of its class.

Extending to a maximal rank Levi is done by repeatedly finding a root by which
we can extend the Levi system to a larger one; to this end we first locate
using |minimal_extenders| a set of candidates (root indices, not necessarily
positive ones), whose roots are minimally positive for some some linear form
vanishing on |Levi|. From these, |extend_Levi| will then select a minimal one
that extends |Levi| by adding a single root.

keep the tabulated Levi found, adapt the conjugator

facilitate reverting to |(RootDatum,[int])| encoding of Levi subgroups