atlas  0.6
repr.h
Go to the documentation of this file.
1
2 /*
3  This is repr.h
4
5  Copyright (C) 2009-2012 Marc van Leeuwen
6  part of the Atlas of Lie Groups and Representations
7
8  For license information see the LICENSE file
9 */
10
11 #ifndef REPR_H /* guard against multiple inclusions */
12 #define REPR_H
13
14 #include <iostream>
15
16 #include "../Atlas.h"
17
18 #include "matrix.h" // containment
19 #include "ratvec.h" // containment
20
21 #include "realredgp.h" // inlines
22
23 #include "hashtable.h"
24 #include "free_abelian.h"
25 #include "arithmetic.h" // |SplitInteger|
26
27 namespace atlas {
28
29 namespace repr {
30
31 /*
32 We represent the parameter of a standard representation as a triplet
33 $(x,\tilde\lambda,gamma)$, where |x| is an element of the set $K\\backslash 34 G/B$ for our fixed real form (determining amongs others an involution $\thata$
35 of $X^*$), $\tilde\lambda$ is a genuine character of the $\rho$-cover of
36 $H^{\theta_x}$, and $\gamma$ is a character of the complex Lie algebra $h$.
37 The latter two values are related; $(1+\theta)\gamma=(1+\theta)\lambda$, in
38 other words $\gamma-\tilde\lambda$ is fixed by $-\theta$; the projection of
39 $\gamma$ on the $+1$-eigenspace of $\theta$ is determined by this relation and
40 is called the discrete part $\lamda_0$ of $\gamma$. The difference
41 $\gamma-\lambda_0$, i.e., the projection of $\gamma$ on the $-1$-eigenspace,
42 is called $\nu$. This component is what we are adding with respect to the
43 values encoded in the |standardrepk::StandarRepK| type. The part of
44 $\tilde\lambda$ that is independent of $lambda_0$ is its "torsion part"
45 (disconnected $H(R)_c$), which would be represented in the |Block| structure
46 by the |TorusPart| component of the |TitsElt| of the dual KGB-element ($y$).
47 In fact we convert it intenally to a |TorusPart| here too. It repesents an
48 element of the quotient of $X^* /2X^*$ by the image of $(X^*)^\theta$, which
49 can be converted to the difference $\tilde\lambda-\lambda_0$ by the method
50 |involutions::InvolutionTable::unpack|.
51
52 In principle $\gamma$ could take any complex values compatible with
53 $\tildelambda$, but we shall only be interested in real values, and in fact
54 record a rational value, because that is all we can do in an exact manner, and
55 all interesting phenomena take place at rational infinitesimal character.
56 */
57
59 {
60  friend class Rep_context;
61
65
66  // one should call constructor from |Rep_context| only
68  : x_part(x), y_bits(y), infinitesimal_char(gamma)
69  { infinitesimal_char.normalize(); } // ensure this class invariant
70
71  public:
72
73  const RatWeight& gamma() const { return infinitesimal_char; }
74  KGBElt x() const { return x_part; }
75  const TorusPart& y() const { return y_bits; }
76
77  bool operator== (const StandardRepr&) const;
78
79 // special members required by HashTable
80
81  typedef std::vector<StandardRepr> Pooltype;
82  bool operator!=(const StandardRepr& another) const
83  { return not operator==(another); }
84  size_t hashCode(size_t modulus) const;
85 }; // |class StandardRepr|
86
87
88 // This class stores the information necessary to interpret a |StandardRepr|
90 {
91  RealReductiveGroup& G;
92  const KGB& KGB_set;
93
94  public:
95  explicit Rep_context(RealReductiveGroup &G);
96
97  // accessors
98  RealReductiveGroup& realGroup() const { return G; }
99  const InnerClass& innerClass() const { return G.innerClass(); }
100  const RootDatum& rootDatum() const { return G.rootDatum(); }
101  const WeylGroup& weylGroup() const { return G.weylGroup(); }
102  const TwistedWeylGroup& twistedWeylGroup() const
103  { return G.twistedWeylGroup(); }
104  const TitsGroup& titsGroup() const { return G.titsGroup(); }
105  const TitsCoset& basedTitsGroup() const { return G.basedTitsGroup(); }
106  const KGB& kgb() const { return KGB_set; }
107  size_t rank() const;
108
109  const TwistedInvolution involution_of_Cartan(size_t cn) const;
110
111  RatWeight gamma // compute (representative of) infinitesimal character
112  (KGBElt x, const Weight& lambda_rho, const RatWeight& nu) const;
113  StandardRepr sr_gamma // use this one when infinitesimal character is known
114  (KGBElt x, const Weight& lambda_rho, const RatWeight& gamma) const;
115  StandardRepr sr // construct parameter from |(x,\lambda,\nu)| triplet
116  (KGBElt x, const Weight& lambda_rho, const RatWeight& nu) const
117  { return sr_gamma(x,lambda_rho,gamma(x,lambda_rho,nu)); }
118
120  sr(const standardrepk::StandardRepK& srk,
121  const standardrepk::SRK_context& srkc,
122  const RatWeight& nu) const;
123  StandardRepr sr(const param_block& b, BlockElt i) const;
124
125  // component extraction
126  Weight lambda_rho(const StandardRepr& z) const;
127
128  RatWeight lambda(const StandardRepr& z) const; // half-integer
129  RatWeight nu(const StandardRepr& z) const; // rational, $-\theta$-fixed
130
131  // attributes
132  bool is_standard // whether $I(z)$ is non-virtual: gamma imaginary-dominant
133  (const StandardRepr& z, RootNbr& witness) const; // simple-imaginary witness
134  bool is_zero // whether $I(z)=0$: exists singular simple-imaginary compact
135  (const StandardRepr& z, RootNbr& witness) const; // simple-imaginary witness
136  bool is_final // whether $I(z)$ unrelated by Hecht-Schmid to more compact
137  (const StandardRepr& z, RootNbr& witness) const; // singular real witness
138  bool is_oriented(const StandardRepr& z, RootNbr alpha) const;
139  unsigned int orientation_number(const StandardRepr& z) const;
140
141  // action by equivalence of parameters (not the cross action), changing gamma
142  void W_act(const WeylWord& w,StandardRepr& z) const;
143
144  // same, but interpreting the Weyl word in a subsystem
145  void W_act(const WeylWord& w,StandardRepr& z,const SubSystem& subsys) const;
146
147  // prepare for |deform|: make |gamma| dominant, and as theta-stable as can be
148  // return the sequence of Weyl generators that was applied (to the right)
149  WeylWord make_dominant(StandardRepr& z) const;
150
151  // make integrally dominant, with precomputed integral subsystem
152  WeylWord make_dominant(StandardRepr& z,const SubSystem& subsys) const;
153
154  RationalList reducibility_points(const StandardRepr& z) const; // normalised
155
156  // the following take |z| by value, modifying and in some cases returning it
158  StandardRepr Cayley(weyl::Generator s, StandardRepr z) const;
159  StandardRepr inv_Cayley(weyl::Generator s, StandardRepr z) const;
160  StandardRepr twist(StandardRepr z) const;
161
162  StandardRepr cross(const Weight& alpha, StandardRepr z) const;
163  StandardRepr any_Cayley(const Weight& alpha, StandardRepr z) const;
164
165  class compare
166  { Coweight level_vec; // linear form to apply to |gamma| for ordering
167  public:
168  compare (const Coweight& lv) : level_vec(lv) {}
169
170  bool operator()(const StandardRepr& r,const StandardRepr& s) const;
171  }; // |compare|
172
173  compare repr_less() const;
174
175  typedef Free_Abelian<StandardRepr,Split_integer,compare> poly;
176
177  poly expand_final(StandardRepr z) const; // express in final SReprs (by value)
178
179  std::ostream& print (std::ostream&,const StandardRepr& z) const;
180  std::ostream& print (std::ostream&,const poly& P) const;
181
182 }; // |Rep_context|
183
185
186 class Rep_table : public Rep_context
187 {
188  std::vector<StandardRepr> pool;
189  HashTable<StandardRepr,unsigned long> hash;
190  std::vector<unsigned short int> lengths;
191  std::vector<SR_poly> KL_list; // indexed by |hash| values for |StandardRepr|s
192  std::vector<SR_poly> def_formula; // idem
193
194  public:
195  Rep_table(RealReductiveGroup &G)
196  : Rep_context(G), pool(), hash(pool), KL_list(), def_formula()
197  {}
198
199  unsigned int length(StandardRepr z); // by value
200
201  SR_poly KL_column_at_s(StandardRepr z); // by value
202
203  SR_poly deformation_terms (param_block& block,BlockElt entry_elem);
204  // here |block| is non-|const| because it calls |add_block|
205
206  SR_poly deformation(const StandardRepr& z);
207
208  private:
209  void add_block(param_block& block, BlockEltList& survivors);
210  // here |block| is non-|const| as the method generates KL polynomials in it
211  // and |survivors| is non-|const| because the method computes and exports it
212
213 }; // |Rep_table|
214
215
216 // Functions
217
218
219 } // |namespace repr|
220
221 } // |namespace atlas|
222
223 #endif
StandardRepr * sr
Definition: reprmode.cpp:82
WeylElt TwistedInvolution
Definition: Atlas.h:231
compare(const Coweight &lv)
Definition: repr.h:168
Free_Abelian< StandardRepr, Split_integer, compare > poly
Definition: repr.h:175
const TwistedWeylGroup & twistedWeylGroup() const
Definition: repr.h:102
const KGB & KGB_set
Definition: repr.h:92
Represents the restriction to $K$ of a (coherently) continued standard Harish-Chandra module...
Definition: standardrepk.h:140
StandardRepr(KGBElt x, TorusPart y, const RatWeight &gamma)
Definition: repr.h:67
RealReductiveGroup & realGroup() const
Definition: repr.h:98
KGBElt x() const
Definition: repr.h:74
KGBElt x_part
Definition: repr.h:62
const RatWeight & gamma() const
Definition: repr.h:73
std::vector< Rational > RationalList
Definition: Atlas.h:74
bool operator==(const StandardRepr &) const
Definition: repr.cpp:31
Rep_table(RealReductiveGroup &G)
Definition: repr.h:195
friend class Rep_context
Definition: repr.h:60
int length
Definition: common.c:103
Definition: repr.h:165
Definition: standardrepk.h:250
TorusPart y_bits
Definition: repr.h:63
std::vector< unsigned short int > lengths
Definition: repr.h:190
KGBElt cross(const KGB_base &kgb, KGBElt x, RootNbr alpha)
Definition: kgb.cpp:824
Definition: repr.h:186
const KGB & kgb() const
Definition: repr.h:106
RatWeight infinitesimal_char
Definition: repr.h:64
const RootDatum & rootDatum() const
Definition: repr.h:100
RealReductiveGroup & G
Definition: repr.h:91
std::vector< StandardRepr > Pooltype
Definition: repr.h:81
unsigned int KGBElt
Definition: Atlas.h:339
const TitsCoset & basedTitsGroup() const
Definition: repr.h:105
RationalVector & normalize()
Definition: ratvec.cpp:135
bool operator!=(const StandardRepr &another) const
Definition: repr.h:82
Rep_context::poly SR_poly
Definition: repr.h:184
HashTable< StandardRepr, unsigned long > hash
Definition: repr.h:189
KGBElt any_Cayley(const KGB_base &kgb, KGBElt x, RootNbr alpha)
Definition: kgb.cpp:832
size_t hashCode(size_t modulus) const
Definition: repr.cpp:36
std::vector< SR_poly > def_formula
Definition: repr.h:192
Definition: repr.h:89
Definition: repr.h:58
const WeylGroup & weylGroup() const
Definition: repr.h:101
Coweight level_vec
Definition: repr.h:166
struct lambda_node * lambda
Definition: parse_types.h:94
Definition: Atlas.h:38
void print(char *s,...)
Definition: common.c:861
const TorusPart & y() const
Definition: repr.h:75
std::vector< StandardRepr > pool
Definition: repr.h:188
unsigned short RootNbr
Definition: Atlas.h:216
SmallBitVector TorusPart
Definition: Atlas.h:256
const InnerClass & innerClass() const
Definition: repr.h:99
unsigned char Generator
Definition: Atlas.h:226
unsigned int BlockElt
Definition: Atlas.h:367
std::vector< SR_poly > KL_list
Definition: repr.h:191
std::vector< BlockElt > BlockEltList
Definition: Atlas.h:368
const TitsGroup & titsGroup() const
Definition: repr.h:104