abelian.h

Go to the documentation of this file.

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

  For license information see the LICENSE file
*/

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

#include <limits>
#include <set>

#include "abelian_fwd.h"
#include "arithmetic_fwd.h"

#include "bitmap.h"
#include "matrix.h"

/******** type declarations **************************************************/

namespace atlas {


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

namespace abelian {

  void basis(std::vector<matrix::Vector<int> >&, const bitmap::BitMap&,
         const FiniteAbelianGroup&);

  void coset(bitmap::BitMap&, const bitmap::BitMap&, GrpNbr,
         const FiniteAbelianGroup&);

  const bitmap::BitMap& cycGenerators(const FiniteAbelianGroup&);

  void generateSubgroup(bitmap::BitMap&, GrpNbr, const FiniteAbelianGroup&);

  void generators(GrpNbrList&, const bitmap::BitMap&,
          const FiniteAbelianGroup&);

  bool isElementaryAbelian(const std::vector<arithmetic::Denom_t>&);

  // coset representatives of $G/H$ in $G$
  bitmap::BitMap quotReps(const bitmap::BitMap& H,const FiniteAbelianGroup& G);

  void to_array(GrpArr&, GrpNbr, const GroupType&);

  void to_array(GrpArr&, const matrix::Vector<int>&, const GroupType&);

  void toEndomorphism(Endomorphism&, const matrix::PID_Matrix<int>&,
              const FiniteAbelianGroup&);

  GrpNbr to_GrpNbr(const GrpArr&, const GroupType&);

  void transpose(Endomorphism&, const FiniteAbelianGroup&);

}

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

namespace abelian {

class FiniteAbelianGroup {

  unsigned long long d_size; // this limits the order of representable groups
  GroupType d_type;
  GroupType d_cotype;

 public:

// constructors and destructors
  FiniteAbelianGroup() {}

  explicit FiniteAbelianGroup(const GroupType&);

// copy and assignment: defaults are ok

// accessors
  bool operator== (const FiniteAbelianGroup& A) const {
    return d_type == A.d_type;
  }

  bool operator!= (const FiniteAbelianGroup& A) const {
    return not operator==(A);
  }

  unsigned int rank() const { return d_type.size(); }
  const GroupType& type() const {  return d_type; }

  // calling the following member |size| proved to be error prone
  unsigned long long order() const { return d_size; } // order of entire group

// representation conversions
  GrpArr toArray(GrpNbr x) const
    { GrpArr result(rank()); to_array(result,x,d_type); return result; }

  GrpArr toArray(const matrix::Vector<int>& v) const
    { GrpArr result(rank()); to_array(result,v,d_type); return result; }

  GrpNbr toGrpNbr(const GrpArr& a) const { return to_GrpNbr(a,d_type); }

  void toWeight(matrix::Vector<int>&, const GrpArr&) const;

  void toWeight(matrix::Vector<int>&, GrpNbr) const;

  // arithmetic on group elements

  GrpNbr add(GrpNbr, GrpNbr) const;

  GrpNbr add(GrpNbr, const GrpArr&) const;

  GrpArr& add(GrpArr&, const GrpArr&) const;

  GrpArr& add(GrpArr&, GrpNbr) const;

  unsigned long annihilator() const;

  const GroupType& cotype() const {
    return d_cotype;
  }

  GrpNbr leftApply(GrpNbr, const Endomorphism&) const;

  GrpArr& leftApply(GrpArr&, const Endomorphism&) const;

  GrpNbr minus(GrpNbr) const;

  unsigned long order(GrpNbr) const;

  unsigned long order(const bitmap::BitMap&, GrpNbr) const;

  unsigned long pairing(const GrpArr&, const GrpArr&) const;

  unsigned long pairing(const GrpArr&, const GrpArr&, unsigned long) const;

  GrpNbr prod(GrpNbr, unsigned long) const;

  GrpNbr subtract(GrpNbr, const GrpNbr) const;

  GrpArr& subtract(GrpArr&, const GrpArr&) const;

}; // |class FiniteAbelianGroup|

class Homomorphism {

 private:

  GroupType d_source;
  GroupType d_dest;
  GroupType d_cosource; // cotypes of source components with respect to $M$
  GroupType d_codest;   // cotypes destination components with respect to $M$
  unsigned long d_annihilator; // the common multiple $M$
  matrix::PID_Matrix<unsigned long> d_matrix;

 public:

// constructors and destructors
  Homomorphism(const std::vector<GrpArr>&,
           const FiniteAbelianGroup&,
           const FiniteAbelianGroup&);

// accessors
  GrpArr operator*(const GrpArr&) const;

  GrpNbr operator*(GrpNbr) const;
};

} // |namespace abelian|

} // |namespace atlas|

#endif