atlas  0.6
standardrepk.h
Go to the documentation of this file.
1
6 /*
7  This is standardrepk.h
8
9  Copyright (C) 2004, 2005 Fokko du Cloux
10  Copyright (C) 2008, 2009 Marc van Leeuwen
11  part of the Atlas of Lie Groups and Representations version 0.2.4
12
14 */
15
16 #ifndef STANDARDREPK_H /* guard against multiple inclusions */
17 #define STANDARDREPK_H
18
19 #include <set>
20 #include <vector>
21 #include <iostream>
22
23 #include "../Atlas.h"
24
25 #include "innerclass.h"// inlines
26 #include "realredgp.h" // numerous inline methods
27 #include "hashtable.h" // containment
28 #include "free_abelian.h"// containment and use via |Char|
29
30
31 namespace atlas {
32
33 /******** type declarations and typedefs ************************************/
34
35 namespace standardrepk {
36
37
38 // type |HCParam|: image of a weight of the $\rho$-cover mod $(1-\theta)X^*$
39
40 // the following cannot be in ../Atlas.h: they need free_abelian.h
41 typedef Char::coef_t CharCoeff;
42 typedef q_Char::coef_t q_CharCoeff; // i.e., |Polynomial<int>|
43
44 // remaining definitions could be in ../Atlas.h, but seem module-specific
45
47 typedef std::pair<seq_no,combination> equation;
48
50 typedef std::pair<seq_no,q_combin> q_equation;
51
52
53 /******** function declarations *********************************************/
54
55 template <typename C>
57  (const std::vector<
58  std::pair<seq_no,
60  > >& system,
61  std::vector<seq_no>& new_order);
62
63 template <typename C>
65  (const matrix::Matrix_base<C>& U);
66
67  q_combin to_q(const combination& c);
68  combination q_is_1(const q_combin& c);
69
70  q_Char to_q(const Char& chi);
71  Char q_is_1(const q_Char& chi);
72
73
74 /******** type definitions **************************************************/
75
76
141 {
142
143  friend class SRK_context; // which is like |WeylGroup| is for |WeylElt|
144
148  size_t d_cartan;
149
150 // no real form or base grading recorded in elements; they're in |KhatContext|
154  TorusPart d_fiberElt; // a SmallBitVector
155
160
161 // constructors, destructors, and swap
162
163  // main constructor is private, used by |SRK_context| methods
164  // fundamental bare-bones constructor
165  StandardRepK(size_t cn, const TorusPart& x, const HCParam& lambda)
166  : d_cartan(cn), d_fiberElt(x), d_lambda(lambda) {}
167
168 public:
169
170  StandardRepK() : d_fiberElt(0) {} // so empty slots can be created
171
172  void swap(const StandardRepK&);
173
174  // accessors
175
176  bool operator< (const StandardRepK&) const;
177  bool operator== (const StandardRepK&) const;
178
179  size_t Cartan() const { return d_cartan; }
180
181 // manipulators: none (done by friend class KhatContext)
182
183 // special members required by HashTable
184
185  typedef std::vector<StandardRepK> Pooltype;
186  bool operator!=(const StandardRepK& another) const
187  { return not operator==(another); }
188  size_t hashCode(size_t modulus) const;
189
190 }; // |class StandardRepK|
191
192
195 {
196  // projection matrix to torsion free part
198  // projection matrix to torsion part, after rho-shift and reduction mod 2
200
201  // matrix used to lift free part of |HCParam| back to a weight
203
204  // list of vectors used to lift torsion part of |HCParam| to a weight
206
207  // space that fiber parts are reduced modulo
209
210  // simple roots orthogonal to sums of positive imaginary and real roots
211  // a chosen one from each pair of $\theta$-conjugate such simple roots
212  RankFlags bi_ortho; // simple roots, and necessarily complex ones
213  WeightList sum_coroots; // associated sums of 2 coroots
214
215  Cartan_info() : torsionProjector(0) {}
216
217  const Weight& coroot_sum(size_t i) const
218  { assert (bi_ortho[i]); return sum_coroots[bi_ortho.position(i)]; }
219
220 }; // |struct Cartan_info|
221
222 // a data type used for storing projections to facets of fundamental chamber
223 struct proj_info
224 {
227 }; // |struct proj_info|
228
229
230 // a wrapper around |RankFlags| to allow a hash table indexed by them
231 struct bitset_entry : public RankFlags
232 {
233  typedef RankFlags base;
234  typedef std::vector<bitset_entry> Pooltype;
235  bitset_entry(base b) : base(b) {}
237 }; // |struct bitset_entry|
238
239
240 /* This class stores the information necessary to interpret a |StandardRepK|,
241  but it does not store extensive tables concerning them, which is relegated
242  to the derived class |KHatContext| defined below.
243
244  Just one dynamic table is held, for projection matrices correponding to
245  different subsets of simple roots; they serve to speed up the height
246  computation. That computation is not a necessary part for the other
247  functionality of this class, but it allows height-truncation to be built
248  into for instance |K_type_formula|, which speeds up simple cases a lot.
249  */
251 {
252  RealReductiveGroup& G;
253  BitMap Cartan_set; // marks recorded Cartan class numbers
254  std::vector<Cartan_info> C_info; // indexed by number of Cartan for |GR|
255
256 // this member is precomputed to increase efficiency of certain operations
257  std::vector<BinaryMap> simple_reflection_mod_2; // dual side
258
259 // we cache a number of |proj_info| values, indexed by sets of generators
261  HashTable<bitset_entry,unsigned int> proj_sets;
262  std::vector<proj_info> proj_data;
263
264  public:
265  SRK_context(RealReductiveGroup &G);
266
267  // accessors
268  InnerClass& innerClass() const
269  { return G.innerClass(); }
270  const RootDatum& rootDatum() const { return G.rootDatum(); }
271  const WeylGroup& weylGroup() const { return G.weylGroup(); }
272  const TwistedWeylGroup& twistedWeylGroup() const
273  { return G.twistedWeylGroup(); }
274  const TitsGroup& titsGroup() const { return G.titsGroup(); }
275  const TitsCoset& basedTitsGroup() const
276  { return G.basedTitsGroup(); }
277
279  { return innerClass().involution_of_Cartan(cn); }
280  const Fiber& fiber(const StandardRepK& sr) const
281  { return G.cartan(sr.Cartan()).fiber(); }
282
283  const KGB& kgb() const { return G.kgb(); }
284
285  const Cartan_info& info(size_t cn) const
286  { return C_info[Cartan_set.position(cn)]; }
288  { return simple_reflection_mod_2[i]; }
289
290  // projection (keeping free & torsion parts): doubled |Weight| to |HCParam|
291  HCParam project(size_t cn, Weight lambda) const; // by value
292
293  // a section of |project|
294  Weight lift(size_t cn, HCParam p) const;
295
296  // $(1+\theta)$ times |lift(cn,p)|; this is independent of choice of lift
297  Weight theta_lift(size_t cn, HCParam p) const
298  {
299  Weight result=lift(cn,p);
300  result += G.cartan(cn).involution()*result;
301  return result;
302  }
303
304  Weight lift(const StandardRepK& s) const
305  { return lift(s.d_cartan,s.d_lambda); }
306
308  { return theta_lift(s.d_cartan,s.d_lambda); }
309
310  StandardRepK std_rep (const Weight& two_lambda, TitsElt a) const;
311
312  StandardRepK std_rep_rho_plus (Weight lambda, TitsElt a) const
313  {
314  (lambda *= 2) += rootDatum().twoRho();
315  return std_rep(lambda,a);
316  }
317
318  // RepK from KGB number only, with |lambda=rho|; method is currently unused
319  StandardRepK KGB_elt_rep(KGBElt z) const;
320
321  RawRep Levi_rep (Weight lambda, TitsElt a, RankFlags gens) const;
322
323 /*
324  The conditions below are defined by
325  Standard: $<\lambda,\alpha\vee>\geq0$ when $\alpha$ positive imaginary
326  Normal: $<\lambda,\alpha\vee+\theta\alpha\vee>\geq0$ when $\alpha$ simple,
327  complex, and orthogonal to sums of positive imaginary resp. real roots.
328  Zero: $<\lambda,\alpha\vee>=0$ for some simple-imaginary compact $\alpha$
329  Final: $<\lambda,\alpha\vee>$ odd for all simple-real roots $\alpha$
330
331  The condition Zero is a sufficient, but possibly not necessary, condition
332  for the parameter to determine a zero representation.
333
334  The |witness| parameter is set to an index of a root that witnesses
335  the failure to be Standard, non-Zero, or Final in case of such verdicts.
336  This index is into |f.simpleImaginary| for |isStandard| and |isZero|, and
337  it is into |f.simpleReal| for |isFinal|, where |f| is the |Fiber| at the
338  canonical twisted involution for the Cartan class of |sr|.
339 */
340  bool isStandard(const StandardRepK& sr, size_t& witness) const;
341  bool isNormal(Weight lambda, size_t cn, size_t& witness) const;
342  bool isNormal(const StandardRepK& sr, size_t& witness) const
343  { return isNormal(lift(sr),sr.Cartan(),witness); }
344  bool isZero(const StandardRepK& sr, size_t& witness) const;
345  bool isFinal(const StandardRepK& sr, size_t& witness) const;
346
347  void normalize(StandardRepK& sr) const;
348
349  q_Char q_normalize_eq (const StandardRepK& sr,size_t witness) const;
350  q_Char q_reflect_eq (const StandardRepK& sr,size_t i,
351  Weight lambda,
352  const Weight& cowt) const;
353
354  TitsElt titsElt(const StandardRepK& s) const
355  {
356  return TitsElt(titsGroup(), involution_of_Cartan(s.d_cartan), s.d_fiberElt);
357  }
358
359  KGBEltList sub_KGB(const PSalgebra& q) const;
360
361  PSalgebra theta_stable_parabolic
362  (const StandardRepK& sr, WeylWord& conjugator) const;
363
364  CharForm K_type_formula
365  (const StandardRepK& sr, level bound=~0u); // non-|const| (|height_bound|)
366  q_CharForm q_K_type_formula
367  (const StandardRepK& sr, level bound=~0u); // non-|const| (|height_bound|)
368
369  // Hecht-Schmid identity for simple-imaginary root $\alpha$
370  HechtSchmid HS_id(const StandardRepK& s, RootNbr alpha) const;
371
372  // Hecht-Schmid identity for simple-real root $\alpha$
373  HechtSchmid back_HS_id(const StandardRepK& s, RootNbr alpha) const;
374
375  // equivalent by $q$-Hecht-Schmid identity for simple-imaginary root $\alpha$
376  q_Char q_HS_id_eq(const StandardRepK& s, RootNbr alpha) const;
377
378  // no need for |q_back_HS_id_eq|, it would not involve $q$; use |back_HS_id|
379
384  level height(const StandardRepK& s) const;
385
387  level height_bound(const Weight& lambda); // non |const|
388
389  std::ostream& print(std::ostream& strm, const StandardRepK& sr) const;
390  std::ostream& print(std::ostream& strm, const Char& ch) const;
391  std::ostream& print(std::ostream& strm, const q_Char& ch) const;
392
393 // private methods
394  private:
395  RawChar KGB_sum(const PSalgebra& q, const Weight& lambda)
396  const;
397
398  Raw_q_Char q_KGB_sum(const PSalgebra& q, const Weight& lambda)
399  const;
400
401  const proj_info& get_projection(RankFlags gens); // non |const|
402
403 }; // |SRK_context|
404
405 // a comparison object that first takes into account a grading (height)
407 {
408  const std::vector<level>* h; // pointer, so |graded_compare| can be assignable
409
410 public:
411  graded_compare (const std::vector<level>& a) : h(&a) {}
412
413  bool operator()(seq_no x, seq_no y) const
414  {
415  level hx=(*h)[x], hy=(*h)[y];
416  return hx!=hy ? hx<hy : x<y; // compare levels; sequence nbrs break ties
417  }
419
420 // This class serves to store tables of previously computed mappings from
421 // "bad" standard representations to good ones. Also the information
422 // necessary to interpret the d_lambda field in StandardRepK are stored here
423 class KhatContext : public SRK_context
424 {
425  typedef HashTable<StandardRepK,seq_no> Hash;
426
428  Hash nonfinals,finals;
429
430  std::vector<level> height_of; // alongside |final_pool|
432
433  // a set of equations rewriting to Standard, Normal, Final, NonZero elements
434  std::vector<combination> expanded; // equivalents for |nonfinal| elements
435
436  public:
437
438 // constructors, destructors, and swap
439
440  KhatContext(RealReductiveGroup &G);
441
442 // accessors and manipulators (manipulation only as side effect for efficiency)
443
444  seq_no nr_reps() const { return final_pool.size(); }
445
446  StandardRepK rep_no(seq_no i) const { return final_pool[i]; }
447
448
449  using SRK_context::height;
450  level height(seq_no i) const
451  {
452  assert(i<height_of.size());
453  return height_of[i]; // which will equal |height(rep_no(i))|
454  }
455
457
458  combination standardize(const StandardRepK& sr); // non |const|: |expanded++|
459  combination standardize(const Char& chi); // non |const|
460
461  combination truncate(const combination& c, level bound) const;
462
463
464  equation mu_equation(seq_no, level bound=~0u); // adds equations
465
466  std::vector<equation> saturate
467  (const std::set<equation>& system, level bound);
468
469  // saturate and invert |system| up to |bound|, writing list into |reps|
471  K_type_matrix(std::set<equation>& system,
472  level bound,
473  std::vector<seq_no>& reps,
474  matrix::Matrix_base<CharCoeff>* direct_p); // non |const|
475
476  combination branch(seq_no s, level bound); // non |const|
477
478  void go(const StandardRepK& sr); // used by "test" command
479
480  using SRK_context::print;
481  std::ostream& print(std::ostream& strm, const combination& ch,
482  bool brief=false) const;
483 // manipulators
484  private:
485  const combination& equate(seq_no n, const combination& rhs); // nonfinal #n
486
487 }; // |class KhatContext|
488
489 // This class serves to store tables of previously computed mappings from
490 // "bad" standard representations to good ones. Also the information
491 // necessary to interpret the d_lambda field in StandardRepK are stored here
492 class qKhatContext : public SRK_context
493 {
494  typedef HashTable<StandardRepK,seq_no> Hash;
495
497  Hash nonfinals,finals;
498
499  std::vector<level> height_of; // alongside |final_pool|
501
502  // a set of equations rewriting to Standard, Normal, Final, NonZero elements
503  std::vector<q_combin> expanded; // equivalents for |nonfinal| elements
504
505  public:
506
507 // constructors, destructors, and swap
508
509  qKhatContext(RealReductiveGroup &G);
510
511 // accessors and manipulators (manipulation only as side effect for efficiency)
512
513  seq_no nr_reps() const { return final_pool.size(); }
514
515  StandardRepK rep_no(seq_no i) const { return final_pool[i]; }
516
517
518  using SRK_context::height;
519  level height(seq_no i) const
520  {
521  assert(i<height_of.size());
522  return height_of[i]; // which will equal |height(rep_no(i))|
523  }
524
526
527  q_combin standardize(const StandardRepK& sr); // non |const|: |expanded++|
528  q_combin standardize(const q_Char& chi); // non |const|
529
530  q_combin truncate(const q_combin& c, level bound) const;
531
532  q_equation mu_equation(seq_no, level bound=~0u); // adds equations
533
534  std::vector<q_equation> saturate
535  (const std::set<q_equation>& system, level bound);
536
538  K_type_matrix(std::set<q_equation>& system,
539  level bound,
540  std::vector<seq_no>& reps,
541  matrix::Matrix_base<q_CharCoeff>* direct_p); // non |const|
542
543  q_combin branch(seq_no s, level bound); // non |const|
544
545  using SRK_context::print;
546  std::ostream& print(std::ostream& strm, const q_combin& ch, bool brief=false)
547  const;
548
549 // manipulators
550  private:
551  const q_combin& equate(seq_no n, const q_combin& rhs); // nonfinal #n
552
553 }; // |class qKhatContext|
554
555
556 /* HechtSchmid identities are represented as equation with a main left hand
557  member |lh|, and optional second left member |lh2|, and two optional
558  right hand members |rh1| and |rh2|. Standardreps are all normalized.
559 */
561 {
563  StandardRepK* lh2; // owned pointers
566
567  public:
569  : lh(s), lh2(NULL), rh1(NULL), rh2(NULL) {}
570  ~HechtSchmid() { delete lh2; delete rh1; delete rh2; }
571
572  void add_lh(const StandardRepK& s) { lh2=new StandardRepK(s); }
574  { *(rh1==NULL ? &rh1 : &rh2) = new StandardRepK(s); }
575
576  int n_lhs() const { return lh2==NULL ? 1 : 2; }
577  int n_rhs() const { return rh1==NULL ? 0 : rh2==NULL ? 1 : 2; }
578  Char rhs () const; // stored right hand side: |*rh1 + *rh2|
579  Char equivalent () const; // expression for initial term |lh|: |rhs() - *lh1|
580
581 }; // |class HechtSchmid|
582
583 class PSalgebra // Parabolic subalgebra
584 {
585  TitsElt strong_inv; // corresponding strong involution
586  size_t cn; // number of the Cartan class
587  RankFlags sub_diagram; // simple roots forming basis of Levi factor
588  RootNbrSet nilpotents; // (positive) roots in nilpotent radical
589  public:
590  PSalgebra (TitsElt base,
591  const InnerClass& G);
592
593  const TitsElt& strong_involution() const { return strong_inv; }
594  TwistedInvolution involution() const { return strong_inv.tw(); }
595  size_t Cartan_no() const { return cn; }
596  RankFlags Levi_gens() const { return sub_diagram; }
597  const RootNbrSet& radical() const { return nilpotents; }
598 }; // |class PSalgebra|
599
600
601 } // |namespace standardrepk|
602
603 } // |namespace atlas|
604
605 #endif
Definition: standardrepk.h:492
StandardRepr * sr
Definition: reprmode.cpp:82
size_t Cartan_no() const
Definition: standardrepk.h:595
WeylElt TwistedInvolution
Definition: Atlas.h:231
Definition: standardrepk.h:431
std::pair< seq_no, combination > equation
Definition: standardrepk.h:47
level height(const StandardRepK &s) const
Definition: standardrepk.cpp:280
StandardRepK::Pooltype nonfinal_pool
Definition: standardrepk.h:427
combination q_is_1(const q_combin &c)
Definition: standardrepk.h:583
HashTable< bitset_entry, unsigned int > proj_sets
Definition: standardrepk.h:261
const std::vector< level > * h
Definition: standardrepk.h:408
Definition: standardrepk.h:411
level height(seq_no i) const
Definition: standardrepk.h:519
RankFlags sub_diagram
Definition: standardrepk.h:587
const TitsGroup & titsGroup() const
Definition: standardrepk.h:274
Definition: Atlas.h:79
const BinaryMap & dual_reflection(weyl::Generator i) const
Definition: standardrepk.h:287
int n_lhs() const
Definition: standardrepk.h:576
RankFlags bi_ortho
Definition: standardrepk.h:212
uA p
Definition: lists.cpp:26
Represents the restriction to $K$ of a (coherently) continued standard Harish-Chandra module...
Definition: standardrepk.h:140
HashTable< StandardRepK, seq_no > Hash
Definition: standardrepk.h:494
Definition: standardrepk.h:597
BitSet< constants::RANK_MAX > RankFlags
Definition: Atlas.h:60
std::pair< seq_no, q_combin > q_equation
Definition: standardrepk.h:50
bool operator<(const StandardRepK &) const
Definition: standardrepk.cpp:80
int_Matrix projection
Definition: standardrepk.h:225
Definition: standardrepk.h:223
Weight theta_lift(size_t cn, HCParam p) const
Definition: standardrepk.h:297
size_t hashCode(size_t modulus) const
Definition: standardrepk.h:236
StandardRepK std_rep_rho_plus(Weight lambda, TitsElt a) const
Definition: standardrepk.h:312
std::pair< StandardRepK, Char > CharForm
Definition: Atlas.h:397
std::pair< StandardRepK, q_Char > q_CharForm
Definition: Atlas.h:401
TitsElt titsElt(const StandardRepK &s) const
Definition: standardrepk.h:354
Definition: standardrepk.h:572
HechtSchmid(const StandardRepK &s)
Definition: standardrepk.h:568
bool isNormal(const StandardRepK &sr, size_t &witness) const
Definition: standardrepk.h:342
Free_Abelian< StandardRepK > Char
Definition: Atlas.h:396
size_t d_cartan
Number of the Cartan to which the HC module is associated.
Definition: standardrepk.h:148
void swap(const StandardRepK &)
friend class SRK_context
Definition: standardrepk.h:143
std::vector< BinaryMap > simple_reflection_mod_2
Definition: standardrepk.h:257
const Weight & coroot_sum(size_t i) const
Definition: standardrepk.h:217
Definition: standardrepk.h:231
StandardRepK rep_no(seq_no i) const
Definition: standardrepk.h:446
~HechtSchmid()
Definition: standardrepk.h:570
Free_Abelian< RawRep, Polynomial< int > > Raw_q_Char
Definition: Atlas.h:402
HCParam d_lambda
Character of the rho cover of H^theta, on basis of $(1/2)X^*$.
Definition: standardrepk.h:159
Definition: standardrepk.h:250
bool operator==(const StandardRepK &) const
Definition: standardrepk.cpp:87
InnerClass & innerClass() const
Definition: standardrepk.h:268
unsigned int level
Definition: Atlas.h:404
bitset_entry::Pooltype proj_pool
Definition: standardrepk.h:260
RankFlags Levi_gens() const
Definition: standardrepk.h:596
Weight theta_lift(const StandardRepK &s) const
Definition: standardrepk.h:307
std::vector< combination > expanded
Definition: standardrepk.h:434
StandardRepK * rh1
Definition: standardrepk.h:564
level height(seq_no i) const
Definition: standardrepk.h:450
const KGB & kgb() const
Definition: standardrepk.h:283
Definition: standardrepk.h:456
Free_Abelian< RawRep > RawChar
Definition: Atlas.h:399
TitsElt strong_inv
Definition: standardrepk.h:585
Hash nonfinals
Definition: standardrepk.h:428
BitMap Cartan_set
Definition: standardrepk.h:253
Definition: standardrepk.h:406
q_Char::coef_t q_CharCoeff
Definition: standardrepk.h:42
std::vector< proj_info > proj_data
Definition: standardrepk.h:262
std::vector< Weight > WeightList
Definition: Atlas.h:162
std::ostream & print(std::ostream &strm, const StandardRepK &sr) const
Definition: standardrepk.cpp:1087
std::vector< Cartan_info > C_info
Definition: standardrepk.h:254
int_Vector lift(const BitVector< dim > &v)
Definition: bitvector.cpp:819
LatticeCoeff denom
Definition: standardrepk.h:226
Definition: standardrepk.h:423
SmallSubspace fiber_modulus
Definition: standardrepk.h:208
std::vector< bitset_entry > Pooltype
Definition: standardrepk.h:234
HashTable< StandardRepK, seq_no > Hash
Definition: standardrepk.h:425
bitset_entry(base b)
Definition: standardrepk.h:235
RankFlags base
Definition: standardrepk.h:233
RootNbrSet nilpotents
Definition: standardrepk.h:588
std::vector< StandardRepK > Pooltype
Definition: standardrepk.h:185
size_t hashCode(size_t modulus) const
Definition: standardrepk.cpp:95
q_combin to_q(const combination &c)
Definition: standardrepk.cpp:1709
const WeylGroup & weylGroup() const
Definition: standardrepk.h:271
StandardRepK()
Definition: standardrepk.h:170
unsigned int KGBElt
Definition: Atlas.h:339
StandardRepK::Pooltype nonfinal_pool
Definition: standardrepk.h:496
const TitsElt & strong_involution() const
Definition: standardrepk.h:593
size_t cn
Definition: standardrepk.h:586
std::pair< Weight, TitsElt > RawRep
Definition: Atlas.h:398
const TwistedWeylGroup & twistedWeylGroup() const
Definition: standardrepk.h:272
Free_Abelian< StandardRepK, Polynomial< int > > q_Char
Definition: Atlas.h:400
size_t Cartan() const
Definition: standardrepk.h:179
const Fiber & fiber(const StandardRepK &sr) const
Definition: standardrepk.h:280
std::vector< level > height_of
Definition: standardrepk.h:499
int_Matrix freeProjector
Definition: standardrepk.h:197
unsigned int seq_no
Definition: Atlas.h:403
TwistedInvolution involution() const
Definition: standardrepk.h:594
std::vector< level > height_of
Definition: standardrepk.h:430
StandardRepK * rh2
Definition: standardrepk.h:565
seq_no nr_reps() const
Definition: standardrepk.h:513
bool operator!=(const StandardRepK &another) const
Definition: standardrepk.h:186
int LatticeCoeff
Definition: Atlas.h:167
Free_Abelian< seq_no, long int, graded_compare > combination
Definition: standardrepk.h:46
StandardRepK(size_t cn, const TorusPart &x, const HCParam &lambda)
Definition: standardrepk.h:165
Definition: standardrepk.h:560
const Cartan_info & info(size_t cn) const
Definition: standardrepk.h:285
Permutation normalize(const DynkinDiagram &d)
Definition: dynkin.cpp:386
const TwistedInvolution involution_of_Cartan(size_t cn) const
Definition: standardrepk.h:278
WeightList torsionLift
Definition: standardrepk.h:205
unsigned long n
Definition: axis.cpp:77
struct lambda_node * lambda
Definition: parse_types.h:94
Definition: standardrepk.h:500
seq_no nr_reps() const
Definition: standardrepk.h:444
StandardRepK * lh2
Definition: standardrepk.h:563
StandardRepK lh
Definition: standardrepk.h:562
per Cartan class information for handling |StandardRepK| values
Definition: standardrepk.h:194
const RootDatum & rootDatum() const
Definition: standardrepk.h:270
Definition: Atlas.h:38
void print(char *s,...)
Definition: common.c:861
std::pair< Weight, RankFlags > HCParam
Definition: Atlas.h:394
Free_Abelian< seq_no, q_CharCoeff, graded_compare > q_combin
Definition: standardrepk.h:49
TorusPart d_fiberElt
Element of the fiber group; left torus part of the strong involution.
Definition: standardrepk.h:154
matrix::Matrix_base< C > inverse_lower_triangular(const matrix::Matrix_base< C > &L)
Definition: standardrepk.cpp:1786
const TitsCoset & basedTitsGroup() const
Definition: standardrepk.h:275
Container of a large (more than twice the machine word size) set of bits.
Definition: bitmap.h:52
Cartan_info()
Definition: standardrepk.h:215
Hash nonfinals
Definition: standardrepk.h:497
BitMatrix< constants::RANK_MAX > BinaryMap
Definition: Atlas.h:185
unsigned short RootNbr
Definition: Atlas.h:216
SmallBitVector TorusPart
Definition: Atlas.h:256
StandardRepK rep_no(seq_no i) const
Definition: standardrepk.h:515
unsigned char Generator
Definition: Atlas.h:226
Char::coef_t CharCoeff
Definition: standardrepk.h:41
WeightList sum_coroots
Definition: standardrepk.h:213
matrix::Matrix_base< C > triangularize(const std::vector< std::pair< seq_no, Free_Abelian< seq_no, C, graded_compare > > > &eq, std::vector< seq_no > &new_order)
Definition: standardrepk.cpp:1728
Weight lift(const StandardRepK &s) const
Definition: standardrepk.h:304
bool operator()(seq_no x, seq_no y) const
Definition: standardrepk.h:413
std::vector< q_combin > expanded
Definition: standardrepk.h:503