atlas Library · Script File

`W_orbit.at`

Source

Definitions

Loads

<basic.at { for assert, #@int,... }
<sort.at
<hash.at { used in general |generate| method }

Loaded by

complex.at W_reps.at all_finite_order.at bruhat.at projectors_using_character_tables.at parabolics.at W_K.at tits.at conjugate.at isomorphism.at weyl_character_formula.at

Definitions in source order

`generate_from_dom`

L28generate_from_dom ([(vec->Maybe<vec>)] S,vec start) = [vec,[int]]

The next function is not needed for generating orbits for the reflection
representations of the Weyl group on weights and coweights, for which the
built-in |Weyl_orbit| can be used to find the orbit, and |from_dominant| to
recover for each orbit element a representative Weyl group element. Therefore
the name of the function, which is that of the script function originally used
to generate the orbit of a dominant weight, is no longer very appropriate.

An optimised orbit generation procedure, which assumes that generators can
detect and eliminate (by returning |none()|) backwards or stationary steps
(in the main application we generate the orbit of a dominant weight, whence
the function name, and "forward" will then mean subtracting posroots) and that
the poset structure on the orbit is graded (as is true for the weak order on
$W$ or on $W/P$ for a parabolic subgroup $P$). This allows the orbit to be
partitioned into levels, with equality testing only within current level.

Arguments are a row |S| of generating maps and a starting dominant weight |v|;
it returns a list of pairs of a weight |b| and a representative word in the
generators, which when applied right-to-left transforms |v| into |b|.

The algorithm is to generate an array of such pairs, with a counter |done|
saying how many have been considered for successors, and a marker |stop|
saying where the newest level (where duplicates must be avoided) starts.

`generate_action_from_dom`

L58generate_action_from_dom ( [(vec->Maybe<vec>)] S , vec start , int dim , [mat] gens_rep ) = [vec,[int],mat]

Same as above, but also compose |gens_rep| matrices for applied generators;
for callers that need this, this avoids repeated matrix multiplications that
would occur when multiplying out the matrices for all the returned words.
This is typically used for representations of W other than the standard
reflection representation (for which |matrix@WeylElt| can find the action).

`simple_actor`

L91simple_actor (RootDatum rd, int i) = (vec -> Maybe<vec>)

"lowering only" standard simple reflection actions on weights

Commented-out code, lines 95–122 (27 lines)

For refernce we recall how this was applied to the relflection action. Now
  that the built-in function can handle this musch faster, we don;t use them.

  { For Weyl group action on X^*, wrap previous form in pre/post processing }
  set generate_from_dom (RootDatum rd,[int] S,vec v) = [vec,WeylElt]:
     for (x,word) in generate_from_dom(for s in S do simple_actor(rd,s) od,v)
     do (x,product(rd,for i in word do W_refl(rd,S[i]) od)) od
  { get orbit of |v| under parabolic subgroup of Weyl group with generators |S|,
    and witnessing (minimal) Weyl group elements |w|: |x=w*v| for |x| in orbit }
  set generate_from (RootDatum rd,[int] S,vec v) = [vec,WeylElt]:
     let (chamber,dom_wt) = from_dominant(rd,S,v)
     then orbit =
	generate_from_dom(for s in S do simple_actor(rd,s) od,dom_wt)
     ,  to_dom= WeylElt: inverse(chamber)
  in for (x,word) in orbit
     do (x,product(rd,for i in word do W_refl(rd,S[i]) od)*to_dom)
     od
  { when no |WeylElt| elements are needed in the end, we can simplify a bit }
  set W_orbit_of_dom ((RootDatum,[int], vec) triple) = [vec]:
     for (x,) in generate_from_dom(triple) do x od
  set W_orbit ((RootDatum,[int], vec) triple) = [vec]:
     for (x,) in generate_from(triple) do x od
  { minimal coset reprs for stabilizer in $W_S$ of dominant weight |v| }
  set stabiliser_quotient_of_dom ((RootDatum,[int],vec) triple) = [WeylElt]:
     for (,w) in generate_from_dom(triple) do w od
  set stabiliser_quotient ((RootDatum,[int],vec) triple) = [WeylElt]:
     for (,w) in generate_from(triple) do w od

`W_orbit` 4 overloads

L124W_orbit = (RootDatum,vec ->mat)

weight

L125W_orbit = (vec ,RootDatum->mat)

coweight

L126W_orbit = (RootDatum,[int],vec ->mat)

weight

L128W_orbit = (vec ,RootDatum,[int]->mat)

coweight

also in this file at line 216, line 218, line 232, line 234

`stabiliser_quotient` 4 overloads

L133stabiliser_quotient = (RootDatum,vec ->[WeylElt])

minimal coset representatives for stabilizer in $W_S$ of (any weight) |v|

for reflection representation with |S| all simple roots, using built-ins

W/P

weight

L135stabiliser_quotient = (vec ,RootDatum->[WeylElt])

P\W

coweight

L137stabiliser_quotient = (RootDatum,[int],vec ->[WeylElt])

weight

L139stabiliser_quotient = (vec ,RootDatum,[int]->[WeylElt])

coweight

also in this file at line 221, line 223, line 236, line 238

`W_orbit_with_witness` 4 overloads

L142W_orbit_with_witness ((RootDatum,vec) (,v ):args) = [vec,WeylElt]

weight

L144W_orbit_with_witness ((vec,RootDatum) (v ,):args) = [WeylElt,vec]

coweight

L146W_orbit_with_witness ((RootDatum,[int],vec)(,,v ):args) = [vec,WeylElt]

weight

L149W_orbit_with_witness ((vec,RootDatum,[int])(v ,,):args) = [vec,WeylElt]

coweight

also in this file at line 226, line 228, line 240, line 243

When it is just required to visit all elements of an orbit, one can avoid
storing the full orbit in memory by using iterators. This will still use
built-in functions for generating parabolic quotients, but these are smaller.

L153

`W_parabolic_iterator`

L159W_parabolic_iterator (RootDatum rd, [int] gens) = Iterator<WeylElt>

Iterator for running through the Weyl subgroup with simple generators |gens|

`W_parabolic_iterator_with_action`

L181W_parabolic_iterator_with_action (RootDatum rd, [int] gens, int dim, [mat] gens_rep) = Iterator<(WeylElt,mat)>

given action of generators, get action of each generated element on the fly

`W_iterator`

L210W_iterator (RootDatum rd) = Iterator<WeylElt>

`W`

L214W (RootDatum rd) = [WeylElt]

if we don't mind storing the full Weyl group, us built-in which is faster

`W_orbit` 2 overloads

L216W_orbit (RootDatum rd, ratvec rv ) = [ratvec]

weight

L218W_orbit (ratvec rv ,RootDatum rd) = [ratvec]

coweight

also in this file at line 124, line 125, line 126, line 128, line 232, line 234

`stabiliser_quotient` 2 overloads

L221stabiliser_quotient (RootDatum rd,ratvec rv) = [WeylElt]

W/P

L223stabiliser_quotient (ratvec rv,RootDatum rd) = [WeylElt]

P\W

also in this file at line 133, line 135, line 137, line 139, line 236, line 238

`W_orbit_with_witness` 2 overloads

L226W_orbit_with_witness (RootDatum rd,ratvec rv) = [ratvec,WeylElt]

L228W_orbit_with_witness (ratvec rv,RootDatum rd) = [WeylElt,ratvec]

also in this file at line 142, line 144, line 146, line 149, line 240, line 243

`W_orbit` 2 overloads

L232W_orbit (RootDatum rd, [int] S, ratvec rv ) = [ratvec]

variants of the above for subgroups

weight

L234W_orbit (ratvec rv ,RootDatum rd, [int] S) = [ratvec]

coweight

also in this file at line 124, line 125, line 126, line 128, line 216, line 218

`stabiliser_quotient` 2 overloads

L236stabiliser_quotient (RootDatum rd, [int] S, ratvec rv ) = [WeylElt]

weight

L238stabiliser_quotient (ratvec rv ,RootDatum rd, [int] S) = [WeylElt]

coweight

also in this file at line 133, line 135, line 137, line 139, line 221, line 223

`W_orbit_with_witness` 2 overloads

L240W_orbit_with_witness (RootDatum rd, [int] S, ratvec rv ) = [ratvec,WeylElt]

weight

L243W_orbit_with_witness (ratvec rv ,RootDatum rd, [int] S) = [ratvec,WeylElt]

coweight

also in this file at line 142, line 144, line 146, line 149, line 226, line 228

`generate`

L265generate ([(ratvec->ratvec)] S,ratvec v) = [ratvec,[int]]

General orbit generation of |v| for the monoid generated by |S|.

Presumably |S| are involutions coming from some Weyl group action, but not
necessarily simple reflections. However even them being involutions is not
assumed here, nor anything about how these generators relate to dominance; not
even that the generated directed acyclic graph is graded.

No |RootDatum| is passed to this function, although the maps |f_i| that are
passed may themselves have access to a |RootDatum| to do their thing.

Example of use: finding the $W^{\delta}$-orbit of a root, in which the
generators would be the actions of certain $\delta$-stable elements of $W$.


Here we use, instead of |W_orbit_with_witness|, a simplified but less
efficient method, using hash table search over the full orbit generated so far.

also in this file at line 289

The following function calls the previous one with the actions of Weyl
group elements given as second argument. The words in these indices of these
generators are converted upon returing into Weyl group elements.

L283

`generate`

L289generate (RootDatum rd,[WeylElt] S,ratvec v) = [ratvec,WeylElt]

also in this file at line 265

`conjugate_to` 2 overloads

L297conjugate_to (RootDatum rd, [WeylElt] S, ratvec a,ratvec b) = (bool,WeylElt)

find a |WeylElt| in the generated group <S> whose action sends |v| to |w|
returns either (true,w) or (false,id)

L306conjugate_to (RootDatum rd, ratvec u, ratvec v) = (bool,WeylElt)

find WeylElt |w| satisfying |w*v=u|

`bounded_generate_action_from_dom`

L313

bounded_generate_action_from_dom ( [(vec->Maybe<vec>)] S , vec start , int dim , [mat] gens_rep , int length_bound ) = [vec,[int],mat]

same as unbounded case, but limit generating word length to |length_bound|

orbit generation routines which terminate early based on length bound

L351

`bounded_generate_from_dom`

L353bounded_generate_from_dom ([(vec->Maybe<vec>)] S,vec v, int length_bound) = [vec,[int]]

`bounded_generate` 2 overloads

L362bounded_generate (RootDatum rd,[int] S,vec v,int bound) = [vec,WeylElt]

get orbit of |v| under parabolic subgroup of Weyl group with generators |S|,
and witnessing (minimal) Weyl group elements |w|: |x=w*v| for |x| in orbit

L371bounded_generate (RootDatum rd,vec v,int bound) = [vec,WeylElt]

default S to full set of simple roots

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

W_orbit.at

Definitions in source order

generate_from_dom

generate_action_from_dom

simple_actor

W_orbit 4 overloads

stabiliser_quotient 4 overloads

W_orbit_with_witness 4 overloads

W_parabolic_iterator

W_parabolic_iterator_with_action

W_iterator

W

W_orbit 2 overloads

stabiliser_quotient 2 overloads

W_orbit_with_witness 2 overloads

W_orbit 2 overloads

stabiliser_quotient 2 overloads

W_orbit_with_witness 2 overloads

generate

generate

conjugate_to 2 overloads

bounded_generate_action_from_dom

bounded_generate_from_dom

bounded_generate 2 overloads

`W_orbit.at`

`generate_from_dom`

`generate_action_from_dom`

`simple_actor`

`W_orbit` 4 overloads

`stabiliser_quotient` 4 overloads

`W_orbit_with_witness` 4 overloads

`W_parabolic_iterator`

`W_parabolic_iterator_with_action`

`W_iterator`

`W`

`W_orbit` 2 overloads

`stabiliser_quotient` 2 overloads

`W_orbit_with_witness` 2 overloads

`W_orbit` 2 overloads

`stabiliser_quotient` 2 overloads

`W_orbit_with_witness` 2 overloads

`generate`

`generate`

`conjugate_to` 2 overloads

`bounded_generate_action_from_dom`

`bounded_generate_from_dom`

`bounded_generate` 2 overloads