atlas  0.6
cartanclass.h
Go to the documentation of this file.
1 /*
2  This is cartanclass.h
3 
4  Copyright (C) 2004,2005 Fokko du Cloux
5  part of the Atlas of Lie Groups and Representations
6 
7  For license information see the LICENSE file
8 */
9 
10 // Definitions and declarations for the CartanClass and Fiber classes.
11 
12 #ifndef CARTANCLASS_H /* guard against multiple inclusions */
13 #define CARTANCLASS_H
14 
15 #include "../Atlas.h"
16 
17 #include "tags.h"
18 #include "bitset.h" // containment of |Grading|
19 #include "partition.h" // containment of |Partition|
20 
21 #include "involutions.h"// containment of |InvolutionData|
22 #include "tori.h" // containment of |RealTorus|
23 
24 namespace atlas {
25 
26 /******** function declarations **********************************************/
27 
28 namespace cartanclass
29 {
31  (const RootSystem&, const InvolutionData&);
32 
33  Weight
34  compactTwoRho(AdjointFiberElt, const Fiber&, const RootDatum&);
35 
36  Grading
37  restrictGrading(const RootNbrSet&, const RootNbrList&);
38 
39  // minimal grading of the imaginary simple roots that belongs to |rf|
41  (const Partition& fg_partition, RealFormNbr rf, RankFlags fixed_points);
42 
43  // strongly orthogonal reflections leading to most split Cartan for |rf|
45  toMostSplit(const Fiber&,RealFormNbr rf,const RootSystem&);
46 }
47 
48 /******** type definitions ***************************************************/
49 
50 namespace cartanclass {
51 
52 /*
53  The class |Fiber| describes "the fiber" (in the set of strong real forms)
54  over a fixed involution of a torus, in twisted Tits group.
55 
56  This is an important but somewhat subtle class. In fact none of the data
57  stored directly describes the mentioned fiber, or the strong real forms in
58  it. There is the description of a "fiber group", a vector space over $Z/2Z$
59  that acts simply transitively on the fiber. In other words, the fiber is an
60  affine space over $Z/2Z$ with the fiber group as space of translations, and
61  a choice of a base point determines a bijection between the fiber and this
62  fiber group. One way fiber elements manifest themselves is via a grading of
63  the set of imaginary roots. This grading is determined for the entire fiber
64  by giving the "base grading" for the base point, and the "grading shifts"
65  for translations by each of a set of generators of the grading group.
66 
67  We fix an involutive automorphism $\tau$ of the complex torus $H$, and
68  consider the collection of all strong involutiond $x$ of $G$ (which are
69  elements of "G semidirect delta") that induce $\tau$ on $H$; conjuguation
70  defines an action of $H$ on the collection, and strong real forms are
71  oribits for this action. A strong real form has square equal to some
72  element $z$ in $Z(G)^\delta$. (Changing the element $z$ by $(1+\delta)Z$ is
73  relatively innocuous, and the quotient $Z^delta/[(1+delta)Z]$ is finite.)
74 
75  For each fixed value of $z$, this collection of strong real forms admits a
76  simply transitive action (by left multiplication) of the fiber group: the
77  quotient $H^{-\tau}/(1-\tau)H$, which is isomorphic to the component group
78  of the complex group $H^{-\tau}$ of fixed points of $-\tau$ on $H$. It is an
79  elementary $2$-group that can be realized as a subquotient of the group
80  $H(2)$ of involutions in $H$. While the expression $H^{-\tau}/(1-\tau)H$ is
81  mathematically correct, it is intuitively misleading since the fiber group
82  is largest when $H^{-\tau}$ is smallest, namely when $\tau$ is the identity
83  (one simply gets $H(2)$ in this case), and when for the linear involution
84  $\theta$ of $X^*$ defined by $\tau$ one has that $-\theta$ has one $0$ as
85  fixed point. The expression that will be actually used to determine the
86  fiber group is $(X_*)^\theta/(X_*(1+\theta)), the fixed points of $\theta$
87  acting on the right on the coweight lattive $X_*$, modulo the image of the
88  action of $1+\theta$.
89 
90  For a given $z$, orbits of strong real forms for that $z$ under the action
91  of the imaginary Weyl group form a partition of the fiber group (which
92  parition depends on $z$); this is the basis for the classification of weak
93  real forms. These partitions (for various $z$) are stored in |d_strongReal|,
94  and accessed by the function |fiber_partition|. A strong real form may be
95  labelled by a pair of integers: the second labelling the element $z$ (or
96  rather its coset modulo $(1+delta)Z$), and the first the fiber group orbit.
97 */
98 class Fiber {
99 
100  private:
101 
102 /* A torus defined over R.
103 
104  Represented as the lattice Z^n endowed with an involutive
105  automorphism (represented by its n x n integer matrix).
106 */
108 
109  // some basic data associated to the involution, such as set of real roots
110  InvolutionData d_involutionData;
111 
112 /* Fiber group.
113 
114  In terms of the complex torus $H$ and the Cartan involution $\tau$, it
115  is equal to $F=H^{-\tau}/(1-\tau)H$: the group of fixed points of
116  $\-tau$, modulo its identity component. Here additive notation is used
117  for multiplicative composition; e.g., $1-\tau$ maps $z\in H$ to
118  $z/\tau(z)$; this notation is natural when $\tau$ is viewed as
119  operating on the weight lattice, in which case $1-\tau$ acts as the
120  identity matrix minus the matrix giving $\tau$.
121 
122  Recall that the group of real points $H(R)$ is a product of $p$ unit circle
123  groups, $q$ groups $R^\times$, and $r$ groups $C^\times$. It is easy to see
124  that $F=(\Z/2\Z)^p$, with one factor $\Z/2\Z$ coming from each circle.
125 
126  The fiber group is represented as a subquotient of the group $H(2)$ of
127  elements of order 2 (or 1) in the torus. Write $Y$ for the lattice of
128  coweights of $H$; then one has natural isomorphisms $H(2)=(1/2)Y/Y=Y/2Y$.
129  The Cartan involution $\tau$ is always represented by the matrix $q$ of
130  its action on the character lattice $X$, which is dual to $Y$; so its action
131  on $Y$ is given by the matrix $q^t$. The action of $-\tau$ on $Y$ is
132  given by $-q^t$.
133 
134  Because $H$ is the product (not direct) of the connected groups
135  $(H^\tau)_0$ and $(H^{-\tau})_0$, the group $H^\tau$ meets every
136  component of $H^{-tau}$. The intersection of $H^\tau$ and
137  $H^{-\tau}$ consists of $H(2)^\tau$, the $\tau$-fixed elements
138  of order 2. It follows that the component group $F$ may be identified with
139  $H(2)^\tau/(H(2)\cap (1-\tau)H)$. Thus $F$ can be represented by a
140  subquotient of $H(2)=Y/2Y=(Z/2Z)^n$.
141 
142  The larger group $H(2)^\tau$ is computed as the kernel of the action of
143  $(1+\tau)$ on $H(2)$, which via the isomorphism $H(2)=(Z/2Z)^n$ means
144  the kernel of the reduction mod 2 of the matrix $I+q^t$. The smaller group
145  $H(2)\cap (1-\tau)H$ consists of the elements of order 2 in the
146  connected group $(H^{-\tau})_0$. It is computed as the reduction mod 2
147  of the $-1$ eigenlattice $Y^{-\tau}$ (the latter is the lattice of
148  coweights of $(H^{-tau})_0$).
149 */
151 
152 /*
153  Fiber group for the adjoint group of G.
154 
155  Writing H_ad for the complex torus in G_ad, and still writing tau for the
156  Cartan involution, this is F_ad=H_ad^{-tau}/(1-tau)H_ad. The adjoint
157  covering G-->G_ad defines a natural map F-->F_ad, but this map may be
158  neither injective nor surjective.
159 
160  The adjoint fiber is computed from the action of tau on the adjoint lattice
161  of one-parameter subgroups Y_ad just as the fiber group is computed. The
162  lattice Y_ad has as basis the fundamental coweights.
163 */
165 
166 // List of all noncompact imaginary roots for the base grading
168 
169 /* Grading with all simple-imaginary roots noncompact.
170 
171  All bits are 1, their (small) number is the imaginary rank of the fiber
172 */
174 
175 /* RootSet $i$ in this vector flags the imaginary roots whose grading is
176  changed by canonical basis vector $i$ of the adjoint fiber group.
177 */
178  std::vector<RootNbrSet> d_noncompactShift; // |size()==adjointFiberRank()|
179 
180 /* Grading $i$ flags the simple-imaginary roots whose grading is changed by
181  canonical basis vector $i$ in the adjoint fiber group.x
182 */
183  GradingList d_gradingShift; // |size()==adjointFiberRank()|
184 
185 /* Matrix (over $Z/2Z$) of the map from the fiber group $F$ for $G$ to the
186  fiber group $F_ad$ for $G_ad$.
187 
188  Although the map is induced by Y/2Y-->Y_ad/2Y_ad, whose matrix is the
189  reduction mod 2 of the matrix of Y-->Y_ad, that is _not_ the matrix in
190  |d_toAdjoint|, which must take into account the subquotients at both sides.
191  Each subquotient $F$ and $F_ad$ is equipped (by the row reduction algorithms
192  in Subquotient) with a distinguished basis, and what is recorded in
193  |d_toAdjoint| is the $(\dim F_ad) x (\dim F)$ matrix with respect to those
194  bases.
195 */
197 
198 /* Partition of the adjoint fiber group according to weak real forms.
199 
200  The imaginary Weyl group acts on the adjoint fiber group; the partition is
201  by orbits of this action, and each orbit corresponds to a weak real form.
202 */
203  Partition d_weakReal;
204 
205 /* Partition of the set [0,numRealForms()[ indexing weak real forms according
206  to their corresponding square classes, in $Z(G)^delta/[(1+delta)Z(G)]$.
207 */
209 
210 /*
211  Collection of partitions of Fiber group cosets, each corresponding to a
212  possible square classes in Z^delta/[(1+delta)Z].
213 
214  The Fiber group acts in a simply transitive way on strong real forms
215  (inducing $\tau$ on $H$) with a fixed square in $Z^delta$. The number of
216  squares that occur (modulo $(1+\delta)Z$) is equal to the number $c$ of
217  classes in the partition |d_realFormPartition|. The collection of strong
218  real forms is therefore a collection of $c$ cosets of the fiber group |F|.
219  Each of these $c$ cosets is partitioned into $W_i$-orbits; these partitions
220  into orbits are described by the $c$ partitions in |d_strongReal|.
221 */
222  std::vector<Partition> d_strongReal;
223 
224 /* Representative strong real form for each weak real form.
225 
226  A StrongRealFormRep is a pair of numbers |(x,c)|. Here |c| indexes the value
227  of the square of the strong real form in $Z^\delta/[(1+\delta)Z]$, and |x|
228  gives a part of the partition |d_strongReal[c]|, which part is a
229  $W_{im}$-orbit in the corresponding coset of the fiber group.
230 */
231  std::vector<StrongRealFormRep> d_strongRealFormReps;
232 
233  public:
234 
235 // constructors and destructors
236 
237  // main and only constructor:
238  Fiber(const RootDatum&, const WeightInvolution&);
239 
240 // copy and assignment
241 
242  Fiber(const Fiber&);
243 
244 // accessors
245 
246 /* Real torus defined over $\R$.
247 
248  Represented as the lattice $\Z^n$ endowed with an involutive
249  automorphism (represented by its $n \times n$ integer matrix).
250 */
251  const tori::RealTorus& torus() const { return d_torus; }
253  { return d_torus.involution(); }
254  size_t plusRank() const { return d_torus.plusRank(); }
255  size_t minusRank() const { return d_torus.minusRank(); }
256 
257 
258  const InvolutionData& involution_data() const { return d_involutionData; }
259 
260 // RootSet flagging the complex roots.
261  const RootNbrSet& complexRootSet() const
262  { return d_involutionData.complex_roots(); }
263 
264 // RootSet flagging the imaginary roots.
266  { return d_involutionData.imaginary_roots(); }
267 
268 // RootSet flagging the real roots.
269  const RootNbrSet& realRootSet() const
270  { return d_involutionData.real_roots(); }
271 
272 /*
273  RootList holding the numbers of the simple-imaginary roots.
274 
275  These are simple for the positive imaginary roots given by the (based)
276  RootDatum. They need not be simple in the entire root system.
277 */
279  { return d_involutionData.imaginary_basis(); }
280  const RootNbr simpleImaginary(size_t i) const
281  { return d_involutionData.imaginary_basis(i); }
282  size_t imaginaryRank() const { return d_involutionData.imaginary_rank(); }
283 
284 /*
285  RootList holding the numbers of the simple-real roots.
286 
287  These are simple for the positive real roots given by the (based) RootDatum.
288  They need not be simple in the entire root system.
289 */
290  const RootNbrList& simpleReal() const
291  { return d_involutionData.real_basis(); }
292  const RootNbr simpleReal(size_t i) const
293  { return d_involutionData.real_basis()[i]; }
294  size_t realRank() const { return d_involutionData.real_rank(); }
295 
296  // Action of the Cartan involution on root |j|.
298  { return d_involutionData.root_involution()[j]; }
299 
300 
301 
302  // Fiber group.
303 
305  { return d_fiberGroup; }
306 
307  // Dimension of the fiber group as a $Z/2Z$ vector space.
308  size_t fiberRank() const { return d_fiberGroup.dimension(); }
309 
310  // Cardinality of the fiber group: 2^dimension.
311  size_t fiberSize() const { return d_fiberGroup.size(); }
312 
313 /*
314  Fiber group for the adjoint group of G.
315 
316  Writing $H_ad$ for the complex torus in $G_ad$, and still writing $\tau$ for
317  the Cartan involution, this is $F_ad=H_ad^{tau}/(1+tau)H_ad$ (on a compact
318  Cartan $\tau=1$, and one gets the essentially the group $H_ad(2)$ of
319  elements of order dividing 2). The adjoint covering G-->G_ad defines a
320  natural map F-->F_ad, but this map may be neither injective nor surjective.
321 
322  The adjoint fiber is computed from the action of tau on the adjoint lattice
323  of one-parameter subgroups Y_ad just as the fiber group is computed. The
324  lattice Y_ad has as basis the fundamental coweights.
325 */
327  { return d_adjointFiberGroup; }
328 
329 // Dimension of the adjoint fiber group as a $Z/2Z$ vector space.
330  size_t adjointFiberRank() const { return d_adjointFiberGroup.dimension(); }
331 
332 // Cardinality of the adjoint fiber group.
333  size_t adjointFiberSize() const { return d_adjointFiberGroup.size(); }
334 
335 
336  RootNbrSet compactRoots(AdjointFiberElt x) const;
337 
338  RootNbrSet noncompactRoots(AdjointFiberElt x) const;
339 
340  // grading of simple-imaginary roots associated to an adjoint fiber element
342 
343  // An inverse of |grading|, assuming |g| is valid in this fiber
344  AdjointFiberElt gradingRep(const Grading& g) const;
345 
346  // Image of a coroot (expressed in weight basis) in the fiber group
347 
348  SmallBitVector mAlpha(const rootdata::Root&) const;
349 
350 /* Number of weak real forms containing this Cartan.
351 
352  This is the number of orbits of the imaginary Weyl group on the adjoint
353  fiber group.
354 */
355  size_t numRealForms() const { return d_weakReal.classCount(); }
356 
357 /*
358  Partition of the weak real forms according to the corresponding central
359  square classes in $Z(G)/[(1+\delta)Z(G)]$.
360 
361  A weak real form (always containing our fixed real torus) is an orbit of
362  $W_{im}$ on the adjoint fiber group.
363 */
364  const Partition& realFormPartition() const { return d_realFormPartition; }
365 
366  // The central square class to which a weak real form belongs.
368  {
369  return d_realFormPartition.class_of(wrf); // square class number of |wrf|
370  }
371 
372  // The base element for a central square class
374  { return wrf_rep(d_realFormPartition.classRep(c)); }
375 
376 /*
377  List of partitions of the fiber group cosets, its elements corresponding to
378  the possible square classes in $Z^\delta/[(1+\delta)Z]$.
379 
380  The fiber group acts in a simply transitive way on the strong involutions
381  (inducing $\tau$ on $H$) with a fixed square in $Z^\delta$. The number of
382  squares that occur (modulo $(1+\delta)Z)$ is equal to the number $n$ of
383  classes in the partition d_realFormPartition. The collection of strong real
384  involutions is therefore a union of $n$ copies of the fiber group $F$, each
385  an affine $Z/2Z$-space with $W_{im}$ acting in a different way. Thus each of
386  these $n$ spaces is partitioned into $W_{im}$ orbits; these partitions are
387  stored in |d_strongReal|.
388 */
389  const Partition& fiber_partition(square_class c) const
390  { return d_strongReal[c]; }
391 
392 /*
393  Representative strong real form for real form |rf|.
394 
395  A |StrongRealFormRep| is a pair of numbers. The second number |c| identifies
396  the square class, the class in $Z^\delta/[(1+\delta)Z]$ of the square of any
397  strong involution representing the strong real form; it equals
398  |central_square_class(wrf)|. The first number indexes a $W_{im}$-orbit in
399  the corresponding coset of the fiber group, as (a |short| integer
400  identifying) a part of the partition |fiber_partition(c)|
401 */
403  { return d_strongRealFormReps[wrf]; }
404 
405 /*
406  Natural linear map from fiber group to adjoint fiber group, induced by the
407  inclusion of the root lattice in the character lattice
408 */
409  BinaryMap toAdjoint() const { return d_toAdjoint; }
410  AdjointFiberElt toAdjoint(FiberElt) const;
411 
412 /* The class number in the weak real form partition of the strong real form
413  |c| in real form class |csc|.
414 */
415  adjoint_fiber_orbit toWeakReal(fiber_orbit c, square_class csc) const;
416 
417 
418 /* Partition of adjoint fiber group; the classes (which are $W_i$-orbits)
419  correspond to weak real forms, but numbering is specific to this fiber;
420  conversion to |RealFormNbr| is done in complex group via |real_labels|
421 */
422  const Partition& weakReal() const { return d_weakReal; }
424  { return AdjointFiberElt(RankFlags(d_weakReal.classRep(wrf)),
425  adjointFiberRank()); }
427  { return d_weakReal.class_of(x.data().to_ulong()); }
428 
429 // private accessors only needed during construction
430 
431 private:
432 
433  SmallSubquotient makeFiberGroup() const;
434 
435  SmallSubquotient makeAdjointFiberGroup
436  (const RootSystem&) const;
437 
438  SmallSubspace gradingGroup(const RootSystem&) const;
439 
440  Grading makeBaseGrading
441  (RootNbrSet& flagged_roots,const RootSystem&) const;
442 
443  GradingList makeGradingShifts
444  (std::vector<RootNbrSet>& all_shifts,const RootSystem&) const;
445 
446  RankFlagsList adjointMAlphas (const RootSystem&) const;
447 
448  RankFlagsList mAlphas(const RootDatum&) const;
449 
450  BinaryMap makeFiberMap(const RootDatum&) const;
451 
452  Partition makeWeakReal(const RootSystem&) const;
453 
454  Partition makeRealFormPartition() const;
455 
456  std::vector<Partition> makeStrongReal
457  (const RootDatum& rd) const;
458 
459  std::vector<StrongRealFormRep> makeStrongRepresentatives() const;
460 
461 
462 }; // |class Fiber|
463 
464 
465 
466 
467 
468 /*
469 
470  The |CartanClass| class
471 
472 */
473 
474 /* This class represents a single stable conjugacy class of Cartan subgroups.
475 
476  Mathematically this means the complex torus in the complex group, together
477  with an involutive automorphism of this torus (the Cartan involution). (More
478  precisely, it is a $W$-conjugacy class of involutive automorphisms.) As the
479  class is now used in the software, the Cartan involution must be in the
480  inner class specified by InnerClass. Most of the interesting
481  information is contained in the two underlying Fiber classes d_fiber and
482  |d_dualFiber|. First of all, that is where the Cartan involution lives (since
483  the involution is needed to define the fibers). But the fiber classes also
484  record for which real forms this stable conjugacy class of Cartan subgroups
485  is defined; and, given the real form, which imaginary roots are compact and
486  noncompact.
487 */
488 class CartanClass {
489 
490  private:
491 
492 /* Class of the fiber group H^{-tau}/[(1-tau)H] for this Cartan.
493 
494  Elements (very roughly) correspond to possible extensions
495  of the real form $\tau$ from $H$ to $G$.
496 */
498 
499 /* Class of the fiber group for the dual Cartan.
500 
501  Elements of the dual fiber group are characters of the group of connected
502  components of the real points of $H$.
503 */
505 
506 /* Roots simple for the "complex factor" of $W^\tau$.
507 
508  The subgroup $W^\tau$ of Weyl group elements commuting with the Cartan
509  involution $\tau$ has two obvious (commuting) normal subgroups: the Weyl
510  group $W^R$ of the real (that is, fixed by $-\tau$) roots, and the Weyl
511  group $W^{iR}$ of the imaginary (that is, fixed by $\tau$) roots. But
512  this is not all of $W^\tau$, as is easily seen in the case of complex
513  groups, where both $W^R$ and $W^{iR}$ are trivial (there are no real or
514  imaginary roots), yet $W$ is a direct sum of two identical factors
515  interchanged by $\tau$, and the actions of diagonal elements of that sum
516  clearly commute with $\tau$. In general there is a group denoted $W^C
517  such that $W^\tau$ is a semidirect product of $W^R * W^{iR}$ (the normal
518  subgroup) with $W^C$. Here is how to describe $W^C$.
519 
520  Write $RC$ (standing for "complex roots") for the roots orthogonal to both
521  the sum of positive real roots, and the sum of positive imaginary roots
522  (this group depends on the choice of positive roots, but all choices lead to
523  conjugate subgroups). It turns out that $RC$ as a root system is the direct
524  sum of two isomorphic root systems $RC_0$ and $RC_1$ interchanged by $\tau$.
525  (There is no canonical choice of this decomposition.) Now $W^C$ is the set
526  of $\tau$-fixed elements of $W(RC_0) \times W(RC_1)$, in other words its
527  diagonal subgroup.
528 
529  In general $W^C$ is not the Weyl group of a root subsystem, but it is
530  isomorphic the the Weyl group of (any choice of) $RC_0$ (or of $RC_1$). We
531  make a choice for $RC_0$, and |d_simpleComplex| lists its simple roots, so
532  that $W^C$ is isomorphic to the Weyl group generated by the reflections
533  corresponding to the roots whose numbers are in |d_simpleComplex|.
534 */
536 
537 /* Size of the W-conjugacy class of $\tau$.
538 
539  The number of distinct involutions defining the same stable conjugacy class
540  of Cartan subgroups.
541 */
542  size_t d_orbitSize;
543 
544 public:
545 
546 // constructors and destructors
547  CartanClass(const RootDatum& rd,
548  const RootDatum& dual_rd,
550 
551 // copy and assignment: defaults are ok for copy and assignment
552 
553 // accessors
554 
555  // the matrix of the involution on the weight lattice of the Cartan subgroup
557  { return d_fiber.involution(); }
558 
559  // Action of the Cartan involution on root |j|
561  { return d_fiber.involution_image_of_root(j); }
562 
563  // RootSet flagging the imaginary roots.
565  { return d_fiber.imaginaryRootSet(); }
566  // RootSet flagging the real roots.
567  const RootNbrSet& realRootSet() const { return d_fiber.realRootSet(); }
568 
569  // RootList holding the numbers of the simple-imaginary roots.
571  { return d_fiber.simpleImaginary(); }
572 
573  // RootList holding the numbers of the simple real roots.
574  const RootNbrList& simpleReal() const { return d_fiber.simpleReal(); }
575 /* Since only the _numbers_ of simple-real roots are returned, this used to be
576  obtained as |d_dualFiber.simpleImaginary()|, before the |InvolutionData|
577  contained the basis for the real root system as well. That is indeed the
578  same value, given that the constructor for a dual root system preserves the
579  numbering of the roots (but exchanging roots and coroots of course). Such a
580  root datum differs however from one that could be constructed directly
581  (because its coroots rather than its roots are sorted lexicographically);
582  as the construction of root data might change in the future, it seems safer
583  and more robust to just take the basis of the real root subsystem. MvL.
584 */
585 
586 
587 /* Class of the fiber group $H^{-\tau}/[(1-\tau)H]$ for this Cartan.
588 
589  Elements (very roughly) correspond to possible extensions
590  of the real form tau from H to G.
591 */
592  const Fiber& fiber() const { return d_fiber; }
593 
594 /* Class of the fiber group for the dual Cartan.
595 
596  Elements of the dual fiber group are characters of the group of
597  connected components of the real points of H.
598 */
599  const Fiber& dualFiber() const { return d_dualFiber; }
600 
601 
602  bool isMostSplit(adjoint_fiber_orbit wrf) const;
603 
604 /*
605  Number of weak real forms containing this Cartan.
606 
607  This is the number of orbits of the imaginary Weyl group on the adjoint
608  fiber group.
609 */
610  size_t numRealForms() const { return d_fiber.numRealForms(); }
611  // Number of weak real forms for the dual group containing the dual Cartan.
612  size_t numDualRealForms() const { return d_dualFiber.numRealForms(); }
613 
614 /* Number of possible squares of strong real forms mod $(1+\delta)Z$.
615 
616  This is the number of classes in the partition of weak real forms
617  according to $Z^\delta/[(1+\delta)Z]$.
618 */
619  size_t numRealFormClasses() const
620  { return d_fiber.realFormPartition().classCount(); }
621 
622 /* The number of distinct involutions defining the same stable conjugacy
623  class of Cartan subgroups.
624 */
625  size_t orbitSize() const { return d_orbitSize; }
626 
627 /* Roots simple for the "complex factor" of $W^\tau$.
628 
629  The subgroup $W^\tau$ of Weyl group elements commuting with the Cartan
630  involution tau has two obvious (commuting) normal subgroups: the Weyl group
631  $W^R$ of the real (that is, fixed by $-\tau$) roots, and the Weyl group
632  $W^iR$ of the imaginary (that is, fixed by $\tau$) roots. But this is not
633  all: $W^\tau$ is a semidirect product of $W^R x W^iR$ with a group $W^C$,
634  the first factor being normal. Here is how to describe $W^C$.
635 
636  Write $RC$ (standing for "complex roots") for the roots orthogonal to (a)
637  the sum of positive real roots, and also to (b) the sum of positive
638  imaginary roots. It turns out that $RC$ as a root system is the direct sum
639  of two isomorphic root systems $RC_0$ and $RC_1$ interchanged by tau. (There
640  is no canonical choice of this decomposition.) The group $W^\tau$ includes
641  $W^C$, the diagonal subgroup of $W(RC_0) \imes W(RC_1)$. The list
642  |d_simpleComplex| contains the numbers of the simple roots for (a choice of)
643  $RC_0$. That is, the Weyl group $W^C$ is isomorphic to the Weyl group
644  generated by the reflections corresponding to the numbers in
645  |d_simpleComplex|.
646 */
647  const RootNbrList& simpleComplex() const { return d_simpleComplex; }
648 
649 /* Partitions of fiber group cosets corresponding to the
650  possible square classes in $Z^\delta/[(1+delta)Z]$.
651 */
652  const Partition& fiber_partition(square_class j) const
653  { return d_fiber.fiber_partition(j); }
654 
655 /* The image of x in the adjoint fiber group.
656  Precondition: x is a valid element in the fiber group.
657 */
658  AdjointFiberElt toAdjoint(FiberElt x) const { return d_fiber.toAdjoint(x); }
659 
660 /*
661  The class number in the weak real form partition of the strong real form |c|
662  in real form class |csc|.
663 
664  The pair |(c,csc)| specifies a strong real form by giving its square class
665  |csc| (which labels an element of $Z^\delta/[(1+\delta)Z]$) and an orbit
666  number $c$ in the corresponding action of $W_im$ on the fiber group. The
667  function returns the corresponding weak real form, encoded (internally) as
668  number of a $W_im$-orbit on the adjoint fiber stored in |d_weakReal|
669 */
671  { return d_fiber.toWeakReal(c,csc); }
672 
673 /* Partition of adjoint fiber group; the classes (which are $W_i$-orbits)
674  correspond to weak real forms, but numbering is specific to this fiber;
675  conversion to |RealFormNbr| is done in complex group via |real_labels|
676 */
677  const Partition& weakReal() const { return d_fiber.weakReal(); }
678 
679 
680 // private accessors only needed during construction
681 
682 private:
683  RootNbrList makeSimpleComplex(const RootDatum&) const;
684 
685  // number of conjugate twisted involutions (|rs| is our root system)
686  size_t orbit_size(const RootSystem& rs) const;
687 
688 }; // |class CartanClass|
689 
690 } // |namespace cartanclass|
691 
692 } // |namespace atlas|
693 
694 #endif
size_t fiberSize() const
Definition: cartanclass.h:311
AdjointFiberElt wrf_rep(adjoint_fiber_orbit wrf) const
Definition: cartanclass.h:423
unsigned short square_class
Definition: Atlas.h:312
size_t realRank() const
Definition: cartanclass.h:294
BitVector< constants::RANK_MAX > SmallBitVector
Definition: Atlas.h:181
const Partition & realFormPartition() const
Definition: cartanclass.h:364
RootNbrSet d_baseNoncompact
Definition: cartanclass.h:167
RootNbr involution_image_of_root(RootNbr j) const
Definition: cartanclass.h:560
Class definition and function declarations for the class RealTorus.
BinaryMap d_toAdjoint
Definition: cartanclass.h:196
Grading d_baseGrading
Definition: cartanclass.h:173
const StrongRealFormRep & strongRealForm(adjoint_fiber_orbit wrf) const
Definition: cartanclass.h:402
Partition d_realFormPartition
Definition: cartanclass.h:208
SmallSubquotient d_adjointFiberGroup
Definition: cartanclass.h:164
BitSet< constants::RANK_MAX > RankFlags
Definition: Atlas.h:60
const Partition & fiber_partition(square_class c) const
Definition: cartanclass.h:389
unsigned short adjoint_fiber_orbit
Definition: Atlas.h:311
const RootNbrSet & complexRootSet() const
Definition: cartanclass.h:261
size_t fiberRank() const
Definition: cartanclass.h:308
size_t dimension() const
Definition: subquotient.h:195
size_t d_orbitSize
Definition: cartanclass.h:542
std::vector< StrongRealFormRep > d_strongRealFormReps
Definition: cartanclass.h:231
const tori::RealTorus & torus() const
Definition: cartanclass.h:251
tori::RealTorus d_torus
Definition: cartanclass.h:107
GradingList d_gradingShift
Definition: cartanclass.h:183
Definition: cartanclass.h:98
std::vector< Grading > GradingList
Definition: Atlas.h:290
const RootNbrList & simpleComplex() const
Definition: cartanclass.h:647
BinaryMap toAdjoint() const
Definition: cartanclass.h:409
const WeightInvolution & involution() const
Definition: tori.h:138
size_t orbitSize() const
Definition: cartanclass.h:625
adjoint_fiber_orbit toWeakReal(fiber_orbit c, square_class csc) const
Definition: cartanclass.cpp:811
Weight compactTwoRho(AdjointFiberElt x, const Fiber &f, const RootDatum &rd)
Definition: cartanclass.cpp:826
Grading specialGrading(const Fiber &f, RealFormNbr rf, const RootSystem &rs)
Definition: cartanclass.cpp:863
const Partition & fiber_partition(square_class j) const
Definition: cartanclass.h:652
size_t numRealForms() const
Definition: cartanclass.h:355
int_Vector Weight
Definition: Atlas.h:154
const SmallSubquotient & adjointFiberGroup() const
Definition: cartanclass.h:326
const RootNbrSet & realRootSet() const
Definition: cartanclass.h:269
AdjointFiberElt class_base(square_class c) const
Definition: cartanclass.h:373
size_t plusRank() const
Definition: tori.h:144
size_t numDualRealForms() const
Definition: cartanclass.h:612
AdjointFiberElt toAdjoint(FiberElt x) const
Definition: cartanclass.h:658
InvolutionData d_involutionData
Definition: cartanclass.h:110
RootNbrList d_simpleComplex
Definition: cartanclass.h:535
std::vector< RankFlags > RankFlagsList
Definition: Atlas.h:62
const WeightInvolution & involution() const
Definition: cartanclass.h:556
Partition d_weakReal
Definition: cartanclass.h:203
const InvolutionData & involution_data() const
Definition: cartanclass.h:258
size_t adjointFiberSize() const
Definition: cartanclass.h:333
WeightInvolution involution(const Layout &lo)
Definition: lietype.cpp:463
const RootNbrList & simpleReal() const
Definition: cartanclass.h:290
std::vector< Partition > d_strongReal
Definition: cartanclass.h:222
size_t imaginaryRank() const
Definition: cartanclass.h:282
const Fiber & dualFiber() const
Definition: cartanclass.h:599
size_t plusRank() const
Definition: cartanclass.h:254
size_t adjointFiberRank() const
Definition: cartanclass.h:330
SmallBitVector AdjointFiberElt
Definition: Atlas.h:309
bitmap::BitMap RootNbrSet
Definition: Atlas.h:218
unsigned short RealFormNbr
Definition: Atlas.h:302
int_Matrix WeightInvolution
Definition: Atlas.h:159
const SmallSubquotient & fiberGroup() const
Definition: cartanclass.h:304
const RootNbrList & simpleReal() const
Definition: cartanclass.h:574
unsigned long size() const
Definition: subquotient.h:216
square_class central_square_class(adjoint_fiber_orbit wrf) const
Definition: cartanclass.h:367
const Partition & weakReal() const
Definition: cartanclass.h:422
const RootNbrSet & realRootSet() const
Definition: cartanclass.h:567
Fiber d_dualFiber
Definition: cartanclass.h:504
CoweightInvolution adjoint_involution(const RootSystem &rs, const InvolutionData &id)
Definition: cartanclass.cpp:221
unsigned int g(A &x)
Definition: lists.cpp:38
Fiber d_fiber
Definition: cartanclass.h:497
RootNbrSet toMostSplit(const Fiber &fundf, RealFormNbr rf, const RootSystem &rs)
Definition: cartanclass.cpp:911
Definition: Atlas.h:38
Definition of dummy argument tags used for constructor overloading.
const RootNbrList & simpleImaginary() const
Definition: cartanclass.h:570
size_t numRealFormClasses() const
Definition: cartanclass.h:619
const Partition & weakReal() const
Definition: cartanclass.h:677
const Fiber & fiber() const
Definition: cartanclass.h:592
size_t minusRank() const
Definition: cartanclass.h:255
Class definitions and function declarations for the BitSet class.
Container of a large (more than twice the machine word size) set of bits.
Definition: bitmap.h:52
BitMatrix< constants::RANK_MAX > BinaryMap
Definition: Atlas.h:185
unsigned short RootNbr
Definition: Atlas.h:216
size_t minusRank() const
Definition: tori.h:145
RootNbr involution_image_of_root(RootNbr j) const
Definition: cartanclass.h:297
const RootNbrSet & imaginaryRootSet() const
Definition: cartanclass.h:265
unsigned short fiber_orbit
Definition: Atlas.h:310
Grading restrictGrading(const RootNbrSet &rs, const RootNbrList &rl)
Definition: cartanclass.cpp:832
std::bitset< 32 > RankFlags
Definition: KLread.cpp:39
const RootNbr simpleImaginary(size_t i) const
Definition: cartanclass.h:280
RankFlags Grading
Definition: Atlas.h:289
const WeightInvolution & involution() const
Definition: cartanclass.h:252
std::vector< RootNbr > RootNbrList
Definition: Atlas.h:217
const RootNbrList & simpleImaginary() const
Definition: cartanclass.h:278
Definition: cartanclass.h:488
std::vector< RootNbrSet > d_noncompactShift
Definition: cartanclass.h:178
const RootNbrSet & imaginaryRootSet() const
Definition: cartanclass.h:564
SmallBitVector FiberElt
Definition: Atlas.h:307
adjoint_fiber_orbit toWeakReal(fiber_orbit c, square_class csc) const
Definition: cartanclass.h:670
Represents a torus defined over R.
Definition: tori.h:82
std::pair< fiber_orbit, square_class > StrongRealFormRep
Definition: Atlas.h:313
size_t numRealForms() const
Definition: cartanclass.h:610
Grading grading
Definition: output.cpp:73
adjoint_fiber_orbit adjoint_orbit(AdjointFiberElt x) const
Definition: cartanclass.h:426
SmallSubquotient d_fiberGroup
Definition: cartanclass.h:150
const RootNbr simpleReal(size_t i) const
Definition: cartanclass.h:292