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

/magnus/back_end/AProducts/include/OneRelatorGroupWithTorsion.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: OneRelatorGroupWithTorsion.h,v 1.3 1998/05/14 19:44:03 bormotov 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 class OneRelatorGroupWithTorsion,
00009 //                               OneRelatorGroupWithTorsionRep.
00010 //
00011 // Principal Author: Dmitry Pechkin
00012 //
00013 // Status: in progress
00014 //
00015 // Revision History:
00016 //
00017 
00018 #ifndef _OR_GROUP_WITH_TORSION_H_
00019 #define _OR_GROUP_WITH_TORSION_H_
00020 
00021 #include "OneRelatorGroup.h"
00022 
00023 class OneRelatorGroupWithTorsionRep : public OneRelatorGroupRep
00024 {
00025 public:
00026 
00027   ///////////////////////////////////////////////////////
00028   //                                                   //
00029   //  Constructors                                     //
00030   //                                                   //
00031   ///////////////////////////////////////////////////////
00032         
00033   OneRelatorGroupWithTorsionRep( int ngens, const Word& relator );
00034   // To construct a group of given number of unnamed generators and
00035   // a given relator.
00036   
00037   OneRelatorGroupWithTorsionRep( const VectorOf<Chars>& gennames, 
00038                                  const Word& relator ); 
00039   // To construct a group with named generators, a given relator.  
00040 
00041   OneRelatorGroupWithTorsionRep( const FPGroup& G );
00042   
00043   // Copy ctor, operator= and dtor provided by compiler
00044 
00045 
00046   /////////////////////////////////////////////////////////////////////////
00047   //                                                                     //
00048   // Representation methods:                                             //
00049   //                                                                     //
00050   /////////////////////////////////////////////////////////////////////////
00051   
00052   PureRep* clone( ) const { return new OneRelatorGroupWithTorsionRep(*this); }
00053   // Overrides OneRelatorGroupRep::clone().
00054 
00055   static const Type theOneRelatorGroupWithTorsionType;
00056 
00057   static Type type( ) { return theOneRelatorGroupWithTorsionType; }
00058   // dominates OneRelatorGroupRep::type()
00059 
00060   Type actualType( ) const { return type(); }
00061   // overrides OneRelatorGroupRep::actualType();
00062 
00063   ///////////////////////////////////////////////////////
00064   //                                                   //
00065   //  Accessors / Modifiers                            //
00066   //                                                   //
00067   ///////////////////////////////////////////////////////
00068 
00069   ///////////////////////////////////////////////////////
00070   //                                                   //
00071   //  Methods dealing with group structure             //
00072   //                                                   //
00073   ///////////////////////////////////////////////////////
00074 
00075   Trichotomy isFreeProduct( ) const;
00076 
00077   ///////////////////////////////////////////////////////
00078   //                                                   //
00079   //  Methods which deal with subgroups structure      //
00080   //                                                   //
00081   ///////////////////////////////////////////////////////
00082 
00083   bool isProperMagnusSubgroup( const VectorOf<Generator>& gens ) const;
00084   // Returns true iff a subgroup generated by `gens' is a Magnus one.
00085 
00086   bool doesMagnusSubgroupContainElt( const VectorOf<Generator>& subgroup, 
00087     const Word& w, Word& wInSubgroupBasis ) const;
00088   // Determines whether the word is in the given Magnus subgroup
00089   // If it is true then it expresses the word in the generators of 
00090   // the subgroup.
00091 
00092   bool isPowerOfEltInMagnusSubgroup( const VectorOf<Generator>& subgroup, 
00093     const Word& w, Word& subgroupElt, int& powerOfElt ) const;
00094   // Determines whether the given word `w' is a power of an element of
00095   // the given Magnus subgroup.
00096 
00097   ///////////////////////////////////////////////////////
00098   //                                                   //
00099   //  Methods which deal with group elements           //
00100   //                                                   //
00101   ///////////////////////////////////////////////////////
00102 
00103   Trichotomy wordProblem( const Word& w, 
00104     ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
00105   // Solves word problem for the given word.
00106   // If the word is identity then it expressed as a product of 
00107   // relator conjugates.
00108 
00109   Trichotomy wordProblem( const Word& w ) const;
00110   // Overrides pseudo-virtual OnerelatorGroupRep::wordProblem(const Word&).
00111 
00112   Trichotomy conjugacyProblem( const Word& u, const Word& v, Word& conjugator )
00113     const;
00114   // Solves the conjugacy problem. If the words are conjugated then it returns 
00115   // the conjugator of first word to get the second one.
00116 
00117   Trichotomy conjugacyProblem( const Word& u, const Word& w ) const 
00118   {
00119     Word dummyConjugator;
00120     return conjugacyProblem( u, w, dummyConjugator );
00121   }
00122   // Overrides pseudo-virtual OnerelatorGroupRep::conjugacyProblem().
00123 
00124   Trichotomy maximalRoot( const Word& w, Word& maxRoot, int& maxPower ) const;
00125   // Finds maximal root of given word w. The root word is stored in `maxRoot',
00126   // and its power in `maxPower'. If the function returns value `donknow'
00127   // the answer is cannot be determined.
00128 
00129   int powerOfElt(const Word& w, Word& st, Word& x, 
00130                  ProductOfRelatorConjugates& productOfRelatorConjugates) const;
00131 
00132   VectorOf<Word> centralizerOfElt( const Word& w ) const;
00133   // Computes a centralizer of the given element. Returns subgroup generated by
00134   // a single element (maximal root of w)  always. 
00135   // This fact is proved by B.B.Newman.
00136 
00137   ///////////////////////////////////////////////////////
00138   //                                                   //
00139   //  I/O                                              //
00140   //                                                   //
00141   ///////////////////////////////////////////////////////
00142 
00143   GroupRep* readFrom( istream& istr, Chars& errMesg ) const;
00144 
00145   ///////////////////////////////////////////////////////
00146   //                                                   //
00147   //  IPC tools:                                       //
00148   //                                                   //
00149   ///////////////////////////////////////////////////////
00150 
00151   ///////////////////////////////////////////////////////
00152   //                                                   //
00153   //  Data:                                            //
00154   //                                                   //
00155   ///////////////////////////////////////////////////////
00156 
00157 };
00158 
00159 class  OneRelatorGroupWithTorsion 
00160   : public DerivedObjectOf<OneRelatorGroup,OneRelatorGroupWithTorsionRep>
00161 {
00162 public:
00163 
00164   /////////////////////////////////////////////////////////////////////////
00165   //                                                                     //
00166   //  Constructors:                                                      //
00167   //                                                                     //
00168   /////////////////////////////////////////////////////////////////////////
00169 
00170   OneRelatorGroupWithTorsion( int ngens, const Word& relator ) 
00171     : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
00172         new OneRelatorGroupWithTorsionRep( ngens, relator ) 
00173       ) {} 
00174   // To construct a group of given number of unnamed generators and
00175   // a given relator.
00176   
00177   OneRelatorGroupWithTorsion( const VectorOf<Chars>& gennames, 
00178                               const Word& relator )
00179     : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
00180         new OneRelatorGroupWithTorsionRep( gennames, relator ) 
00181       ) {} 
00182   // To construct a group with named generators, a given relator.  
00183 
00184   OneRelatorGroupWithTorsion( const FPGroup& G )
00185     : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
00186         new OneRelatorGroupWithTorsionRep( G )
00187       ) {} 
00188   
00189   // Copy constructor, operator=, and destructor supplied by compiler.
00190 
00191   /////////////////////////////////////////////////////////////////////////
00192   //                                                                     //
00193   //  Accessors:                                                         //
00194   //                                                                     //
00195   /////////////////////////////////////////////////////////////////////////
00196 
00197   /////////////////////////////////////////////////////////////////////////
00198   //                                                                     //
00199   //  Methods and operators which deal with the group:                   //
00200   //                                                                     //
00201   /////////////////////////////////////////////////////////////////////////
00202   
00203   /////////////////////////////////////////////////////////////////////////
00204   //                                                                     //
00205   //  Methods and operators which deal with subgroups:                   //
00206   //                                                                     //
00207   /////////////////////////////////////////////////////////////////////////
00208 
00209   bool isProperMagnusSubgroup( const VectorOf<Generator>& subgroup ) const
00210   {
00211     return look()->isProperMagnusSubgroup( subgroup );
00212   }
00213   // Returns true iff a subgroup generated by `gens' is a Magnus one.
00214 
00215   bool doesMagnusSubgroupContainElt( const VectorOf<Generator>& subgroup, 
00216     const Word& w, Word& wInSubgroupBasis ) const
00217   {
00218     return look()->doesMagnusSubgroupContainElt( subgroup,w,wInSubgroupBasis );
00219   }
00220   // Determines whether the word is in the given Magnus subgroup
00221   // If it is true then it expresses the word in the generators of 
00222   // the subgroup.
00223 
00224   bool isPowerOfEltInMagnusSubgroup( const VectorOf<Generator>& subgroup, 
00225     const Word& w, Word& subgroupElt, int& powerOfElt ) const
00226   {
00227     return look()->isPowerOfEltInMagnusSubgroup( subgroup, w, subgroupElt, 
00228                                                  powerOfElt );
00229   }
00230   // Determines whether the given word `w' is a power of an element of
00231   // the given Magnus subgroup.
00232 
00233   /////////////////////////////////////////////////////////////////////////
00234   //                                                                     //
00235   //  Methods which deal with group elements:                            //
00236   //                                                                     //
00237   /////////////////////////////////////////////////////////////////////////
00238 
00239   // Trichotomy wordProblem( const Word& w ) const;
00240   // Overrides pseudo-virtual OneRelatorGroup::wordProblem().
00241 
00242   Trichotomy wordProblem( const Word& w, 
00243     ProductOfRelatorConjugates& productOfRelatorConjugates ) const 
00244   {
00245     return look()->wordProblem( w, productOfRelatorConjugates );
00246   }
00247   // Solves word problem for the given word.
00248   // If the word is identity then it expressed as a product of 
00249   // relator conjugates.
00250 
00251   // @dp will be implemented soon. 
00252   // Trichotomy conjugacyProblem( const Word& u, const Word& w ) const;
00253   // Overrides pseudo-virtual OnerelatorGroupRep::conjugacyProblem().
00254 
00255   Trichotomy conjugacyProblem( const Word& u, const Word& v, Word& conjugator)
00256     const
00257   {
00258     return look()->conjugacyProblem( u, v, conjugator );
00259   }
00260   // Solves the conjugacy problem. If the words are conjugated then it returns 
00261   // the conjugator of first word to get the second one.
00262 
00263 
00264   Trichotomy maximalRoot( const Word& w, Word& maxRoot, int& maxPower ) const 
00265   {
00266     return look()->maximalRoot( w, maxRoot, maxPower );
00267   }
00268   // Finds maximal root of given word w. The root word is stored in `maxRoot',
00269   // and its power in `maxPower'. If the function returns value `donknow'
00270   // the answer is cannot be determined.
00271 
00272 
00273   int powerOfElt(const Word& w, Word& st, Word& x, 
00274                  ProductOfRelatorConjugates& productOfRelatorConjugates ) const
00275   {
00276     return look()->powerOfElt( w, st, x, productOfRelatorConjugates );
00277   }
00278   // Return finite order or 0 iff the element of infinite order.
00279   // If the one is of finite order then decomposition of w is
00280   //    w = (s^t)^x * R1^c1 * ... * Rm^cm
00281   // where G = < X | r = s^k = 1 > is the given group, 
00282   //       Ri is r or r^-1, st = s^t.
00283   
00284 
00285   VectorOf<Word> centralizerOfElt( const Word& w ) const {
00286     return look()->centralizerOfElt( w );
00287   }
00288   // Computes a centralizer of the given element. Returns subgroup generated by
00289   // a single element (maximal root of w) always. 
00290   // This fact is proved by B.B.Newman.
00291 
00292   /////////////////////////////////////////////////////////////////////////
00293   //                                                                     //
00294   // I/O:                                                                //
00295   //                                                                     //
00296   /////////////////////////////////////////////////////////////////////////
00297 
00298   /////////////////////////////////////////////////////////////////////////
00299   //                                                                     //
00300   // IPC tools:                                                          //
00301   //                                                                     //
00302   /////////////////////////////////////////////////////////////////////////
00303 
00304 protected:
00305 
00306   /////////////////////////////////////////////////////////////////////////
00307   //                                                                     //
00308   // Protected functions:                                                //
00309   //                                                                     //
00310   /////////////////////////////////////////////////////////////////////////
00311 
00312   OneRelatorGroupWithTorsion( OneRelatorGroupWithTorsionRep *newrep ) 
00313     : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>(newrep){}
00314 
00315 };
00316 
00317 #endif

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