BKLRightNormalForm.h

Go to the documentation of this file.

// Copyright (C) 2005 Alexander Ushakov
// Contents: Definition of class BKLRightNormalForm
//
// Principal Authors: Alexander Ushakov
//
// Revision History:
//

#ifndef _BKLRightNormalForm_h_
#define _BKLRightNormalForm_h_

#include "tuples.h"
#include "Permutation.h"

#include "vector"
#include "list"
using namespace std ;

class BraidGroup;
class Word;


#define ERROR_EXISTS

//---------------------------------------------------------------------------//
//--------------------------- BKLRightNormalForm ----------------------------//
//---------------------------------------------------------------------------//



class BKLRightNormalForm
{
 public:
  

  typedef triple< int , int , list< Permutation > > NF;
  
  //                                                     //
  //  Constructors:                                      //
  //                                                     //

 public:
  
  BKLRightNormalForm( ) : theRank( 0 ) { 
#ifdef ERROR_EXISTS
    exit(1);
#endif
  }
    
    
  BKLRightNormalForm( const BKLRightNormalForm& bkl ) : 
    theOmegaPower( bkl.theOmegaPower ) ,
    theDecomposition( bkl.theDecomposition ) { 
#ifdef ERROR_EXISTS
    exit(1);
#endif
}

    
  BKLRightNormalForm( int rank , int power , const list< Permutation >& decomp ) : 
    theRank( rank ) ,
    theOmegaPower( power ) ,
    theDecomposition( decomp ) { 
#ifdef ERROR_EXISTS
    exit(1);
#endif
}
  
    
  BKLRightNormalForm( const BraidGroup& G , const Word& w );

  
  //                                                     //
  //  Operatos:                                          //
  //                                                     //

 public:

  BKLRightNormalForm& operator = ( const BKLRightNormalForm& bkl ) {
    theRank = bkl.theRank;
    theOmegaPower = bkl.theOmegaPower;
    theDecomposition = bkl.theDecomposition;
  }

  BKLRightNormalForm& operator = ( const NF& bkl ) {
    theRank = bkl.first;
    theOmegaPower = bkl.second;
    theDecomposition = bkl.third;
  }

  BKLRightNormalForm operator- ( ) const { return inverse( ); }
  
  
  BKLRightNormalForm operator* ( const BKLRightNormalForm& bkl ) const { return multiply( bkl ); }


  bool operator ==( const BKLRightNormalForm& bkl ) const;
  bool operator !=( const BKLRightNormalForm& bkl ) const;
  bool operator < ( const BKLRightNormalForm& bkl ) const;


  //                                                     //
  //  Accessors:                                         //
  //                                                     //

 public:
  
  int getPower( ) const { return theOmegaPower; }


  const list< Permutation >& getDecomposition( ) const { return theDecomposition; }
  

  operator NF( ) const { return NF( theRank , theOmegaPower , theDecomposition ); }


  bool isTrivial( ) const { return theOmegaPower==0 && theDecomposition.size()==0; }

  
  static Permutation getTinyTwistPermutation( int theIndex ) {
    Permutation result( theIndex );
    for( int i=0 ; i<theIndex ; ++i )
      result[i] = (i+theIndex-1)%theIndex;
    return result;
  }


  Word getWord( ) const;

  
  static void adjustDecomposition( int rank ,
                                   int& power ,
                                   list<Permutation>& decomp );
  // this function transforms any (reasonable) decomposition
  // to a decomposition of a normal form 


  //                                                     //
  //  Modifiers:                                         //
  //                                                     //

 public:
  
  inline void setPower( int p ) { theOmegaPower = p; }

  inline void setDecomposition( const list< Permutation >& d ) { theDecomposition = d; }
  
  //                                                     //
  //  Internal functions:                                //
  //                                                     //

 private:

  enum   transformationResult { TWO_MULTIPLIERS , ONE_MULTIPLIER , NO_CHANGE };
  static transformationResult transform ( int theIndex , Permutation& p1 , Permutation& p2 );

  BKLRightNormalForm inverse( ) const;
  
  
  BKLRightNormalForm multiply( const BKLRightNormalForm& bkl ) const;


  //                                                     //
  //  Data members:                                      //
  //                                                     //

 private:


  int theRank;
  
  
  int theOmegaPower;


  list< Permutation > theDecomposition;
  
};


ostream& operator << ( ostream& os, const BKLRightNormalForm& rep );


#endif