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

/magnus/back_end/AProducts/include/SubgroupOfOneRelatorGroup.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: SubgroupOfOneRelatorGroup.h,v 1.3 1998/01/06 20:04: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: Interface of class SubgroupOfIOneRelatorGroup.
00009 //
00010 //            
00011 // Principal Author: Dmitry Pechkin
00012 //
00013 // Status: under trial.
00014 //
00015 // Revision History:
00016 //
00017 //  97/02/13 @dp added method
00018 //               bool pureContainmentProblem( const Word& u ) const;
00019 //
00020 // TO DO:
00021 //
00022 //
00023 
00024 #ifndef __SUBGROUP_ONE_RELATOR_GROUP_H__
00025 #define __SUBGROUP_ONE_RELATOR_GROUP_H__
00026 
00027 
00028 #include "OneRelatorGroup.h"
00029 #include "OneRelatorGroupWithTorsion.h"
00030 
00031 
00032 
00033 class ORGSubgroup {
00034 
00035 public:
00036 
00037   ///////////////////////////////////////////////////////
00038   //                                                   //
00039   //  Constructors / Destructor                        //
00040   //                                                   //
00041   ///////////////////////////////////////////////////////
00042 
00043   ORGSubgroup( const VectorOf<Word>& gens );
00044 
00045   virtual ~ORGSubgroup( ) { }
00046 
00047 
00048   virtual ORGSubgroup *copy( ) const = 0;
00049 
00050   ///////////////////////////////////////////////////////
00051   //                                                   //
00052   //  Accessors / Modifiers                            //
00053   //                                                   //
00054   ///////////////////////////////////////////////////////
00055 
00056   virtual const OneRelatorGroup& parentGroup( ) const = 0;
00057 
00058   const VectorOf<Word>& generators() const { return theGenerators; }
00059 
00060   ///////////////////////////////////////////////////////
00061   //                                                   //
00062   //  Methods which deal with subgroup structure       //
00063   //                                                   //
00064   ///////////////////////////////////////////////////////
00065 
00066   bool isMagnusSubgroup( ) const;
00067 
00068   ///////////////////////////////////////////////////////
00069   //                                                   //
00070   //  Methods which deal with group elements           //
00071   //                                                   //
00072   ///////////////////////////////////////////////////////
00073 
00074   virtual bool contains( const Word& w ) const = 0;
00075 
00076   virtual Word rewriteFromGroupToSubgroupGenerators( const Word& w ) const = 0 ;
00077 
00078   Word rewriteFromSubgroupToGroupGenerators( const Word& w ) const;
00079 
00080   bool lexicallyContains( const Word& w ) const;
00081   bool lexicallyContains( const Word& w, Word& wInBasis ) const;
00082 
00083   virtual bool operator == ( const ORGSubgroup& S ) const {
00084     return ( theGenerators == S.theGenerators ? true : false );
00085   }
00086 
00087   /////////////////////////////////////////////////////////////////////////
00088   //                                                                     //
00089   // I/O routines:                                                       //
00090   //                                                                     //
00091   /////////////////////////////////////////////////////////////////////////
00092 
00093   friend ostream& operator << ( ostream& ostr, const ORGSubgroup& S ) {
00094     S.printOn( ostr );
00095     return ostr;
00096   }
00097 
00098   /////////////////////////////////////////////////////////////////////////
00099   //                                                                     //
00100   // IPC tools:                                                          //
00101   //                                                                     //
00102   /////////////////////////////////////////////////////////////////////////
00103 
00104   friend ostream& operator < ( ostream& ostr, const ORGSubgroup& S ) {
00105     S.write( ostr );
00106     return ostr;
00107   }
00108 
00109   friend istream& operator > ( istream& istr, ORGSubgroup& S ) {
00110     S.read( istr );
00111     return istr;
00112   }
00113 
00114 protected:
00115 
00116   /////////////////////////////////////////////////////////////////////////
00117   //                                                                     //
00118   // IPC tools:                                                          //
00119   //                                                                     //
00120   /////////////////////////////////////////////////////////////////////////
00121 
00122   virtual void write( ostream& ostr ) const;
00123   virtual void read( istream& istr );
00124 
00125 private:
00126 
00127   /////////////////////////////////////////////////////////////////////////
00128   //                                                                     //
00129   // I/O routines:                                                       //
00130   //                                                                     //
00131   /////////////////////////////////////////////////////////////////////////
00132 
00133   virtual void printOn( ostream& ostr ) const;
00134 
00135   // data members:
00136 
00137   VectorOf<Word> theGenerators;
00138 };
00139 
00140 
00141 class SubgroupOfOneRelatorGroup : public ORGSubgroup
00142 {
00143 
00144 public:
00145 
00146   ///////////////////////////////////////////////////////
00147   //                                                   //
00148   //  Constructors                                     //
00149   //                                                   //
00150   ///////////////////////////////////////////////////////
00151 
00152 
00153   SubgroupOfOneRelatorGroup( const OneRelatorGroup& G,
00154                              const VectorOf<Word>& gens );
00155 
00156   ORGSubgroup *copy( ) const { return new SubgroupOfOneRelatorGroup( *this ); }
00157 
00158   ///////////////////////////////////////////////////////
00159   //                                                   //
00160   //  Accessors / Modifiers                            //
00161   //                                                   //
00162   ///////////////////////////////////////////////////////
00163 
00164   const OneRelatorGroup& parentGroup() const { return theParentGroup; }
00165 
00166   ///////////////////////////////////////////////////////
00167   //                                                   //
00168   //  Methods which deal with subgroup structure       //
00169   //                                                   //
00170   ///////////////////////////////////////////////////////
00171 
00172   ///////////////////////////////////////////////////////
00173   //                                                   //
00174   //  Methods which deal with group elements           //
00175   //                                                   //
00176   ///////////////////////////////////////////////////////
00177 
00178   bool contains( const Word& w ) const;
00179   // Overrides pure-virtual ORGSubgroup::contains().
00180 
00181   bool contains( const Word& w, bool keepDetails ) const;
00182 
00183   Word rewriteFromGroupToSubgroupGenerators( const Word& w ) const;
00184   // Overrides pure-virtual ORGSubgroup::rewriteFromGroupToSubgroupGenerators().
00185 
00186   ProductOfRelatorConjugates getIdentityProductDecomposition( const Word& w ) const;
00187 
00188   SubgroupOfOneRelatorGroup join( const SubgroupOfOneRelatorGroup& sg ) const;
00189   
00190   // Inherited from ORGSubgroup: 
00191   //   bool lexicallyContains( const Word& w ) const;
00192   //   bool lexicallyContains( const Word& w, Word& wInBasis ) const;
00193 
00194   
00195   bool operator == ( const SubgroupOfOneRelatorGroup& S ) const {
00196     if( theParentGroup == S.theParentGroup )
00197       return true;
00198     return ORGSubgroup::operator==(S);
00199   }
00200   // Overrides virtual ORGSubgroup::operator==().
00201 
00202 private:
00203 
00204   /////////////////////////////////////////////////////////////////////////
00205   //                                                                     //
00206   // I/O routines:                                                       //
00207   //                                                                     //
00208   /////////////////////////////////////////////////////////////////////////
00209 
00210   /////////////////////////////////////////////////////////////////////////
00211   //                                                                     //
00212   // IPC tools:                                                          //
00213   //                                                                     //
00214   /////////////////////////////////////////////////////////////////////////
00215 
00216   void write( ostream& ostr ) const;
00217   // Overrides virtual ORGSubgroup::write().
00218   void read( istream& istr ); 
00219   // Overrides virtual ORGSubgroup::read().
00220  
00221 private:
00222 
00223   // data members:
00224 
00225   OneRelatorGroup theParentGroup;
00226   
00227   //
00228   // 
00229   //
00230 
00231   struct ContainmentProblemData 
00232   {
00233     Word wordInParentGroupGenerators;
00234     bool inSubgroup;
00235     Word wordInSubgroupGenerators;
00236     ProductOfRelatorConjugates idProductDeco;
00237     bool keepDetails;
00238     
00239     ContainmentProblemData() 
00240       : wordInParentGroupGenerators( ), inSubgroup( true ),
00241         wordInSubgroupGenerators( ), idProductDeco( ),
00242         keepDetails( false ) { }
00243     
00244     ContainmentProblemData( const Word& w, bool f, const Word& u, bool keep_details,
00245                             const ProductOfRelatorConjugates& prodDeco ) 
00246       : wordInParentGroupGenerators(w), inSubgroup(f),
00247         wordInSubgroupGenerators(u), idProductDeco( prodDeco ),
00248         keepDetails( keep_details ) { }
00249   };
00250   
00251   ContainmentProblemData containsResult;
00252 
00253   void setContainmentProblemData( const Word& w, bool in_subgroup, 
00254                                   const Word& wInBasis, bool keepDetails, 
00255                                   const ProductOfRelatorConjugates& product ) const;
00256 
00257   bool subgroupsDecomposition(const Word& w, 
00258                               const SubgroupOfOneRelatorGroup& T,
00259                               const SubgroupOfOneRelatorGroup& A,
00260                               Word& t_part, Word& a_part,
00261                               const bool keepDetails, 
00262                               ProductOfRelatorConjugates& prodDeco ) const;
00263   
00264   // define theParentGroup as HNN-extension of G_0 group.
00265   // define subgroup T (theGenerators) in G as HNN-extension of T_0 in G_0 
00266 
00267   bool pureContainmentProblem( const Word& u, bool keepDetails = false ) const;
00268 
00269   class MagnusBreakdown buildMagnusBreakdown( const Word& w, 
00270     SetOf<Generator>& subGens ) const;
00271 };
00272 
00273 
00274 class SubgroupOfORGroupWithTorsion : public ORGSubgroup
00275 {
00276 
00277 public:
00278 
00279   ///////////////////////////////////////////////////////
00280   //                                                   //
00281   //  Constructors                                     //
00282   //                                                   //
00283   ///////////////////////////////////////////////////////
00284 
00285 
00286   SubgroupOfORGroupWithTorsion( const OneRelatorGroupWithTorsion& G,
00287                                 const VectorOf<Word>& gens );
00288 
00289   ORGSubgroup *copy( ) const { return new SubgroupOfORGroupWithTorsion( *this ); }
00290 
00291   ///////////////////////////////////////////////////////
00292   //                                                   //
00293   //  Accessors / Modifiers                            //
00294   //                                                   //
00295   ///////////////////////////////////////////////////////
00296 
00297   const OneRelatorGroup& parentGroup() const { return theParentGroup; }
00298   // Overrides pure-virtual ORGSUbgroup::parentGroup().
00299 
00300   ///////////////////////////////////////////////////////
00301   //                                                   //
00302   //  Methods which deal with subgroup structure       //
00303   //                                                   //
00304   ///////////////////////////////////////////////////////
00305 
00306   ///////////////////////////////////////////////////////
00307   //                                                   //
00308   //  Methods which deal with group elements           //
00309   //                                                   //
00310   ///////////////////////////////////////////////////////
00311 
00312   bool contains( const Word& w ) const;
00313   // Overrides virtual ORGSubgroup::contains().
00314 
00315   Word rewriteFromGroupToSubgroupGenerators( const Word& w ) const;
00316   // Overrides pure-virtual ORGSubgroup::rewriteFromGroupToSubgroupGenerators().
00317 
00318   bool operator == ( const SubgroupOfORGroupWithTorsion& S ) const {
00319     if( theParentGroup == S.theParentGroup )
00320       return true;
00321     return ORGSubgroup::operator==(S);
00322   }
00323   // Overrides virtual ORGSubgroup::operator==().
00324 
00325 private:
00326 
00327   /////////////////////////////////////////////////////////////////////////
00328   //                                                                     //
00329   // I/O routines:                                                       //
00330   //                                                                     //
00331   /////////////////////////////////////////////////////////////////////////
00332 
00333   /////////////////////////////////////////////////////////////////////////
00334   //                                                                     //
00335   // IPC tools:                                                          //
00336   //                                                                     //
00337   /////////////////////////////////////////////////////////////////////////
00338 
00339   void write( ostream& ostr ) const;
00340   void read( istream& istr );
00341 
00342   // data members:
00343 
00344   bool contains( const Word& w, Word& wInBasis ) const;
00345 
00346   OneRelatorGroupWithTorsion theParentGroup;
00347 };
00348 
00349 
00350 #endif

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