atlas  0.6
kl.h
Go to the documentation of this file.
1 /*
2  This is kl.h
3
4  Class definitions and function declarations for the class KLContext.
5
6
7  Copyright (C) 2004,2005 Fokko du Cloux
8  Copyright 2012 David Vogan, Marc van Leeuwen
9  part of the Atlas of Lie Groups and Representations
10
12 */
13
14 #ifndef KL_H /* guard against multiple inclusions */
15 #define KL_H
16
17 #include <limits>
18 #include <set>
19
20 #include "../Atlas.h"
21
22 #include "klsupport.h" // containment
23 #include "polynomials.h"// containment
24
25 namespace atlas {
26
27 /******** function declarations *********************************************/
28
29 namespace kl {
30
31  void wGraph(wgraph::WGraph&, const KLContext&);
32
33 }
34
35 /******** type definitions **************************************************/
36
37 /* Namely: the definition of KLContext itself */
38
39 namespace kl {
40
41 typedef std::vector<std::pair<BlockElt,MuCoeff> > MuRow;
42
43 class KLPolEntry; // class definition will given in the implementation file
44
45 /*
46  |KLContext| is a class that Calculates and stores the
47  Kazhdan-Lusztig-Vogan polynomials for a block of representations of $G$.
48  */
49 class KLContext
50  : public klsupport::KLSupport // base is needed for full functionality
51 {
52
53  BlockElt fill_limit; // all "rows" |y| with |y<fill_limit| have been computed
54
55 /*
56  |d_kl[y]| is a list of indices into |d_hashtable| of polynomials
57  $P_{x_i,y}$ with $x_i$ equal to primitive element number $i$ for
58  |descentSet(y)|, for all $i$ such that $l(x_i)<l(y)$.
59 */
60  std::vector<KLRow> d_kl; // list of polynomial pointers
61
65  std::vector<MuRow> d_mu; // lists of x's and their mu-coefficients
66
67  KLStore d_store; // the distinct actual polynomials
68
69  // the constructors will ensure that |d_store| contains 0, 1 at beginning
70  enum { d_zero = 0, d_one = 1}; // indices of polynomials 0,1 in |d_store|
71  // using enum rather than |static const int| allows implicit const references
72
73  private: // copy and assignment are not needed, and forbidden
74  KLContext(const KLContext&);
75  KLContext& operator= (const KLContext&);
76
77  public:
78
79 // constructors and destructors
80  KLContext(const Block_base&); // construct initial base object
81
82 // accessors
83  // construct lists of extremal respectively primitive elements for |y|
84  PrimitiveRow extremalRow(BlockElt y) const;
85  PrimitiveRow primitiveRow(BlockElt y) const;
86
87  bool isZero(const KLIndex p) const { return p == d_zero; }
88
89  // A constant reference to the Kazhdan-Lusztig-Vogan polynomial P_{x,y}
90  KLPolRef klPol(BlockElt x, BlockElt y) const;
91
92  // That polynomial in the form of an index into |polStore()==d_store|
93  KLIndex KL_pol_index(BlockElt x, BlockElt y) const;
94
95  const KLRow& klRow(BlockElt y) const { return d_kl[y]; }
96
97  MuCoeff mu(BlockElt x, BlockElt y) const; // $\mu(x,y)$
98
99  // List of nonzero $\mu(x,y)$ for |y|, as pairs $(x,\mu(x,y))$
100  const MuRow& muRow(BlockElt y) const { return d_mu[y]; }
101
102  // List of all non-zero KL polynomials for the block, in generation order
103  const KLStore& polStore() const { return d_store; }
104
105  // get bitmap of primitive elements for row |y| with nonzero KL polynomial
106  BitMap primMap (BlockElt y) const;
107
108 // manipulators
109
110  // partial fill, up to and including the "row" of |y|
111  void fill(BlockElt y, bool verbose=true);
112
113  void fill(bool verbose=true)
114  { fill(size()-1,verbose); } // simulate forbidden first default argument
115
116
117  // private methods used during construction
118  private:
119  typedef HashTable<KLPolEntry,KLIndex> KLHash;
120
121  //accessors
122  weyl::Generator firstDirectRecursion(BlockElt y) const;
123  weyl::Generator first_nice_and_real(BlockElt x,BlockElt y) const;
124  std::pair<weyl::Generator,weyl::Generator>
125  first_endgame_pair(BlockElt x, BlockElt y) const;
126  BlockEltPair inverseCayley(size_t s, BlockElt y) const;
127  std::set<BlockElt> down_set(BlockElt y) const;
128
129  KLPolRef klPol(BlockElt x, BlockElt y,
130  KLRow::const_iterator klv,
131  PrimitiveRow::const_iterator p_begin,
132  PrimitiveRow::const_iterator p_end) const;
133
134  // manipulators
135  void silent_fill(BlockElt last_y);
136  void verbose_fill(BlockElt last_y);
137
138  void fillKLRow(BlockElt y, KLHash& hash);
139  void recursionRow(std::vector<KLPol> & klv,
140  const PrimitiveRow& e, BlockElt y, size_t s);
141  void muCorrection(std::vector<KLPol>& klv,
142  const PrimitiveRow& e,
143  BlockElt y, size_t s);
144  void complete_primitives(const std::vector<KLPol>& klv,
145  const PrimitiveRow& e, BlockElt y,
146  KLHash& hash);
147  void newRecursionRow(KLRow & klv,const PrimitiveRow& pr,
148  BlockElt y, KLHash& hash);
149  KLPol muNewFormula(BlockElt x, BlockElt y, size_t s, const MuRow& muy);
150
151 }; //class KLContext
152
153 } // |namespace kl|
154
155 } // |namespace atlas|
156
157 #endif
std::vector< std::pair< BlockElt, MuCoeff > > MuRow
Definition: kl.h:41
const MuRow & muRow(BlockElt y) const
Definition: kl.h:100
Definition: kl.h:49
unsigned long size
Definition: testprint.cpp:46
Definition: klsupport.h:31
std::pair< BlockElt, BlockElt > BlockEltPair
Definition: Atlas.h:369
uA p
Definition: lists.cpp:26
unsigned int KLIndex
Definition: Atlas.h:383
std::vector< KLRow > d_kl
Definition: kl.h:60
std::vector< KLIndex > KLRow
Definition: Atlas.h:387
KLStore d_store
Definition: kl.h:67
std::vector< BlockElt > PrimitiveRow
Definition: Atlas.h:388
bool verbose
const KLRow & klRow(BlockElt y) const
Definition: kl.h:95
std::vector< KLPol > KLStore
Definition: Atlas.h:385
bool isZero(const KLIndex p) const
Definition: kl.h:87
Class definition and function declarations for KLSupport.
HashTable< KLPolEntry, KLIndex > KLHash
Definition: kl.h:119
std::vector< MuRow > d_mu
Entry d_mu[y] is a MuRow, which has parallel vectors for x and mu(x,y)
Definition: kl.h:65
Definition: Atlas.h:122
id_pointer hash[hash_size]
Definition: common.c:125
Definition: kl.cpp:94
Definition: Atlas.h:38
void fill(bool verbose=true)
Definition: kl.h:113
KLCoeff MuCoeff
Definition: Atlas.h:384
BlockElt fill_limit
Definition: kl.h:53
const KLStore & polStore() const
Definition: kl.h:103
unsigned char Generator
Definition: Atlas.h:226
const expr & e
Definition: axis.cpp:95
unsigned int BlockElt
Definition: Atlas.h:367
void wGraph(wgraph::WGraph &wg, const KLContext &klc)
Puts in wg the W-graph for this block.
Definition: kl.cpp:1135
KLStore::const_reference KLPolRef
Definition: Atlas.h:386
Class definitions and function declarations for the class Polynomial.