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 
13  For license information see the LICENSE file
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 
46 typedef Free_Abelian<seq_no,long int,graded_compare> combination;
47 typedef std::pair<seq_no,combination> equation;
48 
49 typedef Free_Abelian<seq_no,q_CharCoeff,graded_compare> q_combin;
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,
59  Free_Abelian<seq_no,C,graded_compare>
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) {}
236  size_t hashCode(size_t modulus) const { return to_ulong()&(modulus-1); }
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  }
418 }; // |class graded_compare|
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|
431  graded_compare height_graded; // ordering object that will use |height_of|
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 
456  const graded_compare& height_order() const { return height_graded; }
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|
500  graded_compare height_graded; // ordering object that will use |height_of|
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 
525  const graded_compare& height_order() const { return height_graded; }
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); }
573  void add_rh(const 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
graded_compare height_graded
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
graded_compare(const std::vector< level > &a)
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
const RootNbrSet & radical() const
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
void add_lh(const StandardRepK &s)
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
const graded_compare & height_order() const
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
graded_compare height_graded
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
void add_rh(const StandardRepK &s)
Definition: standardrepk.h:573
int_Matrix freeLift
Definition: standardrepk.h:202
BinaryMap torsionProjector
Definition: standardrepk.h:199
RealReductiveGroup & G
Definition: standardrepk.h:252
std::vector< KGBElt > KGBEltList
Definition: Atlas.h:340
const graded_compare & height_order() const
Definition: standardrepk.h:525
int n_rhs() const
Definition: standardrepk.h:577