-
Notifications
You must be signed in to change notification settings - Fork 5
/
coxgroup.h
400 lines (322 loc) · 15.9 KB
/
coxgroup.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
/*
This is coxgroup.h
Coxeter version 3.0 Copyright (C) 2002 Fokko du Cloux
See file main.cpp for full copyright notice
*/
/*
This file presents the main type in this program, viz. the CoxGroup
class. This is the base class for the hierarchy of coxeter group
classes, ranging from the most general ones considered in this program
(rank <= 255, coefficients of Coxeter matris <= COXENTRY_MAX) to
the most special, the class SmallCoxGroup.
We have adhered to the philosophy that all non-leaf classes in the
hierarchy should be abstract. So this file contains only the root
of the hierarchy, as an abstract class.
The layout of the Coxeter hierarchy as considered in this program
is as follows :
CoxGroup(a)
FiniteCoxGroup(a)
FiniteBigRankCoxGroup(a)
GeneralFBRCoxGroup(c)
FiniteMedRankCoxGroup(a)
GeneralFMRCoxGroup(c)
FiniteSmallRankCoxGroup(a)
GeneralFSRCoxGroup(c)
SmallCoxGroup(a)
GeneralSCoxGroup(c)
TypeACoxGroup(a)
TypeABigRankCoxGroup(c)
TypeAMedRankCoxGroup(c)
TypeASmallRankCoxGroup(c)
TypeASmallCoxGroup(c)
AffineCoxGroup(a)
AffineBigRankCoxGroup(a)
GeneralABRCoxGroup(c)
AffineMedRankCoxGroup(a)
GeneralAMRCoxGroup(c)
AffineSmallRankCoxGroup(a)
GeneralASRCoxGroup(c)
GeneralCoxGroup(a)
BigRankCoxGroup(a)
GeneralBRCoxGroup(c)
MedRankCoxGroup(a)
GeneralMRCoxGroup(c)
SmallRankCoxGroup(a)
GeneralSRCoxGroup(c)
*/
#ifndef COXGROUP_H /* guarantee single inclusion */
#define COXGROUP_H
#include "globals.h"
#include "coxtypes.h"
#include "files.h"
#include "graph.h"
#include "hecke.h"
#include "interface.h"
#include "invkl.h"
#include "kl.h"
#include "klsupport.h"
#include "minroots.h"
#include "transducer.h"
#include "uneqkl.h"
namespace coxeter {
//******** type definitions **************************************************
using namespace coxtypes;
using namespace files;
using namespace graph;
using namespace hecke;
using namespace interface;
using namespace klsupport;
using namespace minroots;
using namespace transducer;
class CoxGroup {
protected:
CoxGraph* d_graph;
MinTable* d_mintable;
KLSupport* d_klsupport;
kl::KLContext* d_kl;
invkl::KLContext* d_invkl;
uneqkl::KLContext* d_uneqkl;
Interface* d_interface;
OutputTraits* d_outputTraits;
struct CoxHelper; /* provides helper functions */
CoxHelper* d_help;
friend struct CoxHelper;
public:
void* operator new(size_t size) {return arena().alloc(size);}
void operator delete(void* ptr)
{return arena().free(ptr,sizeof(CoxGroup));}
//******** Chapter 0 : CoxGroup objects *************************************
CoxGroup(const Type& x, const Rank& l);
virtual ~CoxGroup();
CoxGraph& graph(); /* inlined */
virtual Interface& interface(); /* inlined */
MinTable& mintable(); /* inlined */
KLSupport& klsupport(); /* inlined */
kl::KLContext& kl(); /* inlined */
invkl::KLContext& invkl(); /* inlined */
uneqkl::KLContext& uneqkl(); /* inlined */
virtual OutputTraits& outputTraits(); /* inlined */
const CoxGraph& graph() const; /* inlined */
virtual const Interface& interface() const; /* inlined */
const MinTable& mintable() const; /* inlined */
const KLSupport& klsupport() const; /* inlined */
const kl::KLContext& kl() const; /* inlined */
const uneqkl::KLContext& uneqkl() const; /* inlined */
const SchubertContext& schubert() const; /* inlined */
virtual const OutputTraits& outputTraits() const; /* inlined */
void activateKL();
void activateIKL();
void activateUEKL();
/* graph data */
CoxEntry M(Generator s, Generator t) const; /* inlined */
Rank rank() const; /* inlined */
const Type& type() const; /* inlined */
virtual CoxSize order() const = 0;
virtual bool isFullContext() const; /* inlined */
//******* Chapter I : Elementary operations ********************************
/* word operations */
virtual int insert(CoxWord& g, const Generator& s) const; /* inlined */
virtual const CoxWord& inverse(CoxWord& g) const; /* inlined */
virtual const CoxWord& normalForm(CoxWord& g) const; /* inlined */
virtual const CoxWord& power(CoxWord& g, const Ulong& m) const;
/* inlined */
virtual int prod(CoxWord& g, const Generator& s) const; /* inlined */
virtual int prod(CoxWord& g, const CoxWord& h) const; /* inlined */
virtual const CoxWord& reduced(CoxWord& g, CoxWord& h) const; /* inlined */
/* descent sets */
virtual LFlags descent(const CoxWord& g) const; /* inlined */
virtual LFlags ldescent(const CoxWord& g) const; /* inlined */
virtual LFlags rdescent(const CoxWord& g) const; /* inlined */
bool isDescent(const CoxWord& g, const Generator& s) const;
//******** Chapter II : Schubert context **************************************
virtual CoxNbr contextNumber(const CoxWord& g) const; /* inlined */
CoxNbr contextSize() const; /* inlined */
Length length(const CoxNbr& x) const; /* inlined */
virtual CoxNbr extendContext(const CoxWord& g);
virtual void permute(const Permutation& a);
virtual LFlags descent(const CoxNbr& x) const; /* inlined */
virtual LFlags ldescent(const CoxNbr& x) const; /* inlined */
virtual LFlags rdescent(const CoxNbr& x) const; /* inlined */
virtual CoxNbr inverse(const CoxNbr& x) const; /* inlined */
virtual int prod(CoxNbr& x, const Generator& s) const;
virtual int lprod(CoxNbr& x, const Generator& s) const; /* inlined */
virtual int prod(CoxWord& g, const CoxNbr& x) const;
virtual int prod(CoxNbr& x, const CoxWord& g) const;
virtual const List<CoxNbr>& extrList(const CoxNbr& x) const; /* inlined */
//******** Chapter III : Bruhat ordering **************************************
virtual void coatoms(List<CoxWord>& c, const CoxWord& g) const;
virtual const CoatomList& coatoms(const CoxNbr& x) const ; /* inlined */
virtual void extractClosure(BitMap& b, const CoxNbr& x) const; /* inlined */
virtual bool inOrder(const CoxWord& h, const CoxWord& g) const; /* inlined */
virtual bool inOrder(List<Length>& a, const CoxWord& h, const CoxWord& g)
const; /* inlined */
virtual bool inOrder(const CoxNbr& x, const CoxNbr& y) const; /* inlined */
virtual bool isDihedral(const CoxWord& g) const;
//******** Chapter IV : Kazhdan-Lusztig functions *****************************
virtual void cBasis(kl::HeckeElt& h, const CoxNbr& y);
virtual void fillKL();
virtual void fillMu();
virtual const kl::KLPol& klPol(const CoxNbr& x, const CoxNbr& y);
virtual void klRow(kl::HeckeElt& h, const CoxNbr& y);
virtual KLCoeff mu(const CoxNbr& x, const CoxNbr& y);
virtual void fillIKL();
virtual void fillIMu();
virtual const invkl::KLPol& invklPol(const CoxNbr& x, const CoxNbr& y);
virtual void invklRow(invkl::HeckeElt& h, const CoxNbr& y);
virtual void fillUEKL();
virtual void fillUEMu();
virtual const uneqkl::KLPol& uneqklPol(const CoxNbr& x, const CoxNbr& y);
virtual const uneqkl::MuPol& uneqmu(const Generator& s, const CoxNbr& x,
const CoxNbr& y);
virtual void uneqcBasis(uneqkl::HeckeElt& h, const CoxNbr& y);
virtual void uneqklRow(uneqkl::HeckeElt& h, const CoxNbr& y);
//******** Chapter V : I/O ***************************************************
/* elementary i/o functions */
const Permutation& ordering() const; /* inlined */
String& append(String& str, const Generator& s) const; /* inlined */
String& append(String& str, const CoxWord& g) const; /* inlined */
String& append(String& str, const LFlags& f) const; /* inlined */
void printSymbol(FILE* file, const Generator& s) const; /* inlined */
void print(FILE* file, const CoxWord& g) const; /* inlined */
void print(FILE* file, const CoxNbr& x) const; /* inlined */
void printFlags(FILE* file, const LFlags& f) const; /* inlined */
void parse(ParseInterface& P) const;
virtual bool parseGroupElement(ParseInterface& P) const;
bool parseBeginGroup(ParseInterface& P) const;
bool parseContextNumber(ParseInterface& P) const;
bool parseEndGroup(ParseInterface& P) const;
virtual bool parseModifier(ParseInterface& P) const;
virtual void modify(ParseInterface& P, const Token& tok) const;
/* modifying the interface */
template<class C> void setOutputTraits(C);
void setInPostfix(const String& a); /* inlined */
void setInPrefix(const String& a); /* inlined */
void setInSeparator(const String& a); /* inlined */
void setInSymbol(const Generator& s, const String& a); /* inlined */
void setOrdering(const Permutation& order); /* inlined */
void setOutPostfix(const String& a); /* inlined */
void setOutPrefix(const String& a); /* inlined */
void setOutSeparator(const String& a); /* inlined */
void setOutSymbol(const Generator& s, const String& a); /* inlined */
template <class H> void printHeckeElt(FILE* file, const H& h); /* inlined */
};
//******** Inline implementations ******************************************
/* Chapter 0 */
inline CoxGraph& CoxGroup::graph() {return *d_graph;}
inline MinTable& CoxGroup::mintable() {return *d_mintable;}
inline KLSupport& CoxGroup::klsupport() {return *d_klsupport;}
inline kl::KLContext& CoxGroup::kl() {activateKL(); return *d_kl;}
inline invkl::KLContext& CoxGroup::invkl() {activateIKL(); return *d_invkl;}
inline uneqkl::KLContext& CoxGroup::uneqkl()
{activateUEKL(); return *d_uneqkl;}
inline Interface& CoxGroup::interface() {return *d_interface;}
inline OutputTraits& CoxGroup::outputTraits() {return *d_outputTraits;}
inline const CoxGraph& CoxGroup::graph() const {return *d_graph;}
inline const MinTable& CoxGroup::mintable() const {return *d_mintable;}
inline const KLSupport& CoxGroup::klsupport() const {return *d_klsupport;}
inline const kl::KLContext& CoxGroup::kl() const {return *d_kl;}
inline const uneqkl::KLContext& CoxGroup::uneqkl() const {return *d_uneqkl;}
inline const SchubertContext& CoxGroup::schubert() const
{return d_klsupport->schubert();}
inline const Interface& CoxGroup::interface() const {return *d_interface;}
inline const OutputTraits& CoxGroup::outputTraits() const
{return *d_outputTraits;}
inline CoxEntry CoxGroup::M(Generator s, Generator t) const
{return(graph().M(s,t));}
inline Rank CoxGroup::rank() const {return(graph().rank());}
inline const Type& CoxGroup::type() const {return graph().type();}
inline bool CoxGroup::isFullContext() const {return false;}
/* Chapter I */
inline int CoxGroup::insert(CoxWord& g, const Generator& s) const
{return mintable().insert(g,s,ordering());}
inline const CoxWord& CoxGroup::inverse(CoxWord& g) const
{return mintable().inverse(g);}
inline const CoxWord& CoxGroup::normalForm(CoxWord& g) const
{return mintable().normalForm(g,interface().order());}
inline const CoxWord& CoxGroup::power(CoxWord& g, const Ulong& m) const
{return mintable().power(g,m);}
inline int CoxGroup::prod(CoxWord& g, const Generator& s) const
{return mintable().prod(g,s);}
inline int CoxGroup::prod(CoxWord& g, const CoxWord& h) const
{return mintable().prod(g,h);}
inline const CoxWord& CoxGroup::reduced(CoxWord& g, CoxWord& h) const
{return mintable().reduced(g,h);}
inline LFlags CoxGroup::descent(const CoxWord& g) const
{return mintable().descent(g);}
inline LFlags CoxGroup::ldescent(const CoxWord& g) const
{return mintable().ldescent(g);}
inline LFlags CoxGroup::rdescent(const CoxWord& g) const
{return mintable().rdescent(g);}
/* Chapter II */
inline CoxNbr CoxGroup::contextNumber(const CoxWord& g) const
{return schubert().contextNumber(g);}
inline CoxNbr CoxGroup::contextSize() const {return d_klsupport->size();}
inline Length CoxGroup::length(const CoxNbr& x) const
{return d_klsupport->length(x);}
inline LFlags CoxGroup::descent(const CoxNbr& x) const
{return schubert().descent(x);}
inline LFlags CoxGroup::ldescent(const CoxNbr& x) const
{return schubert().ldescent(x);}
inline LFlags CoxGroup::rdescent(const CoxNbr& x) const
{return schubert().rdescent(x);}
inline CoxNbr CoxGroup::inverse(const CoxNbr& x) const
{return d_klsupport->inverse(x);}
inline int CoxGroup::lprod(CoxNbr& x, const Generator& s) const
{return prod(x,s+rank());}
inline const List<CoxNbr>& CoxGroup::extrList(const CoxNbr& x) const
{return d_klsupport->extrList(x);}
/* Chapter III */
inline const CoatomList& CoxGroup::coatoms(const CoxNbr& x) const
{return schubert().hasse(x);}
inline void CoxGroup::extractClosure(BitMap& b, const CoxNbr& x) const
{return schubert().extractClosure(b,x);}
inline bool CoxGroup::inOrder(const CoxWord& g, const CoxWord& h) const
{return mintable().inOrder(g,h);}
inline bool CoxGroup::inOrder(List<Length>& a, const CoxWord& g,
const CoxWord& h) const
{return mintable().inOrder(a,g,h);}
inline bool CoxGroup::inOrder(const CoxNbr& x, const CoxNbr& y) const
{return schubert().inOrder(x,y);}
/* Chapter V */
inline const Permutation& CoxGroup::ordering() const
{return interface().order();}
inline String& CoxGroup::append(String& str, const Generator& s)
const {return appendSymbol(str,s,interface());}
inline String& CoxGroup::append(String& str, const CoxWord& g) const
{return interface::append(str,g,interface());}
inline String& CoxGroup::append(String& str, const LFlags& f) const
{return interface::append(str,f,interface());}
inline void CoxGroup::printSymbol(FILE* file, const Generator& s)
const {return interface::printSymbol(file,s,interface());}
inline void CoxGroup::print(FILE* file, const CoxWord& g) const
{return interface().print(file,g);}
inline void CoxGroup::print(FILE* file, const CoxNbr& x) const
{return schubert().print(file,x,interface());}
inline void CoxGroup::printFlags(FILE* file, const LFlags& f) const
{return interface::print(file,f,interface());}
inline void CoxGroup::setInPostfix(const String& a)
{interface().setInPostfix(a);}
inline void CoxGroup::setInPrefix(const String& a)
{interface().setInPrefix(a);}
inline void CoxGroup::setInSeparator(const String& a)
{interface().setInSeparator(a);}
inline void CoxGroup::setInSymbol(const Generator& s, const String& a)
{interface().setInSymbol(s,a);}
inline void CoxGroup::setOrdering(const Permutation& order)
{interface().setOrder(order);}
inline void CoxGroup::setOutPostfix(const String& a)
{interface().setOutPostfix(a);}
inline void CoxGroup::setOutPrefix(const String& a)
{interface().setOutPrefix(a);}
inline void CoxGroup::setOutSeparator(const String& a)
{interface().setOutSeparator(a);}
inline void CoxGroup::setOutSymbol(const Generator& s, const String& a)
{interface().setOutSymbol(s,a);}
template <class H>
inline void CoxGroup::printHeckeElt(FILE* file, const H& h)
{files::printHeckeElt(file,h,schubert(),outputTraits());}
//******** template definitions ***********************************************
template<class C> void CoxGroup::setOutputTraits(C)
{new(d_outputTraits) OutputTraits(graph(),interface(),C());}
}
#endif