Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

/magnus/back_end/Map/include/Automorphism.h

Go to the documentation of this file.
00001 // Copyright (C) 1995 The New York Group Theory Cooperative
00002 // See magnus/doc/COPYRIGHT for the full notice.
00003 
00004 // Contents: Definition of the Automorphism and AutomorphismRep class.
00005 //
00006 // Principal Authors: Eugene Paderin, Dmitry Pechkin
00007 //
00008 // Status: in progress
00009 //
00010 // Revision History:
00011 //
00012 // Special Notes:
00013 //
00014 // * The class is primarily designed and used for solving
00015 //   quadratic equations (in free groups).
00016 //
00017 // * The class methods need advanced consistency checking and
00018 //   more manipulation with Map properties.
00019 //
00020 
00021 #ifndef _AUTOMORPHISM_H_
00022 #define _AUTOMORPHISM_H_
00023 
00024 #include "Endomorphism.h"
00025 #include "FreeGroup.h"
00026 
00027 //---------------------- Automorphism ---------------------------//
00028 
00029 
00030 class Automorphism : public Endomorphism {
00031 
00032 public:
00033 
00034 ////////////////////////////////////////////////////////////////////
00035 //                                                                //
00036 // Constructors                                                   //
00037 //                                                                //
00038 ////////////////////////////////////////////////////////////////////
00039 
00040   Automorphism( const FGGroup& dom) : Endomorphism(dom) { makeIdentity(); }
00041         // make trivial Automorphism on given group
00042 
00043         Automorphism( const FGGroup& dom,       const VectorOf<Word>& generatingImages )
00044                 : Endomorphism(dom,generatingImages) { }
00045         // an Automorphism with explicit generatingImages
00046 
00047         Automorphism(FGGroup& dom, Generator x, Word& w) : Endomorphism(dom)
00048         {
00049                 makeIdentity();
00050                 setGeneratingImages(x,w);
00051         }
00052         // maps x to w, the others to themselves
00053 
00054         Automorphism(FGGroup& dom, Word& w) : Endomorphism(dom)
00055         {
00056                 for(int i=0; i< dom.numberOfGenerators(); i++) {
00057                         Word x = Generator(i+1);
00058                         setGeneratingImages(i, x.conjugateBy(w));
00059                 }
00060         }
00061         // An `inner' endomorphism, i.e., x -> x^w for all generators x.
00062 
00063         Automorphism( const Map& m ) : Endomorphism(m) {}
00064   // cast construtor: to cast an arbitrary map as an automorphism.
00065   // NB. This rewraps the unchanged representation, hence is in general
00066   // only useful for casting a map known to be an actual automorphism.
00067 
00068         // copy constructor, operator=, and destructor supplied by compiler
00069 
00070 ////////////////////////////////////////////////////////////////////
00071 //                                                                //
00072 // Accessors / Modifiers                                          //
00073 //                                                                //
00074 ////////////////////////////////////////////////////////////////////
00075 
00076         // inherited from the base class
00077 
00078         // const FGGroup& domain( ) const;
00079         // const FGGroup& range( ) const;
00080         // const VectorOf<Word>& generatingImages( ) const;
00081         // Word generatingImages( int i ) const;
00082         // void setGeneratingImages( const VectorOf<Word>& gi );
00083         // void setGeneratingImages( int i, const Word& e  );
00084         // void setDomain( const FGGroup& g ); 
00085         // void setRange( const FGGroup& g );
00086         // void makeIdentity()
00087         // void reduceGenImages();
00088 
00089 ////////////////////////////////////////////////////////////////////
00090 //                                                                //
00091 // Mapping methods                                                //
00092 //                                                                //
00093 ////////////////////////////////////////////////////////////////////
00094 
00095         // inherited from the base class
00096 
00097         // friend CondParamLvalue<Map,Word,Generator>::operator Word ( ) const;
00098         // friend Word& CondParamLvalue<Map,Word,Generator>::operator =( const Word& ) const;
00099         // Word imageOf( const Word& w ) const;
00100         // Word imageOf( const Generator& g ) const;
00101         // CondParamLvalue<Map,Word,Generator> imageOf( const Generator& g );
00102         // Word operator()( const Word& w ) const;
00103         // Word operator()( const Generator& g ) const;
00104         // CondParamLvalue<Map,Word,Generator> operator()( const Generator& g );
00105         // computing images:
00106         // Elt evalImage( const Word& w ) const;
00107         // Elt postEvalImage( const Word& w ) const;
00108 
00109 // operations on maps:
00110 
00111         // Map& composeAfter( const Map& firstMap );
00112         // Map operator | ( const Map& secondEndo )
00113 
00114         Automorphism inverse() const {
00115                 #if SAFETY > 0
00116                 if( domain().actualType() != FreeGroup::type() )
00117                         error("Automorphism::inverse() supported for "
00118                               "automorphism of a free group only");
00119                 #endif
00120                 const VectorOf<Word>& images = look()->theGeneratingImages;
00121                 return Automorphism(domain(), ((const FreeGroup&)domain()).inverseAutomorphism(images) );
00122         }
00123 
00124 ////////////////////////////////////////////////////////////////////
00125 //                                                                //
00126 // Mapping properties                                             //
00127 //                                                                //
00128 ////////////////////////////////////////////////////////////////////
00129 
00130         // inherited from the base class:
00131 
00132         // Trichotomy extendsToHom( ) const;
00133         // Trichotomy isMono( ) const;
00134         // Trichotomy isEpi( ) const;
00135         // Trichotomy isIso( ) const;
00136         // Trichotomy isTrivialMap( ) const; // @stc impl. tmp.
00137 
00138 ////////////////////////////////////////////////////////////////////
00139 //                                                                //
00140 // Debugging stuff                                                //
00141 //                                                                //
00142 ////////////////////////////////////////////////////////////////////
00143 
00144 #ifdef DEBUG
00145 
00146         //friend int main( );
00147 
00148         bool consistent( ) {
00149                 const VectorOf<Word>& images = look()->theGeneratingImages;
00150                 return Endomorphism::consistent() &&
00151                        ((const FreeGroup&)domain()).isAutomorphism(images);
00152         }
00153 
00154 #endif
00155 
00156 };
00157 
00158 #endif
00159 

Generated at Tue Jun 19 09:49:36 2001 for Magnus Classes by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001