center.at

lie_radical

Q-basis of Lie algebra of radical of complex group; columns are coweights

kernel(^simple_roots(rd))

defined in basic.at (and actually a better name)

semisimple_part

project a rational weight v\in X^*\otimes Q onto Q-span of the roots

weight

weight

also defined in cyclotomic_Lie_algebra.at, bracket.at

lie_radical_part

lie_radical_part(rd,v)=projection of v\in X^*\otimes Q onto Lie coradical

lie_coradical_part

lie_radical_part(rd,v)=projection of v\in X^*\otimes Q onto Lie coradical

split_radical_basis

Q-basis of Lie algebra of split part of radical; columns are coweights

lie_split_radical

equivalent: Q-basis of LA of split part of radical of the (complex) group

columns are coweights

compact_radical_basis

Q-basis of Lie algebra of compact part of radical; columns are coweights

lie_compact_radical

equivalent: Q-basis of LA of compact part of radical of the (complex) group

lie_radical_hat

Q-basis of dual of radical of complex group

kernel(^simple_coroots(rd))

defined in basic.at (and actually a better name)

split_coradical_basis

Q-basis of split part of coradical; columns are weights

lie_split_radical_hat

equivalent: Q-basis of dual of split part of radical of the (complex) group

compact_coradical_basis

Q-basis of compact part of coradical; columns are weights

lie_compact_radical_hat

equivalent: Q-basis of dual of compact part of radical of (complex) group

Z_hat 2 overloads

dual of center of *semisimple* complex group G:
  Z_hat=X^*/R  (R=root lattice)
       =Z^n/R

  dual of center of complex group G
  1 -> X^*(Z/S) -> X^*(Z) -> X^*(S) -> 1 (splits, not canonically)
  X^*(S): radical_hat
  X^*(Z/S): semisimple_part_hat
  return value: ((mat,vec) semisimple_part_hat,mat radical_hat)
  Z_hat(G)=((M,v),N)
  1 -> S -> T -> T/S -> 1
  1 -> X^*(T/S) -> X^*(T) -> X^*(S) -> 1
  (M,v) gives the finite group X^*(Z/S) = X^*(T/S)/
   M = [g_1,...,g_k]
   g_i = vector of size rank(G)
   vec = [d_1,...,d_k]
   {g_1,...,g_k} are generators of finite group X^*(Z/S)
   d_i*g_i


