atlas  0.6
weyl.h
Go to the documentation of this file.
1
5 /*
6  This is weyl.h
7
8  Copyright (C) 2004,2005 Fokko du Cloux
9  part of the Atlas of Lie Groups and Representations
10
12 */
13
14 #ifndef WEYL_H /* guard against multiple inclusions */
15 #define WEYL_H
16
17 #include "../Atlas.h"
18
19 #include <cstring>
20 #include <cassert>
21
22 #include "constants.h"
23 #include "tags.h"
24
25 #include "size.h" // for stored order of the Weyl group
26 #include "matrix.h" // for Coxeter matrix
27
28
29 /******** type declarations *************************************************/
30
31 namespace atlas {
32
33 namespace weyl {
34
35  class RowBase; // information at one coset element in one transducer table
36  typedef RowBase ShiftRow; // the case of a transition entry
37  typedef RowBase OutRow; // the case of a transduction entry
38
39  class Transducer;
40
41
42 /******** constant declarations *********************************************/
43
44  const unsigned char UndefValue = constants::ucharMax;
45  const unsigned long UndefOrder = 0; // is never a valid value
46
47
48 /******** type definitions **************************************************/
49
53  class Twist // also used by synonym |WeylInterface|
54  {
56  public:
57  Twist () // assures definite values are always set
58  { std::memset(d,~0,sizeof(d)); }
59  Generator& operator[] (size_t i) { return d[i]; }
60  const Generator& operator[] (size_t i) const { return d[i]; }
61
62  bool operator!=(const Twist& y) const
63  { for (unsigned i=0; i<constants::RANK_MAX; ++i)
64  if (d[i]!=y.d[i])
65  return true;
66  return false;
67  }
68  bool operator==(const Twist& y) const { return not operator!=(y); }
69
70  };
71
72
73 /******** function declaration *********************************************/
74
75 Twist make_twist(const RootDatum& rd,
76  const WeightInvolution& d);
77
78 /******** main class definitions *******************************************/
79
88 class WeylElt // a.k.a. |TwistedInvolution|
89 {
90
91  friend class WeylGroup; // so we can shield implementation from all others
92
93 public:
98  typedef unsigned char EltPiece;
99
100  private:
101
112  EltPiece d_data[constants::RANK_MAX];
113
114  public:
115
116 // constructors and destructors
117
122  std::memset(d_data,0,sizeof(d_data));
123  }
124
126  WeylElt(const WeylWord& w, const WeylGroup& W);
127
128 // copy and assignment
129 // use standard definitions (raw copy of array)
130
131 // accessors
132
133
138  bool operator< (const WeylElt& w) const {
139  return std::memcmp(d_data,w.d_data,sizeof(d_data)) < 0;
140  }
141
146  bool operator== (const WeylElt& w) const {
147  return std::memcmp(d_data,w.d_data,sizeof(d_data))==0;
148  }
149
154  bool operator!= (const WeylElt& w) const {
155  return std::memcmp(d_data,w.d_data,sizeof(d_data))!=0;
156  }
157
158 protected: // these are for |WeylGroup| and |TI_Entry|'s eyes only
159
163  EltPiece operator[] (size_t j) const {
164  return d_data[j];
165  }
166
167 // manipulators
168  EltPiece& operator[] (size_t j) {
169  return d_data[j];
170  }
171
172 public:
173 // dummy methods that mark transition of interpretation
174
175  // from WeylElt interpretation to TwistedInvolution
176  // nothing: cast to TwistedInvolution is allowed, would do construction if
177  // TwistedInvolution were a derived class, and is a no-op in reality
178
179  // from TwistedInvolution interpretation to WeylElt
180  // calls of these mark referral to the "base" class of |TwistedInvolution|
181  const WeylElt& w() const { return *this; }
182  WeylElt& contents() { return *this; }
183
184 }; // |class WeylElt|
185
186 const WeylElt Identity; // default constructor initialises to identity
187
191 class RowBase {
192
193  private:
194
195  unsigned char d_data[constants::RANK_MAX];
196
197  public:
198
199 // constructors and destructors
201  std::memset(d_data,UndefValue,sizeof(d_data));
202  }
203
204  ~RowBase() {}
205
206 // copy and assignment
207  RowBase(const RowBase& r) {
208  std::memcpy(d_data,r.d_data,sizeof(d_data));
209  }
210
211  RowBase& operator=(const RowBase& r) {
212  std::memcpy(d_data,r.d_data,sizeof(d_data)); return *this;
213  }
214
215 // accessors
216  Generator operator[] (size_t j) const {
217  return d_data[j];
218  }
219
220 // manipulators
221  Generator& operator[] (size_t j) {
222  return d_data[j];
223  }
224 }; // |class RowBase|
225
257 class Transducer {
258  // there is one such object for each $r\in\{1,2,\ldots,n\}$
259  // but $r$ is not explicitly stored in the Tranducer object
260
264  std::vector<ShiftRow> d_shift;
265
272  std::vector<OutRow> d_out;
273
277  std::vector<unsigned long> d_length;
278
282  std::vector<WeylWord> d_piece;
283
284  public:
285
286 // constructors and destructors
288
289  Transducer(const int_Matrix&, size_t);
290
292
293 // accessors
294
295
299  unsigned long length(WeylElt::EltPiece x) const { return d_length[x]; }
300
301
308  unsigned long maxlength() const { return d_length.back(); }
309
310
316  Generator out(WeylElt::EltPiece x, Generator s) const { return d_out[x][s]; }
317
326  { return d_shift[x][s]; }
327
331  unsigned long size() const {
332  return d_shift.size();
333  }
334
335
339  const WeylWord& wordPiece(WeylElt::EltPiece x) const { return d_piece[x]; }
340
341 // this class should have no manipulators!
342 }; // |class Transducer|
343
344
431 {
432  size_t d_rank;
434  unsigned long d_maxlength;
438
439  std::vector<Transducer> d_transducer;
442  std::vector<Generator> d_min_star;
443
444  WeylGroup(const WeylGroup&); // forbid copying; Weyl groups should be shared
445
446 // private member functions
447 // these interpret Generators and WeylWords internally, so not for public use!
448
449  // set |w=ws|, return value is $l(ws)-l(w)\in\{+1,-1}$
450  int multIn(WeylElt& w, Generator s) const;
451
452  // set |w=wv|, return value is $l(wv)-l(w)-l(v)\in -2\N$
453  int multIn(WeylElt& w, const WeylWord& v) const;
454
455  // set |w=sw|, return value is $l(sw)-l(w)\in\{+1,-1}$
456  int leftMultIn(WeylElt& w, Generator s) const;
457
458  // get WeylWord for piece |j| of |w|
459  const WeylWord& wordPiece(const WeylElt& w, Generator j) const
460  { return d_transducer[j].wordPiece(w[j]); }
461
465  Generator min_neighbor (Generator s) const { return d_min_star[s]; }
466
467  WeylElt genIn (Generator i) const; // $s_i$ as Weyl group element
468
469 // From this point on each Generator or WeylWord uses external numbering
470 public:
471
472 // constructors and destructors
473  WeylGroup(const int_Matrix& cartan); // from Cartan matrix
474
475 // accessors
476
477  WeylElt generator (Generator i) const // $s_i$ as Weyl group element
478  { return genIn(d_in[i]); }
479
480  // set |w=ws|, return length change
481  int mult(WeylElt& w, Generator s) const { return multIn(w,d_in[s]); }
482
483  // set |w=wv|
484  void mult(WeylElt& w, const WeylElt& v) const;
485
486  // set |w=wv|
487  void mult(WeylElt&, const WeylWord&) const;
488
489  // set |w=sw| (argument order motivated by modification effect on |w|)
490  int leftMult(WeylElt& w, Generator s) const { return leftMultIn(w,d_in[s]); }
491  void leftMult(WeylElt& w, const WeylWord& ww) const
492  {
493  for (size_t i=ww.size(); i-->0; ) // use letters from right to left
494  leftMult(w,ww[i]);
495  }
496  void leftMult(WeylElt& w, const WeylElt& x) const; // |w=xw|
497
498  WeylElt prod(const WeylElt& w, Generator s) const
499  { WeylElt result=w; mult(result,s); return result; }
500  WeylElt prod(Generator s, const WeylElt& w) const
501  { WeylElt result=w; leftMult(result,s); return result; }
502  WeylElt prod(const WeylElt& w, const WeylElt& v) const
503  { WeylElt result=w; mult(result,v); return result; }
504  WeylElt prod(const WeylElt& w, const WeylWord& ww) const
505  { WeylElt result=w; mult(result,ww); return result; }
506  WeylElt prod(const WeylWord& ww,const WeylElt& w) const
507  { WeylElt result=w; leftMult(result,ww); return result; }
508
509
510  /* These additional definitions would be needed if TwistedInvolutions were a
511  type distinct from WeylElt (but they are not allowed as it is):
512
513  void leftMult(TwistedInvolution& w, Generator s) const {
514  leftMultIn(w.contents(),d_in[s]);
515  }
516  void leftMult(TwistedInvolution& w, const WeylWord& ww) const {
517  leftMult(w.contents(),ww);
518  }
519  void leftMult(TwistedInvolution& w, const WeylElt& x) const {
520  leftMult(w.contents(),x);
521  }
522  */
523
524
525  unsigned int length(const WeylElt&) const;
526
527  // return (only) $l(w.s)-l(w)$
529  {
530  return multIn(w,d_in[s]); // discard copied |w|
531  }
532
533  // return $l(s.w)-l(w)$
534  int length_change(Generator s,const WeylElt& w) const
535  {
536  return hasDescent(s,w) ? -1 : 1;
537  }
538
539  // letter |i| of Weyl word for |w|
540  Generator letter(const WeylElt& w, unsigned int i) const;
541
542  void conjugacyClass(WeylEltList&, const WeylElt&) const;
543
545  void conjugate(WeylElt& w, Generator s) const
546  { leftMult(w,s); mult(w,s); }
547
549  WeylElt inverse(const WeylElt& w) const;
550
552  void invert(WeylElt& w) const { w=inverse(w); }
553
559  Generator leftDescent(const WeylElt& w) const;
560
561  bool commutes (Generator s, Generator t) const
562  {
563  WeylElt w = generator(s);
564  conjugate(w,t);
565  return w==generator(s);
566  }
567
568  const WeylElt& longest() const { return d_longest; }
569
570  Generator Chevalley_dual(Generator s) const // conjugation by |longest()|
571  { assert(s<rank()); return Chevalley[s]; }
572
573  // correspondence with dual Weyl group; is coherent with \delta on the right!
574  WeylElt opposite (const WeylElt& w) const { return prod(w,d_longest); }
575
576  unsigned long maxlength() const { return d_maxlength; }
577
579  const size::Size& order() const { return d_order; }
580
581  size_t rank() const { return d_rank; }
582
583  WeylWord word(const WeylElt& w) const;
584  WeylElt element(const WeylWord& ww) const { return prod(WeylElt(),ww); }
585
586  WeylEltList reflections() const; // list all reflections
587
588  /* give representation of |w| as integral number, supposing this fits. */
589  unsigned long toUlong(const WeylElt& w) const;
590
591  /* inverse operation of |toUlong| */
592  WeylElt toWeylElt(unsigned long) const;
593
594  bool hasDescent(Generator, const WeylElt&) const; // on the left
595  bool hasDescent(const WeylElt&, Generator) const; // on the right
596
597  // apply automorphism of $(W,S)$ given by |f| in terms of outer numbering
598  WeylElt translation(const WeylElt& w, const WeylInterface& f) const;
599
600  void translate(WeylElt& w, const WeylInterface& i) const
601  { w=translation(w,i); }
602
603  // reflection action of Weyl group on a root
604  void act(const RootDatum& rd, const WeylElt& w, RootNbr& alpha) const;
605  // standard reflection action of Weyl group using a root datum
606  template<typename C>
607  void act(const RootDatum& rd, const WeylElt& w, matrix::Vector<C>& v)
608  const;
609  // standard reflection action of Weyl group using a root datum
610  void act(const RootDatum& rd, const WeylElt& w, RatWeight& v) const;
611  // standard reflection action of Weyl group using a root datum
612  void act(const RootDatum& rd, const WeylElt& w, LatticeMatrix& M) const;
613
614  // same using only lists of simple (co)roots avoiding construction root datum
615  template<typename C>
616  void act(const PreRootDatum& prd, const WeylElt& w, matrix::Vector<C>& v)
617  const;
618  void act(const PreRootDatum& prd, const WeylElt& w, RatWeight& v) const;
619  void act(const PreRootDatum& prd, const WeylElt& w, LatticeMatrix& M) const;
623  Weight
624  image_by(const RootDatum& rd, const WeylElt& w, Weight v) const
625  { act(rd,w,v); return v; }
626
627  void inverse_act(const RootDatum& rd, const WeylElt& w, Weight& v) const;
628
632  Weight
633  image_by_inverse(const RootDatum& rd, const WeylElt& w, Weight v) const
634  { inverse_act(rd,w,v); return v; }
635
636
637 // manipulators
638
639 }; // |class WeylGroup|
640
641 /*
642  We have split off in the following class functionality that involves an
643  involutive diagram automorphism |delta|. While WeylElt values are assumed to
644  live just in the Weyl group W, this class implements operations that
645  are more naturally interprests them in $W semidirect Z/2Z$ (the second
646  factor acting on the first via |delta|), namely in the non-identity coset
647  for $W$.
648
649  This class is not derived from |WeylGroup|, although many methods are just
650  handed over to an underlying |WeylGroup|. We assume the latter to be
651  constructed beforehand, and store a reference to it. For one thing, this
652  makes it possible for two |TwistedWeylGroup|s with different twists to share
653  the same |WeylGroup|; this is useful because the Weyl groups of a root datum
654  and its dual can be identified, but not their twists.
655
656  Having no privilege with respect to |WeylGroup|, we are totally ignorant of
657  its internal numbering.
658 */
660 {
661  const WeylGroup& W; // non-owned reference
662  const Twist d_twist; // cannot be reference, if dual is to be constructible
663
664  void operator=(const TwistedWeylGroup&); // forbid assignment
665  protected:
666  TwistedWeylGroup(const TwistedWeylGroup& g) // only derived classes may copy
667  : W(g.W), d_twist(g.d_twist) {} // share |W|, copy |d_twist|
668 public:
669  TwistedWeylGroup(const WeylGroup&, const Twist&);
670
671  // construct the "dual" twisted Weyl group: differs by a dual twist
673
674  const WeylGroup& weylGroup() const { return W; }
675  size_t rank() const { return W.rank(); }
676
677  int mult(WeylElt& w, Generator s) const { return W.mult(w,s); }
678  void mult(WeylElt& w, const WeylElt& v) const { W.mult(w,v); }
679  void mult(WeylElt& w, const WeylWord& ww) const { W.mult(w,ww); }
680
681  int leftMult(WeylElt& w, Generator s) const { return W.leftMult(w,s); }
682  void leftMult(WeylElt& w, const WeylWord& ww) const { W.leftMult(w,ww); }
683  WeylWord word(const WeylElt& w) const { return W.word(w); }
684
685  WeylElt prod(const WeylElt& w, Generator s) const { return W.prod(w,s); }
686  WeylElt prod(Generator s, const WeylElt& w) const { return W.prod(s,w); }
687  WeylElt prod(const WeylElt& w, const WeylElt& v) const { return W.prod(w,v); }
688  WeylElt prod(const WeylElt& w, const WeylWord& ww) const
689  { return W.prod(w,ww); }
690  WeylElt prod(const WeylWord& ww,const WeylElt& w) const
691  { return W.prod(ww,w); }
692
693  bool hasDescent(Generator s, const WeylElt& w) const
694  { return W.hasDescent(s,w); }
695  bool hasDescent(const WeylElt& w, Generator s) const
696  { return W.hasDescent(w,s); }
697
698  Generator twisted(Generator s) const { return d_twist[s]; }
699  WeylElt twisted(const WeylElt& w) const { return W.translation(w,d_twist); }
700
702  { return W.Chevalley_dual(d_twist[s]); }
703  WeylElt dual_twisted(const WeylElt& w) const;
704
705  const Twist& twist() const { return d_twist; } // noun "twist"
706  void twist(WeylElt& w) const { w=twisted(w); } // verb "twist"
707
708  std::vector<ext_gen> twist_orbits () const;
709  Twist dual_twist() const; // the twist for the dual twisted Weyl group
710
717  {
718  WeylElt& w=tw.contents();
719  int d = W.leftMult(w,s);
720  return d+W.mult(w,d_twist[s]);
721  }
722  int twistedConjugate(TwistedInvolution& tw, const WeylWord& ww) const
723  {
724  int d=0;
725  for (size_t i=ww.size(); i-->0; )
726  d+=twistedConjugate(tw,ww[i]);
727  return d;
728  }
730  {
731  int d=0;
732  for (size_t i=0; i<ww.size(); ++i )
733  d+=twistedConjugate(tw,ww[i]);
734  return d;
735  }
736
738  { twistedConjugate(tw,s); return tw; }
739
740  void twistedConjugacyClass(TwistedInvolutionList&, const TwistedInvolution&)
741  const;
742
746  void twistedConjugate(TwistedInvolution& tw, const WeylElt& w) const;
747
748  bool hasTwistedCommutation(Generator, const TwistedInvolution&) const;
749
753  unsigned long involutionLength(const TwistedInvolution& tw) const;
754
759  InvolutionWord involution_expr(TwistedInvolution tw) const; // call by value
760  InvolutionWord canonical_involution_expr(TwistedInvolution tw) const; // idem
761
762  // extended involution expression for a twist-fixed twisted involution
763  InvolutionWord extended_involution_expr(TwistedInvolution tw) const; // idem
764
766  RootNbrList simple_images
767  (const RootSystem& rs, const TwistedInvolution& tw) const;
768
771  involution_matrix(const RootSystem& rs,
772  const TwistedInvolution& tw) const;
773
774 }; // |class TwistedWeylGroup|
775
776
777 // A small derived class to allow hash tables of TwistedInvolution values
778 // (We might have put |Pooltype| and |hashCode| members in WeylElt directly)
779
780 struct TI_Entry
781  : public TwistedInvolution
782 {
784  TI_Entry(): TwistedInvolution() {} // identity TwistedInvolution
785
786  // members required for an Entry parameter to the HashTable template
787  typedef std::vector<TI_Entry> Pooltype; // associated storage type
788  size_t hashCode(size_t modulus) const; // hash function
789 }; // class TI_Entry
790
791
792 } // |namespace weyl|
793
794 } // |namespace atlas|
795
796 #endif
static const size_t RANK_MAX
Definition: constants.h:57
WeylElt prod(const WeylElt &w, const WeylWord &ww) const
Definition: weyl.h:504
const WeylGroup & weylGroup() const
Definition: weyl.h:674
Represents a Weyl group for the purpose of manipulating its elements.
Definition: weyl.h:430
Generator dual_twisted(Generator s) const
Definition: weyl.h:701
int inverseTwistedConjugate(TwistedInvolution &tw, const WeylWord &ww) const
Definition: weyl.h:729
WeylElt prod(const WeylWord &ww, const WeylElt &w) const
Definition: weyl.h:506
TI_Entry()
Definition: weyl.h:784
std::vector< ShiftRow > d_shift
Right multiplication by $s_j$ gives transition |i -> d_shift[i][j]|.
Definition: weyl.h:264
void invert(WeylElt &w) const
set |w=w^(-1)|
Definition: weyl.h:552
WeylInterface d_out
Definition: weyl.h:441
WeylElt prod(const WeylElt &w, const WeylElt &v) const
Definition: weyl.h:502
TwistedInvolution twistedConjugated(TwistedInvolution tw, Generator s) const
Definition: weyl.h:737
void mult(WeylElt &w, const WeylWord &ww) const
Definition: weyl.h:679
bool hasDescent(Generator s, const WeylElt &w) const
Definition: weyl.h:693
Twist make_twist(const RootDatum &rd, const WeightInvolution &d)
Returns the twist defined by |d| relative to |rd|.
Definition: weyl.cpp:1215
void leftMult(WeylElt &w, const WeylWord &ww) const
Definition: weyl.h:682
WeylWord word(const WeylElt &w) const
Definition: weyl.cpp:494
WeylElt d_longest
Definition: weyl.h:435
Twist Chevalley
Definition: weyl.h:437
int leftMult(WeylElt &w, Generator s) const
Definition: weyl.h:490
std::vector< WeylElt > WeylEltList
Definition: Atlas.h:234
WeylElt()
Constructs the identity element of W.
Definition: weyl.h:121
Element of a Weyl group.
Definition: weyl.h:88
bool operator!=(const Twist &y) const
Definition: weyl.h:62
Twist()
Definition: weyl.h:57
~RowBase()
Definition: weyl.h:204
Generator Chevalley_dual(Generator s) const
Definition: weyl.h:570
unsigned long size() const
Number of cosets W_{r-1}\W_r.
Definition: weyl.h:331
const Twist & twist() const
Definition: weyl.h:705
std::vector< Transducer > d_transducer
Definition: weyl.h:439
const WeylWord & wordPiece(const WeylElt &w, Generator j) const
Definition: weyl.h:459
unsigned long maxlength() const
Maximal length of minimal coset representatives.
Definition: weyl.h:308
int length
Definition: common.c:103
RowBase()
Definition: weyl.h:200
size_t rank() const
Definition: weyl.h:581
const Twist d_twist
Definition: weyl.h:662
size_t rank() const
Definition: weyl.h:675
TI_Entry(const TwistedInvolution &tw)
Definition: weyl.h:783
Weight image_by_inverse(const RootDatum &rd, const WeylElt &w, Weight v) const
Nondestructive version of |inverse_act| method.
Definition: weyl.h:633
WeylElt prod(const WeylElt &w, Generator s) const
Definition: weyl.h:685
std::vector< signed char > InvolutionWord
Definition: Atlas.h:236
void twist(WeylElt &w) const
Definition: weyl.h:706
Generator d[constants::RANK_MAX]
Definition: weyl.h:55
RowBase ShiftRow
Definition: weyl.h:35
const size::Size & order() const
the order of the Weyl group
Definition: weyl.h:579
int mult(WeylElt &w, Generator s) const
Definition: weyl.h:481
RowBase OutRow
Definition: weyl.h:37
std::vector< unsigned long > d_length
Lengths of the minimal coset representatives $x_i$.
Definition: weyl.h:277
unsigned char d_data[constants::RANK_MAX]
Definition: weyl.h:195
Right multiplication action of simple reflections on a Weyl group modulo (to the left) a maximal para...
Definition: weyl.h:257
Transducer()
Definition: weyl.h:287
Definition: weyl.h:659
WeylElt::EltPiece shift(WeylElt::EltPiece x, Generator s) const
Right coset x&#39; defined by x&#39; = xs.
Definition: weyl.h:325
int length_change(WeylElt w, Generator s) const
Definition: weyl.h:528
EltPiece d_data[constants::RANK_MAX]
Represents factorization of Weyl group element w as a product of shortest length coset representative...
Definition: weyl.h:112
WeylWord word(const WeylElt &w) const
Definition: weyl.h:683
const WeylWord & wordPiece(WeylElt::EltPiece x) const
Reduced decomposition in W (or W_r) of minimal coset representative x.
Definition: weyl.h:339
int length_change(Generator s, const WeylElt &w) const
Definition: weyl.h:534
RowBase(const RowBase &r)
Definition: weyl.h:207
WeylElt prod(Generator s, const WeylElt &w) const
Definition: weyl.h:686
WeylElt prod(const WeylWord &ww, const WeylElt &w) const
Definition: weyl.h:690
Definition: Atlas.h:227
const unsigned long UndefOrder
Definition: weyl.h:45
bool hasDescent(Generator, const WeylElt &) const
Tells whether sw < w.
Definition: weyl.cpp:417
int twistedConjugate(TwistedInvolution &tw, const WeylWord &ww) const
Definition: weyl.h:722
Generator & operator[](size_t i)
Definition: weyl.h:59
~Transducer()
Definition: weyl.h:291
Generator min_neighbor(Generator s) const
first generator $<s$ not commuting with |s|, or |s| if none exist
Definition: weyl.h:465
std::vector< WeylWord > d_piece
Reduced expressions of the minimal coset representatives.
Definition: weyl.h:282
int twistedConjugate(TwistedInvolution &tw, Generator s) const
Definition: weyl.h:716
WeylElt & contents()
Definition: weyl.h:182
int leftMult(WeylElt &w, Generator s) const
Definition: weyl.h:681
void translate(WeylElt &w, const WeylInterface &i) const
Definition: weyl.h:600
bool hasDescent(const WeylElt &w, Generator s) const
Definition: weyl.h:695
static const unsigned char ucharMax
Definition: constants.h:39
Definition: weyl.h:780
A mapping between one interpretation of Generators and another.
Definition: weyl.h:53
int_Matrix d_coxeterMatrix
Definition: weyl.h:436
size::Size d_order
Definition: weyl.h:433
WeylInterface d_in
Definition: weyl.h:440
WeylElt prod(const WeylElt &w, const WeylElt &v) const
Definition: weyl.h:687
Generator out(WeylElt::EltPiece x, Generator s) const
Simple reflection t (strictly preceding s) so that xs = tx, if any.
Definition: weyl.h:316
Definition: Atlas.h:78
std::vector< TwistedInvolution > TwistedInvolutionList
Definition: Atlas.h:235
WeylElt prod(Generator s, const WeylElt &w) const
Definition: weyl.h:500
WeylElt prod(const WeylElt &w, const WeylWord &ww) const
Definition: weyl.h:688
void leftMult(WeylElt &w, const WeylWord &ww) const
Definition: weyl.h:491
unsigned long length(WeylElt::EltPiece x) const
Length of minimal coset representative x.
Definition: weyl.h:299
Generator twisted(Generator s) const
Definition: weyl.h:698
const WeylGroup & W
Definition: weyl.h:661
std::vector< Generator > d_min_star
Definition: weyl.h:442
unsigned int g(A &x)
Definition: lists.cpp:38
Definition: Atlas.h:38
Represents one row of a transducer table for a Weyl group.
Definition: weyl.h:191
Definition: tags.h:51
WeylElt prod(const WeylElt &w, Generator s) const
Definition: weyl.h:498
void mult(WeylElt &w, const WeylElt &v) const
Definition: weyl.h:678
WeylElt generator(Generator i) const
Definition: weyl.h:477
Weight image_by(const RootDatum &rd, const WeylElt &w, Weight v) const
Nondestructive version of |act| method.
Definition: weyl.h:624
unsigned short RootNbr
Definition: Atlas.h:216
WeylElt opposite(const WeylElt &w) const
Definition: weyl.h:574
unsigned char EltPiece
Represents a minimal length coset representative for one of the parabolic subquotients W_{i-1}\W_i...
Definition: weyl.h:98
size_t d_rank
Definition: weyl.h:432
unsigned char Generator
Definition: Atlas.h:226
Definition: common.h:36
std::vector< RootNbr > RootNbrList
Definition: Atlas.h:217
WeylElt translation(const WeylElt &w, const WeylInterface &f) const
Applies to |w| the generator permutation in |I|, which should be an automorphism of the Dynkin diagra...
Definition: weyl.cpp:580
unsigned long d_maxlength
Definition: weyl.h:434
WeylElt twisted(const WeylElt &w) const
Definition: weyl.h:699
std::vector< OutRow > d_out
If |d_shift[i][j]==i| then $s_j$ transduces in state $i$ to $s_k$ with $k=d_out[i][j]$ (otherwise |d_...
Definition: weyl.h:272
unsigned long maxlength() const
Definition: weyl.h:576
std::vector< TI_Entry > Pooltype
Definition: weyl.h:787
TwistedWeylGroup(const TwistedWeylGroup &g)
Definition: weyl.h:666
void conjugate(WeylElt &w, Generator s) const
Conjugates |w| by the generator |s|: |w=sws|.
Definition: weyl.h:545
Stores a positive integer as product of prime powers, using the first PRIMES_MAX primes.
Definition: Atlas.h:127
bool operator==(const Twist &y) const
Definition: weyl.h:68
WeylElt element(const WeylWord &ww) const
Definition: weyl.h:584
const WeylElt & w() const
Definition: weyl.h:181
RowBase & operator=(const RowBase &r)
Definition: weyl.h:211
bool commutes(Generator s, Generator t) const
Definition: weyl.h:561
int mult(WeylElt &w, Generator s) const
Definition: weyl.h:677
Vertex v
Definition: graph.cpp:116
const WeylElt & longest() const
Definition: weyl.h:568
const unsigned char UndefValue
Definition: weyl.h:44
const WeylElt Identity
Definition: weyl.h:186