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

/magnus/back_end/AProducts/include/APwithOneRelatorRep.h

Go to the documentation of this file.
00001 /*
00002  * $Id: APwithOneRelatorRep.h,v 1.3 1996/10/17 22:44:40 pechkin Exp $
00003  */
00004 
00005 // Copyright (C) 1996 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 
00008 // Contents: Definition of the APwithOneRelatorRep class.
00009 //
00010 // Principal Authors: Eugene Paderin, Dmitry Pechkin
00011 //
00012 // Status: draft
00013 //
00014 // Revision History:
00015 //
00016 // Discussion:
00017 //
00018 // Bugs:
00019 //
00020 //
00021 // Special Notes:
00022 //
00023 //
00024 
00025 #ifndef _AMPRODUCT_WITH_ONE_RELATOR_REP_H_
00026 #define _AMPRODUCT_WITH_ONE_RELATOR_REP_H_
00027 
00028 #include "APofFreeGroups.h"
00029 
00030 struct APwithOneRelatorRep : AmalgProductOfFreeGroupsRep {
00031 
00032 // Constructors:
00033 
00034   // Copy constructor and operator= provided by compiler (do deep copy).
00035 
00036   APwithOneRelatorRep(const int dummy) 
00037     : AmalgProductOfFreeGroupsRep( FreeGroup(), FreeGroup(), 
00038                                   VectorOf<Word>(), VectorOf<Word>() )
00039   { }
00040   // special `default' constructor. It omits any chechkings.
00041   // It usally called on constructing an amalgamated product from
00042   // input stream, e.g like this:
00043   //  
00044   //  APwithOneRelator G;
00045   //  Chars errMesg = cin >> G;
00046   //  ...
00047     
00048 
00049   APwithOneRelatorRep(const FreeGroup& g1, const FreeGroup& g2,
00050                       const Word& gen1, const Word& gen2 );
00051   
00052   APwithOneRelatorRep(const FreeGroup& g1, const FreeGroup& g2,
00053                       const VectorOf<Word>& gen1, const VectorOf<Word>& gen2 )
00054     :   AmalgProductOfFreeGroupsRep( g1, g2, gen1, gen2 ) 
00055   {
00056     #if ( SAFETY > 0 )
00057      if( gen1.length() != 1 || gen2.length() != 1 )
00058       error("Constructing APwithOneRelator object with non-cyclic subgroups.");
00059     #endif
00060   }
00061 
00062   APwithOneRelatorRep(const SGofFreeGroup& sg1, const SGofFreeGroup& sg2)
00063     : AmalgProductOfFreeGroupsRep( sg1, sg2 ) 
00064   {
00065     #if ( SAFETY > 0 )
00066      if( sg1.generators().length() != 1 || sg2.generators().length() != 1 )
00067       error("Constructing APwithOneRelator object with non-cyclic subgroups.");
00068     #endif
00069   }
00070 
00071   // Destructor provided by compiler
00072 
00073 // Accessors / Manipulators:
00074 
00075   Word assocWord(int i) const { return assocSubgroup[i].generators()[0]; }
00076   // Provided that amalgamating condition is a = b, returns a or b.
00077 
00078 //
00079 // Representation methods:
00080 //
00081 
00082   PureRep* clone( ) const { return new APwithOneRelatorRep(*this); }
00083   // Overrides FGGroupRep::clone()
00084 
00085   static const Type theAPwithOneRelatorType;
00086 
00087   static Type type( ) { return theAPwithOneRelatorType; }
00088   // Dominates AmalgProductOfFreeGroupsRep::type()
00089 
00090   Type actualType( ) const { return type(); }
00091   // Overrides AmalgProductOfFreeGroupsRep::actualType();
00092 
00093 
00094 //
00095 // Methods dealing with the properties of the group:
00096 //
00097 
00098   Trichotomy isHyperbolic() const;
00099   // Overrides AmalgProductOfFreeGroupsRep::isHyperbolic().
00100 
00101 //
00102 // I/O:
00103 //
00104 
00105   GroupRep* readFrom(istream&, Chars&) const;
00106   // Overrides AmalgProductOfFreeGroupsRep::readFrom().
00107 
00108 //
00109 // Methods dealing with group elements:
00110 //
00111 
00112   VectorOf<int> computeInvariants() const;
00113 
00114   void maximalRoot(const Word& w, Word& root, int& power) const;
00115 
00116   VectorOf<Word> centralizerOf(const Word& w) const;
00117 
00118   Trichotomy conjugacyProblem( const Word& u, const Word& v ) const {
00119     Word dummy;
00120     return conjugacyProblem(u,v,dummy);
00121   }
00122   // Overrides AmalgProductOfFreeGroupsRep::().
00123 
00124   Trichotomy conjugacyProblem(const Word& u, const Word& v, Word& conjugator)
00125     const;
00126   
00127 private:
00128   // These methods are used by maximalRoot. Don't use them directly anyway!!
00129   void maximalRoot_case1(const Word& w, Word& root, int& power) const;
00130   void maximalRoot_case2(const Word& w, Word& root, int& power) const;
00131   
00132   Word translateToAnotherPresentation(const Word& w, const Word& aConjInv, 
00133                                       const Word& bConjInv) const;
00134 
00135   Trichotomy conjugacyProblem_reduced(const Word& u, const Word& v, 
00136                                       Word& conjugator) const;
00137 
00138   Trichotomy conjugacyProblem_case1(const Word& u, const Word& v, 
00139                                     Word& conjugator) const;
00140   // Conjugacy problem for special case: amalgamated words are cyclically
00141   // reduced, and every of u, v belongs to a factor
00142 
00143   Trichotomy conjugacyProblem_case2(VectorOf<Word>& uDec, VectorOf<Word>& vDec,
00144                                     Word& conjugator) const;
00145   // Conjugacy problem for special case: amalgamated words are cyclically
00146   // reduced, and length of u is greater than 1.
00147 
00148 // Data members:
00149 
00150 };
00151 
00152 #endif
00153 
00154 
00155 

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