Z=Z(G)=center(G)
  S = radical(G) = Z(G)_0
  1 -> X^*(Z/S) -> X^*(Z) -> X^*(S) -> 1
    X^*(Z/S) = torsion subgroup of X^*(Z)
    X^*(S) = radical_hat(G)
           = {\gamma\in X^* | <gamma,alpha^\vee>=0 all \alpha\in R}
           = (R^\vee)^\perp
    X^*(Z(G/S)) = semisimple_part_hat
                = dual of center of semisimple group
		= X^*(T/S)/R  (R = root lattice, T = Cartan of G, T/S = Cartan of G/S
   semisimple_part_hat= (mat M,vec d):

   order(g_i)=d_i: i.e. d_i*g_i \in X^*(S)
   Z(G/S) \simeq \Prod \Z/d_i\Z

  return value: (semisimple_part,radical)
  semisimple_part is the center of G/radical(G)
  semisimple_part=(mat,vec)
  every entry d@j in the vec part means column j is a generator of order d
  radical=mat
    whose columns form a Q-basis of the dual of the Lie algebra of the radical
  [v1,...,vk]: basis of (R^\vee)^\perp
  where R^\vee is the coroots, and perp is taken in X^*\otimes Q

dual of center of real form G, only depends on the inner class
return value: (mat compact_hat, mat split_radical_hat)
Z=Z(G)
Z = Z_c \times Z_R
 Z_R = vector group
 Z_c = Z^\delta
X^*(G) = X^*(Z_c) \times X^*(Z_R)
 X^*(Z_R) = lattice of rank split-rank of radical

finite_part=(mat,vec)
every entry d@j in the vec part means column j is a generator of order d

radical:
compact_radical: mat whose columns are a basis of [(R^\vee)^\perp]^{delta}
where R^\vee is the coroots, and perp is taken in X^*
number of columns = number of circles in radical
split_part: mat whose columns are a basis of [(R^\vee)^\perp]^{-delta}
in this case perp is taken in X^*\otimes Q
number of columns = number of R^+ factors in radical

finite_center_string

print_Z 2 overloads

output routine for center of real form

Z_2

elements of order 2 in the center of G(R)
needed for  all_G_spherical_same_differential in K_highest_weight.at
algorithm: run over 2^n elements h=(epsilon_1,...,epsilon_n)\in H
check if delta(h)=h, i.e. (1+delta)*h has all even entries
and alpha(h)=1 for all roots alpha
This can, and should, be improved using some Z/2Z-vector space functions.

center_torsion_quotient

Return rational coweights [v_1,..., v_n] so that for $t_j=\exp(2\pi iv_j)$,
the group elements $t_1,...,t_n$ generate the center of the complex group

order(t_i)=denominator of the ratvec v_i

In center@RootDatum the RootDatum must be semisimple or an error is
returned. The value returned by center_torsion_quotient for a
reductive group appears to describe the center of the group modulo
its central torus, NOT that of the derived group (for instance for
GL(n) it returnes a trivial center). The generators are in G itself.

Method: one can present the center as $Z(G)=P^v/X_*$, where $P^v$ is the
(full rank) lattice of $X_*\tensor\Q$ spanned by the fundamental coweights.

Choose fundamental coweights as basis for $P^v$, so that (old) generators of
$X_*$ are given as columns of an integral square matrix $N$ (inverse of the
rational matrix $M$ with the fundamental coweights as columns). In fact, since
coordinates of a coweight $v$ with respect to the basis of fundamental
coweights are by definition pairings of $v$ with the simple roots, $N$ is just
the transpose of |simple_roots(rd)|. Applying |adapted_basis| to $N$ gives
$(A,c)$ where $A$ is an invertible integral matrix, so that the sublattice
$X_*$ is spanned by the multiples $c[i]A[i]$ of the columns of $A$. Applying
|filter_units| discards pairs for which |c[i]=1|, as these are not needed to
get a set of generators for the center.

The value returned are the set of rational weights $M*(A[i])$, where the
multiplication by $M$ transfers us back to the original $X_*$ coordinates.
The numbers $c[i]$ are forgotten, but in fact will appear as denominators
of the rational vectors returned, due to the way they were obtained.

generators in $X_*$

center

generators in $X_*$

type_center

order_center

has_cyclic_center

elements_of_center

list of elements in center,  for |rd| semisimple

map_to_center

rd semisimple, map arbitrary element v of P^vee to
one of the given elements_of_center(rd):
this is the element_of_center(rd) which is equal to v mod Z^n

lift

a matrix A lifting an element of T/Z(G)^0 to T, i.e. satisfying:
 for the quotient group Gmod of G by its central torus (with own coordinates)
   A*simple_coroots(Gmod)=simple_coroots(G)
Gmod is semisimple so simple_coroots(Gmod) is (square and) invertible/Q
=> A=simple_coroots(G)*inverse(simple_coroots(Gmod))
this is applied to L

also defined in hash.at, tits.at, nilpotent_orbits.at, disconnected.at

elements_of_center_derived

list of elements of center of derived group,
as elements of the original group

fundamental_group

return (|mat| generators,[int] orders):
the fundamental group is X_*/R^v, presented as a quotient of Z^n by a lattice
the columns of |generators| represent generators of the quotient, where
|generators[i]| has non-unit order |orders[i]| and the fundamental groups
is the product of the cyclic groups generated by each of the generators

elements_of_fundamental_group

now generate all fundamental group elements exhaustively

relative_fundamental_group