tori.h

Go to the documentation of this file.

/*
  This is tori.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 TORI_H  /* guard against multiple inclusions */
#define TORI_H

#include "bits.h"
#include "tags.h"

#include "../Atlas.h"
#include "subquotient.h"

namespace atlas {

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

namespace tori {

  SmallSubquotient dualPi0(const WeightInvolution&);

  WeightInvolution plusMatrix(const WeightInvolution&, const RealTorus&);
  WeightInvolution minusMatrix(const WeightInvolution&, const RealTorus&);

  void plusBasis(WeightList&, const WeightInvolution&);

  WeightList plusBasis(const WeightInvolution&);

  void minusBasis(WeightList&, const WeightInvolution&);

  WeightList minusBasis(const WeightInvolution&);

}

/******** type definitions **************************************************/

namespace tori {

  class RealTorus {

 private:

  size_t d_rank;                             // rank of torus

  size_t d_complexRank;                      // number of C^x-factors

  WeightInvolution d_involution;            // matrix of the involution

  WeightList d_plus;                     // basis for +1 eigenlattice

  WeightList d_minus;                    // basis for -1 eigenlattice

  LatticeMatrix d_toPlus;                // transform coordinates to $X_+$

  LatticeMatrix d_toMinus;               // transform coordinates to $X_-$

  SmallSubquotient d_topology;

 public:

// constructors and destructors
  explicit RealTorus(const WeightInvolution&);

  RealTorus(const RealTorus&, tags::DualTag);

// accessors

  const WeightInvolution& involution() const { return d_involution; }

  size_t rank() const { return d_rank; }
  size_t complexRank() const { return d_complexRank; }
  size_t compactRank() const { return d_plus.size()-d_complexRank; }
  size_t splitRank() const { return d_minus.size()-d_complexRank; }
  size_t plusRank() const { return d_plus.size(); }
  size_t minusRank() const { return d_minus.size(); }
  size_t twoRank() const { return d_rank-d_complexRank; }

  bool isCompact() const { return d_plus.size() == d_rank; }
  bool isSplit() const { return d_minus.size() == d_rank; }

  BinaryMap componentMap(const LatticeMatrix&,
                    const RealTorus&) const;

  const WeightList& plusLattice() const { return d_plus; }
  const WeightList& minusLattice() const { return d_minus; }

  void toPlus(Weight& dest, const Weight& source) const
    { dest=d_toPlus*source; }

  void toMinus(Weight& dest, const Weight& source) const
    { dest=d_toMinus*source; }

  const SmallSubquotient& topology() const { return d_topology; }
};

}

}

#endif