atlas  0.6
rootdata.h
Go to the documentation of this file.
1
5 /*
6  This is rootdata.h
7
8  Copyright (C) 2004,2005 Fokko du Cloux
9  Copyright (C) 2006--2010 Marc van Leeuwen
10  part of the Atlas of Lie Groups and Representations
11
13 */
14
15 #ifndef ROOTDATA_H /* guard against multiple inclusions */
16 #define ROOTDATA_H
17
18 #include "../Atlas.h"
19
20 #include <algorithm>
21
22 #include "arithmetic_fwd.h"
23 #include "../Atlas.h"
24 #include "tags.h"
25
26 #include "bitset.h" // for ascent and descent sets
27 #include "matrix.h" // for loads of subobjects
28 #include "permutations.h" // for storing root permutations
29
30 namespace atlas {
31
32 /******** type declarations *************************************************/
33
34
35 /******** function declarations *********************************************/
36
37 namespace rootdata {
38
39 RatWeight rho (const RootDatum& rd);
40 RatCoweight rho_check (const RootDatum& rd);
41
43  (const WeightInvolution&, const RootDatum&);
44
45 RootNbrSet makeOrthogonal(const RootNbrSet& o, const RootNbrSet& subsys,
46  const RootSystem& rs);
47
48 void toDistinguished(WeightInvolution&, const RootDatum&);
49
50 // make |Delta| simple (a twist) by Weyl group action; return Weyl word
51 // whose left-multiplication transforms returned |Delta| into original one
52 WeylWord wrt_distinguished(const RootSystem& rs, RootNbrList& Delta);
53
54 // force root positive; unlike |rs.rt_abs(alpha)| does not shift positive roots
55 void make_positive(const RootSystem& rs,RootNbr& alpha);
56
57 // conjugate |alpha| to a simple root, returning right-conjugating word applied
58 // afterwards |alpha| is shifted to become a \emph{simple} root index
59 WeylWord conjugate_to_simple(const RootSystem& rs,RootNbr& alpha);
60
61 // compute product of reflections in set of orthogonal roots
62 WeightInvolution refl_prod(const RootNbrSet&, const RootDatum&);
63
64 RootDatum integrality_datum(const RootDatum& rd, const RatWeight& gamma);
65 RationalList integrality_points(const RootDatum& rd, const RatWeight& gamma);
66 unsigned int integrality_rank(const RootDatum& rd, const RatWeight& gamma);
67
68 } // |namespace rootdata|
69
70 /******** type definitions **************************************************/
71
72 namespace rootdata {
73
74
76 {
77  typedef signed char byte;
79  struct root_info
80  {
81  Byte_vector root, dual; // root in root basis, coroot in coroot basis
82  RankFlags descents,ascents; // for reflections by simple roots
83
84  root_info(const Byte_vector& v)
85  : root(v), dual(), descents(), ascents() {}
86  };
87  struct root_compare; // auxilary type defined here for access reasons
88
89  size_t rk; // rank of root system
90
91  Byte_vector Cmat; // Cartan matrix in compressed format
92
93  std::vector<root_info> ri; // information about individual positive roots
94
96
98  std::vector<Permutation> root_perm;
99
100  // internal access methods
102  { return Cmat[i*rk+j]; }
104  { return Cmat[i*rk+j]; }
105  Byte_vector& root(RootNbr i) { return ri[i].root;}
106  Byte_vector& coroot(RootNbr i) { return ri[i].dual;}
107  const Byte_vector& root(RootNbr i) const { return ri[i].root;}
108  const Byte_vector& coroot(RootNbr i) const { return ri[i].dual;}
109
110  public:
111
112 // constructors and destructors
113
114  explicit RootSystem(const int_Matrix& Cartan_matrix);
115
116  RootSystem(const RootSystem& rs, tags::DualTag);
117
118 // accessors
119
120  size_t rank() const { return rk; } // semisimple rank when part of |RootDatum|
121  unsigned long numPosRoots() const { return ri.size(); }
122  unsigned long numRoots() const { return 2*numPosRoots(); }
123
124  // Cartan matrix by entry and as a whole
126  { return Cartan_entry(i,j); };
127  int_Matrix cartanMatrix() const;
128  LieType Lie_type() const;
129
130  // for subsystem
131  int_Matrix cartanMatrix(const RootNbrList& sub) const;
132  LieType Lie_type(RootNbrList sub) const;
133
134
135
136 // root list access
137
138  // express root in simple root basis, or coroot in simple coroot basis
139  int_Vector root_expr(RootNbr alpha) const;
140  int_Vector coroot_expr(RootNbr alpha) const;
141
142  int level(RootNbr alpha) const; // equals |root(alpha).dot(dual_twoRho())/2|
143  int colevel(RootNbr alpha) const; // equals |coroot(alpha).(twoRho())/2|
144
145  // convert sequence of root numbers to expressions in the simple roots
146  template <typename I, typename O>
147  void toRootBasis(I, I, O) const;
148  // convert sequence of root numbers to expressions in subsystem simple roots
149  template <typename I, typename O>
150  void toRootBasis(I, I, O, const RootNbrList&) const;
151  // convert sequence of root numbers to expressions in subsystem simple weights
152  template <typename I, typename O>
153  void toSimpleWeights(I, I, O, const RootNbrList&) const;
154
155  bool is_simple_root(RootNbr alpha) const
156  { return alpha-numPosRoots()<rk; } // this uses that |RootNbr| is unsigned
157
158  bool is_posroot(RootNbr alpha) const
159  { return alpha>=numPosRoots(); } // second half
160
161  bool is_negroot(RootNbr alpha) const
162  { return alpha<numPosRoots(); } // first half
163
165  { assert(i<rk); return numPosRoots()+i; }
166
167  RootNbr posRootNbr(size_t alpha) const
168  { assert(alpha<numPosRoots()); return numPosRoots()+alpha; }
169
170  RootNbr simpleRootIndex(size_t alpha) const
171  { assert(is_simple_root(alpha)); return alpha-numPosRoots(); }
172
173  RootNbr posRootIndex(size_t alpha) const
174  { assert(is_posroot(alpha)); return alpha-numPosRoots(); }
175
176  RootNbr rootMinus(RootNbr alpha) const // roots are ordered symmetrically
177  { return numRoots()-1-alpha; }
178
179  RootNbr rt_abs(RootNbr alpha) const // offset of corresponding positive root
180  { return is_posroot(alpha) ? alpha-numPosRoots() : numPosRoots()-1-alpha; }
181
182
183  RootNbrSet simpleRootSet() const; // NOT for iteration over it; never used
184  RootNbrList simpleRootList() const; // NOT for iteration over it
185  RootNbrSet posRootSet() const; // NOT for iteration, may serve as mask
186
187 // other accessors
188
189  // The next method requires a positive root index |i|. It is however used
190  // mostly with simple roots, whence the name. See |root_permutation| below.
191  const Permutation& simple_root_permutation(weyl::Generator i) const
192  { return root_perm[i]; }
193
195  {
196  RootNbr a = rt_abs(alpha);
197  return is_posroot(alpha) ? ri[a].descents : ri[a].ascents;
198  }
200  {
201  RootNbr a = rt_abs(alpha);
202  return is_posroot(alpha) ? ri[a].ascents : ri[a].descents;
203  }
204
205  size_t find_descent(RootNbr alpha) const
206  { return descent_set(alpha).firstBit(); }
207
208  bool is_descent(weyl::Generator i, RootNbr alpha) const
209  { return root_perm[i][alpha]<alpha; } // easier than using |descent_set|
210
211  bool is_ascent(weyl::Generator i, RootNbr alpha) const
212  { return root_perm[i][alpha]>alpha; }
213
215  { return simple_root_permutation(i)[r]; }
216
218  { r=simple_root_permutation(i)[r]; }
219
220  RootNbr permuted_root(const WeylWord& ww, RootNbr r) const
221  {
222  for (weyl::Generator i=ww.size(); i-->0; )
223  simple_reflect_root(ww[i],r);
224  return r;
225  }
226
227  RootNbr permuted_root(RootNbr r,const WeylWord& ww) const
228  {
229  for (weyl::Generator i=0; i<ww.size(); ++i)
230  simple_reflect_root(ww[i],r);
231  return r;
232  }
233
234  // for arbitrary roots, reduce root number to positive root offset first
235  const Permutation& root_permutation(RootNbr alpha) const
236  { return root_perm[rt_abs(alpha)]; }
237
238  bool isOrthogonal(RootNbr alpha, RootNbr beta) const
239  { return root_permutation(alpha)[beta]==beta; }
240
241  // pairing between root |alpha| and coroot |beta|
242  int bracket(RootNbr alpha, RootNbr beta) const;
243
244
245
246  // find (simple preserving) roots permutation induced by diagram automorphism
247  Permutation root_permutation(const Permutation& twist) const;
248
249  // extend root datum automorphism given on simple roots to all roots
250  Permutation extend_to_roots(const RootNbrList& simple_images) const;
251
252
253  WeylWord reflectionWord(RootNbr r) const;
254
255  // express sum of roots positive for |Delta| in fundamental weights
256  matrix::Vector<int> pos_system_vec(const RootNbrList& Delta) const;
257
258  // find simple basis for subsystem
259  RootNbrList simpleBasis(RootNbrSet rs) const;
260
261  bool sumIsRoot(RootNbr alpha, RootNbr beta, RootNbr& gamma) const;
262  bool sumIsRoot(RootNbr alpha, RootNbr beta) const
263  { RootNbr dummy; return sumIsRoot(alpha,beta,dummy); }
264
265  RootNbrSet long_orthogonalize(const RootNbrSet& rest) const;
266
267  RootNbrList high_roots() const;
268
269 // manipulators
270
271
272 }; // |class RootSystem|
273
297 : public RootSystem
298 {
299
300  private:
308  enum StatusFlagNames { IsAdjoint, IsSimplyConnected, numFlags };
309
310
311  typedef BitSet<numFlags> Status;
312
316  size_t d_rank;
317
324
330
332
340  Status d_status;
341
342
343  public:
344
345 // constructors and destructors
346
348  : RootSystem(int_Matrix(0,0))
349  , d_rank(0)
350  {}
351
352  explicit RootDatum(const PreRootDatum&);
353
355
356  RootDatum(int_Matrix& projector, const RootDatum&, tags::DerivedTag);
357
358  RootDatum(int_Matrix& injector, const RootDatum&, tags::AdjointTag);
359
360  RootDatum sub_datum(const RootNbrList& generators) const; // pseudo-constructor
361
362 // accessors
363
364  const RootSystem& root_system() const { return *this; } // base object ref
365  size_t rank() const { return d_rank; }
366  size_t semisimpleRank() const { return RootSystem::rank(); }
367
368 // root list access
369
370  WeightList::const_iterator beginRoot() const
371  { return d_roots.begin(); }
372
373  WeightList::const_iterator endRoot() const
374  { return d_roots.end(); }
375
376  CoweightList::const_iterator beginCoroot() const
377  { return d_coroots.begin(); }
378
379  CoweightList::const_iterator endCoroot() const
380  { return d_coroots.end(); }
381
384
387
390
393
394  // below |WRootIterator| is legacy; it equals |WeightList::const_iterator|
395  WRootIterator beginSimpleRoot() const // simple roots start halfway
396  { return beginRoot()+numPosRoots(); }
397
398  WRootIterator endSimpleRoot() const // and end after |semisimpleRank()|
399  { return beginSimpleRoot()+semisimpleRank(); }
400
401  WRootIterator beginPosRoot() const // positive roots start halfway
402  { return beginSimpleRoot(); }
403
404  WRootIterator endPosRoot() const // an continue to the end
405  { return endRoot(); }
406
408  { return beginCoroot()+numPosRoots(); }
409
411  { return beginSimpleCoroot()+semisimpleRank(); }
412
413  WRootIterator beginPosCoroot() const // positive coroots start halfway
414  { return beginSimpleCoroot(); }
415
417  { return endCoroot(); }
418
419
420  bool isRoot(const Weight& v) const // ask this of a weight
421  { return permutations::find_index(d_roots,v) != d_roots.size(); }
422
423  bool isSemisimple() const { return d_rank == semisimpleRank(); }
424
425  const Weight& root(RootNbr i) const
426  { assert(i<numRoots()); return d_roots[i]; }
427
429  { assert(i<semisimpleRank()); return *(beginSimpleRoot()+i); }
430
431  const Weight& posRoot(size_t i) const
432  { assert(i<numPosRoots()); return *(beginPosRoot()+i); }
433
434  RootNbr root_index(const Root& r) const
435  { return permutations::find_index(d_roots,r); }
436
437
438  const Coweight& coroot(RootNbr i) const
439  { assert(i<numRoots()); return d_coroots[i]; }
440
442  { assert(i<semisimpleRank()); return *(beginSimpleCoroot()+i); }
443
444  const Coweight& posCoroot(size_t i) const
445  { assert(i<numPosRoots()); return *(beginPosCoroot()+i); }
446
447  RootNbr coroot_index(const Root& r) const
448  { return permutations::find_index(d_coroots,r); }
449
450
451  // avoid inlining of the following to not depend on rational vector
452  RatWeight fundamental_weight(weyl::Generator i) const;
453  RatCoweight fundamental_coweight(weyl::Generator i) const;
454
455 // other accessors
456
465
474  bool isSimplyConnected() const { return d_status[IsSimplyConnected]; }
475
476
477  const Weight& twoRho() const { return d_2rho; }
478  const Coweight& dual_twoRho() const { return d_dual_2rho; }
479
480
481  int scalarProduct(const Weight& v, RootNbr j) const
482  { return v.dot(coroot(j)); }
483
484  using RootSystem::isOrthogonal; // for the case of two RootNbr values
485  bool isOrthogonal(const Weight& v, RootNbr j) const
486  { return v.dot(coroot(j))==0; }
487
489  { return simpleRoot(i).dot(simpleCoroot(j)); }
490
491  // Apply reflection about root |alpha| to a weight |lambda|.
492  template<typename C>
494  { lambda.subtract(root(alpha).begin(),coroot(alpha).dot(lambda)); }
495  // Apply reflection about coroot |alpha| to a coweight |co_lambda|
496  template<typename C>
497  void coreflect(matrix::Vector<C>& co_lambda, RootNbr alpha) const
498  { co_lambda.subtract(coroot(alpha).begin(),root(alpha).dot(co_lambda)); }
499
500  // on matrices we have left and right multiplication by reflection matrices
501  void reflect(RootNbr alpha, LatticeMatrix& M) const;
502  void reflect(LatticeMatrix& M,RootNbr alpha) const;
503
504  template<typename C>
507  { reflect(alpha,lambda); return lambda; }
508  template<typename C>
510  coreflection(matrix::Vector<C> co_lambda, RootNbr alpha) const
511  { coreflect(co_lambda,alpha); return co_lambda; }
512
513  template<typename C>
515  { reflect(simpleRootNbr(i),v); }
516  template<typename C>
518  { coreflect(v,simpleRootNbr(i)); }
519
521  { reflect(simpleRootNbr(i),M); }
523  { reflect(M,simpleRootNbr(i)); }
524
525
526  template<typename C>
529  { simple_reflect(i,lambda); return lambda; }
530  template<typename C>
533  { simple_coreflect(ell,i); return ell; }
534
535  WeylWord to_dominant(Weight lambda) const; // call by value
536  void act(const WeylWord& ww,Weight& lambda) const
537  {
538  for (weyl::Generator i=ww.size(); i-->0; )
539  simple_reflect(ww[i],lambda);
540  }
541  Weight image_by(const WeylWord& ww,Weight lambda) const
542  { act(ww,lambda); return lambda; }
543
544  // with inverse we invert operands to remind how letters of |ww| are used
545  void act_inverse(Weight& lambda,const WeylWord& ww) const
546  {
547  for (weyl::Generator i=0; i<ww.size(); ++i)
548  simple_reflect(ww[i],lambda);
549  }
550
551  Weight image_by_inverse(Weight lambda,const WeylWord& ww) const
552  { act_inverse(lambda,ww); return lambda; }
553
554 #if 0
555  void dual_act_inverse(const WeylWord& ww,Coweight& ell) const
556  {
557  for (weyl::Generator i=ww.size(); i-->0; )
558  simple_coreflect(ell,ww[i]);
559  }
560  Weight dual_image_by_inverse(const WeylWord& ww,Weight lambda) const
561  { dual_act_inverse(ww,lambda); return lambda; }
562 #endif
563
564  // here the word |ww| is travered as in |act_inverse|, but coreflection used
565  void dual_act(Coweight& ell,const WeylWord& ww) const
566  {
567  for (weyl::Generator i=0; i<ww.size(); ++i)
568  simple_coreflect(ell,ww[i]);
569  }
570  Weight dual_image_by(Coweight ell,const WeylWord& ww) const
571  { dual_act(ell,ww); return ell; }
572
573  // here any matrix permuting the roots is allowed, e.g., root_reflection(r)
574  Permutation rootPermutation(const WeightInvolution& q) const;
575
576  WeightInvolution root_reflection(RootNbr r) const;
578  { return root_reflection(simpleRootNbr(i)); }
579
580  WeightInvolution matrix(const WeylWord& ww) const;
581
582  WeylWord reflectionWord(RootNbr r) const;
583
584  // express root in basis of simple roots
585  int_Vector inSimpleRoots(RootNbr alpha) const { return root_expr(alpha); }
586  // express coroot in basis of simple coroots
587  int_Vector inSimpleCoroots(RootNbr alpha) const { return coroot_expr(alpha); }
588
589  Weight twoRho(const RootNbrList&) const;
590  Weight twoRho(const RootNbrSet&) const;
591  Coweight dual_twoRho(const RootNbrList&) const;
592  Coweight dual_twoRho(const RootNbrSet&) const;
593
594
595  WeylWord word_of_inverse_matrix(const WeightInvolution&)
596  const;
597
598 // manipulators
599
600  void swap(RootDatum&);
601
602 // private methods used during construction
603  private:
604
605  void fillStatus();
606
607
608 }; // |class RootDatum|
609
610
611 } // |namespace rootdata|
612
613 } // |namespace atlas|
614
615 #endif
matrix::Vector< C > reflection(matrix::Vector< C > lambda, RootNbr alpha) const
Definition: rootdata.h:506
root_info(const Byte_vector &v)
Definition: rootdata.h:84
signed char byte
Definition: rootdata.h:77
Byte_vector & root(RootNbr i)
Definition: rootdata.h:105
WeightInvolution refl_prod(const RootNbrSet &rset, const RootDatum &rd)
Definition: rootdata.cpp:1204
size_t semisimpleRank() const
Definition: rootdata.h:366
mod_pointer root
Definition: common.c:127
C1 dot(const Vector< C1 > &v) const
Definition: matrix.cpp:147
RatCoweight rho_check(const RootDatum &rd)
Definition: rootdata.cpp:1078
WeightList d_roots
Full list of roots.
Definition: rootdata.h:318
bool isOrthogonal(RootNbr alpha, RootNbr beta) const
Definition: rootdata.h:238
const Byte_vector & coroot(RootNbr i) const
Definition: rootdata.h:108
WRootIterator beginPosCoroot() const
Definition: rootdata.h:413
Weight image_by(const WeylWord &ww, Weight lambda) const
Definition: rootdata.h:541
Definition: rootdata.h:388
BitSet< constants::RANK_MAX > RankFlags
Definition: Atlas.h:60
LieType Lie_type(const int_Matrix &cm)
Definition: dynkin.cpp:394
WeylWord conjugate_to_simple(const RootSystem &rs, RootNbr &alpha)
Definition: rootdata.cpp:1182
bool isSemisimple() const
Definition: rootdata.h:423
void act_inverse(Weight &lambda, const WeylWord &ww) const
Definition: rootdata.h:545
std::vector< Rational > RationalList
Definition: Atlas.h:74
void act(const WeylWord &ww, Weight &lambda) const
Definition: rootdata.h:536
RootNbr simple_reflected_root(weyl::Generator i, RootNbr r) const
Definition: rootdata.h:214
unsigned long numPosRoots() const
Definition: rootdata.h:121
Basis for orthogonal to coroots.
Definition: rootdata.h:322
int Cartan_denom
Denominator for (co)|weight_numer|.
Definition: rootdata.h:331
const byte & Cartan_entry(weyl::Generator i, weyl::Generator j) const
Definition: rootdata.h:103
Basis for orthogonal to roots.
Definition: rootdata.h:323
void swap(simple_list< T, Alloc > &x, simple_list< T, Alloc > &y)
Definition: sl_list.h:674
void simple_reflect(weyl::Generator i, LatticeMatrix &M) const
Definition: rootdata.h:520
Weight dual_image_by(Coweight ell, const WeylWord &ww) const
Definition: rootdata.h:570
const Permutation & simple_root_permutation(weyl::Generator i) const
Definition: rootdata.h:191
int_Vector two_rho_in_simple_roots
Definition: rootdata.h:95
Byte_vector & coroot(RootNbr i)
Definition: rootdata.h:106
Vector & subtract(I b, C c)
Definition: matrix.h:84
RootNbr simpleRootNbr(weyl::Generator i) const
Definition: rootdata.h:164
void simple_coreflect(matrix::Vector< C > &v, weyl::Generator i) const
Definition: rootdata.h:517
RootDatum integrality_datum(const RootDatum &rd, const RatWeight &gamma)
Definition: rootdata.cpp:1213
const Weight & simpleRoot(weyl::Generator i) const
Definition: rootdata.h:428
unsigned int level
Definition: Atlas.h:404
WeylWord wrt_distinguished(const RootSystem &rs, RootNbrList &Delta)
Definition: rootdata.cpp:1149
RootNbr rt_abs(RootNbr alpha) const
Definition: rootdata.h:179
Weight image_by_inverse(Weight lambda, const WeylWord &ww) const
Definition: rootdata.h:551
Status d_status
BitSet recording whether the root datum is adjoint/simply connected.
Definition: rootdata.h:340
Definition: rootdata.h:391
WRootIterator beginSimpleCoroot() const
Definition: rootdata.h:407
int_Matrix CoweightInvolution
Definition: Atlas.h:160
Definition: tags.h:42
bool isOrthogonal(const Weight &v, RootNbr j) const
Definition: rootdata.h:485
RootNbr permuted_root(RootNbr r, const WeylWord &ww) const
Definition: rootdata.h:227
WeightInvolution simple_reflection(weyl::Generator i) const
Definition: rootdata.h:577
unsigned int integrality_rank(const RootDatum &rd, const RatWeight &gamma)
Definition: rootdata.cpp:1225
RankFlags descent_set(RootNbr alpha) const
Definition: rootdata.h:194
byte & Cartan_entry(weyl::Generator i, weyl::Generator j)
Definition: rootdata.h:101
const Coweight & simpleCoroot(weyl::Generator i) const
Definition: rootdata.h:441
WRootIterator endPosRoot() const
Definition: rootdata.h:404
WRootIterator endPosCoroot() const
Definition: rootdata.h:416
size_t rank() const
Definition: rootdata.h:365
Definition: rootdata.h:75
const Weight & posRoot(size_t i) const
Definition: rootdata.h:431
int_Vector inSimpleRoots(RootNbr alpha) const
Definition: rootdata.h:585
WRootIterator endSimpleCoroot() const
Definition: rootdata.h:410
BitSet< numFlags > Status
Definition: rootdata.h:311
RootNbr rootMinus(RootNbr alpha) const
Definition: rootdata.h:176
Based root datum for a complex reductive group.
Definition: rootdata.h:296
Byte_vector root
Definition: rootdata.h:81
std::vector< Weight > WeightList
Definition: Atlas.h:162
WeightList weight_numer
Fundamental weight numerators.
Definition: rootdata.h:320
Coweight d_dual_2rho
Definition: rootdata.h:329
CoweightList d_coroots
Full list of coroots.
Definition: rootdata.h:319
CoweightList::const_iterator beginCoroot() const
Definition: rootdata.h:376
bool is_simple_root(RootNbr alpha) const
Definition: rootdata.h:155
Definition: rootdata.h:382
size_t find_index(const std::vector< T > &v, const T &x)
Definition: permutations.h:31
matrix::Vector< byte > Byte_vector
Definition: rootdata.h:78
void make_positive(const RootSystem &rs, RootNbr &alpha)
Definition: rootdata.cpp:1174
const Coweight & posCoroot(size_t i) const
Definition: rootdata.h:444
RootDatum()
Definition: rootdata.h:347
bool is_ascent(weyl::Generator i, RootNbr alpha) const
Definition: rootdata.h:211
RatWeight rho(const RootDatum &rd)
Definition: rootdata.cpp:1076
const Coweight & dual_twoRho() const
Definition: rootdata.h:478
Definition: tags.h:45
void generators(GrpNbrList &gen, const bitmap::BitMap &B, const FiniteAbelianGroup &A)
Definition: abelian.cpp:550
bool is_posroot(RootNbr alpha) const
Definition: rootdata.h:158
WRootIterator endSimpleRoot() const
Definition: rootdata.h:398
struct subscription_node * sub
Definition: parse_types.h:102
Layout dual(const Layout &lo)
Definition: lietype.cpp:386
Tells whether the rootdatum is the rootdatum of an adjoint group.
Definition: rootdata.h:464
matrix::Vector< C > simple_reflection(weyl::Generator i, matrix::Vector< C > lambda) const
Definition: rootdata.h:528
RootNbr posRootIndex(size_t alpha) const
Definition: rootdata.h:173
bool is_negroot(RootNbr alpha) const
Definition: rootdata.h:161
Weight d_2rho
Sum of the positive roots.
Definition: rootdata.h:328
matrix::Vector< C > coreflection(matrix::Vector< C > co_lambda, RootNbr alpha) const
Definition: rootdata.h:510
int scalarProduct(const Weight &v, RootNbr j) const
Definition: rootdata.h:481
bool sumIsRoot(RootNbr alpha, RootNbr beta) const
Definition: rootdata.h:262
WeightList::const_iterator endRoot() const
Definition: rootdata.h:373
bitmap::BitMap RootNbrSet
Definition: Atlas.h:218
WRootIterator beginPosRoot() const
Definition: rootdata.h:401
void reflect(RootNbr alpha, matrix::Vector< C > &lambda) const
Definition: rootdata.h:493
StatusFlagNames
Names describing the bits of the bitset d_status.
Definition: rootdata.h:308
int cartan(weyl::Generator i, weyl::Generator j) const
Definition: rootdata.h:125
void simple_reflect_root(weyl::Generator i, RootNbr &r) const
Definition: rootdata.h:217
int_Matrix WeightInvolution
Definition: Atlas.h:159
const Byte_vector & root(RootNbr i) const
Definition: rootdata.h:107
RationalList integrality_points(const RootDatum &rd, const RatWeight &gamma)
Definition: rootdata.cpp:1237
size_t find_descent(RootNbr alpha) const
Definition: rootdata.h:205
void dual_act(Coweight &ell, const WeylWord &ww) const
Definition: rootdata.h:565
const Permutation & root_permutation(RootNbr alpha) const
Definition: rootdata.h:235
std::vector< root_info > ri
Definition: rootdata.h:93
Byte_vector Cmat
Definition: rootdata.h:91
std::vector< Weight > CoweightList
Definition: Atlas.h:163
Definition: rootdata.h:385
bool is_descent(weyl::Generator i, RootNbr alpha) const
Definition: rootdata.h:208
RootNbr posRootNbr(size_t alpha) const
Definition: rootdata.h:167
WRootIterator beginSimpleRoot() const
Definition: rootdata.h:395
struct lambda_node * lambda
Definition: parse_types.h:94
bool isRoot(const Weight &v) const
Definition: rootdata.h:420
RootNbrSet makeOrthogonal(const RootNbrSet &o, const RootNbrSet &subsys, const RootSystem &rs)
Returns the elements of |subsys| which are orthogonal to all elements of |o|.
Definition: rootdata.cpp:1108
size_t d_rank
Rank of the root datum.
Definition: rootdata.h:316
void simple_reflect(weyl::Generator i, matrix::Vector< C > &v) const
Definition: rootdata.h:514
void simple_reflect(LatticeMatrix &M, weyl::Generator i) const
Definition: rootdata.h:522
Definition: Atlas.h:38
Definition: tags.h:51
WeightList::const_iterator beginRoot() const
Definition: rootdata.h:370
size_t rank() const
Definition: rootdata.h:120
void coreflect(matrix::Vector< C > &co_lambda, RootNbr alpha) const
Definition: rootdata.h:497
RootNbr simpleRootIndex(size_t alpha) const
Definition: rootdata.h:170
RootNbr coroot_index(const Root &r) const
Definition: rootdata.h:447
RankFlags ascent_set(RootNbr alpha) const
Definition: rootdata.h:199
Class definitions and function declarations for the BitSet class.
Container of a large (more than twice the machine word size) set of bits.
Definition: bitmap.h:52
CoweightList coweight_numer
Fundamental coweight numerators.
Definition: rootdata.h:321
RootNbr permuted_root(const WeylWord &ww, RootNbr r) const
Definition: rootdata.h:220
WeightList::const_iterator WRootIterator
Definition: Atlas.h:212
unsigned short RootNbr
Definition: Atlas.h:216
ratvec::RationalVector< arithmetic::Numer_t > RatCoweight
Definition: Atlas.h:157
const Weight & twoRho() const
Definition: rootdata.h:477
unsigned char Generator
Definition: Atlas.h:226
int cartan(weyl::Generator i, weyl::Generator j) const
Definition: rootdata.h:488
RankFlags descents
Definition: rootdata.h:82
const RootSystem & root_system() const
Definition: rootdata.h:364
matrix::Vector< C > simple_coreflection(matrix::Vector< C > ell, weyl::Generator i) const
Definition: rootdata.h:532
std::vector< RootNbr > RootNbrList
Definition: Atlas.h:217
int_Vector inSimpleCoroots(RootNbr alpha) const
Definition: rootdata.h:587
CoweightList::const_iterator endCoroot() const
Definition: rootdata.h:379
bool isSimplyConnected() const
Tells whether the rootdatum is the rootdatum of a simply connected group.
Definition: rootdata.h:474
void toDistinguished(WeightInvolution &q, const RootDatum &rd)
Transforms q, assumed a root datum involution, into a based root datum involution w...
Definition: rootdata.cpp:1138
unsigned long numRoots() const
Definition: rootdata.h:122
CoweightInvolution dualBasedInvolution(const WeightInvolution &q, const RootDatum &rd)
Definition: rootdata.cpp:1097
const Weight & root(RootNbr i) const
Definition: rootdata.h:425
const Coweight & coroot(RootNbr i) const
Definition: rootdata.h:438
std::vector< Permutation > root_perm
Root permutations induced by reflections in all positive roots.
Definition: rootdata.h:98
ratvec::RationalVector< arithmetic::Numer_t > RatWeight
Definition: Atlas.h:156
size_t rk
Definition: rootdata.h:87
RootNbr root_index(const Root &r) const
Definition: rootdata.h:434
Vertex v
Definition: graph.cpp:116