lietype.h

Go to the documentation of this file.

/*
  This is lietype.h

  Copyright (C) 2004,2005 Fokko du Cloux
  part of the Atlas of Lie Groups and Representations

  For license information see the LICENSE file
*/

#ifndef LIETYPE_H  /* guard against multiple inclusions */
#define LIETYPE_H


#include <stdexcept>

#include "../Atlas.h"

#include "permutations.h" // needed in the |Layout| structure

namespace atlas {

namespace lietype {

// type declaration
struct Layout;


/******** constant declarations **********************************************/
  const char* const typeLetters = "ABCDEFGT";

  const char* const innerClassLetters = "Ccesu";



struct SimpleLieType : public std::pair<TypeLetter,size_t>
{ // there are no additional data members
  typedef std::pair<TypeLetter,size_t> base;
  SimpleLieType(TypeLetter t,size_t rank) : base(t,rank) {}
  TypeLetter type() const { return base::first; }
  TypeLetter& type() { return base::first; }
  size_t rank() const { return base::second; }
  size_t& rank() { return base::second; }
  size_t semisimple_rank() const { return type()=='T' ? 0 : rank(); }
  int Cartan_entry(size_t i,size_t j) const;
  int_Matrix Cartan_matrix() const;
  int_Matrix transpose_Cartan_matrix() const;
};

struct LieType : public std::vector<SimpleLieType>
{ // there are no additional data members
  typedef std::vector<SimpleLieType> base;
  LieType() : base() {}
  LieType(const base& b) : base(b) {}

  size_t rank() const;
  size_t semisimple_rank() const;
  int Cartan_entry(size_t i,size_t j) const;
  int_Matrix Cartan_matrix() const;
  int_Matrix transpose_Cartan_matrix() const;
  int_VectorList Smith_basis(CoeffList& invf) const;
};

// the follwing rather empty definition serves mainly to make |InnerClassType|
// a genuine member of |namespace lietype| for argument-dependent lookup
struct InnerClassType : public std::vector<TypeLetter>
{ // there are no additional data members
  typedef std::vector<TypeLetter> base;
  InnerClassType() : base() {}
};

/* the |Layout| structure collects a |LieType| and an |InnerClassType|, as
   specified by the user. However dualizing may create Lie types with
   non-standard node labelings (for $G_2$, $F_4$), and in such cases an
   involution of the diagram needs to be indicated, whence the |d_perm| field.
   This is ultimately used (only) to correctly associate a real form name
   (recognised in standard diagram labelling) from a special representative
   grading of the real form (only one bit set), in |output::printType|;
   |d_perm| maps standard (Bourbaki) diagram numbers to simple root indices.
*/
struct Layout
{
  LieType d_type;
  InnerClassType d_inner;
  Permutation d_perm; // of diagram wrt usual order in |d_type|

// constructors and destructors

Layout() : d_type(), d_inner(), d_perm() {} // needed in atlas

  /* In the old Fokko interface, the Lie type is first provided,
     and the inner class type is later added; defaults identity permutation */
  Layout(const LieType& lt)
    :d_type(lt),d_inner(),d_perm(lt.rank(),1) {}

  /* The inner class can also be added right away, permutation defaults id */
  Layout(const LieType& lt, const InnerClassType ict)
    :d_type(lt),d_inner(ict),d_perm(lt.rank(),1) {}


}; // |struct Layout|



/******** function declarations **********************************************/

  bool checkRank(const TypeLetter&, size_t);

  // involution (permutation) matrix for possibly renumbered Dynkin diagram
  WeightInvolution involution(const Layout& lo);

  // permutation matrix for |ict| in simply connected |lt|, Bourbaki order
  WeightInvolution involution(const LieType& lt,
                     const InnerClassType& ict);

  LieType dual_type(LieType lt);

  InnerClassType dual_type(InnerClassType, const LieType& lt);

  Layout dual(const Layout& lo);

}

}

#endif