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

/magnus/back_end/SMApps/include/HNNProblems.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: HNNProblems.h,v 1.4 2000/02/10 00:01:04 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: Declarations of classes 
00009 // 
00010 //
00011 // Principal Author: Dmitry Pechkin
00012 //
00013 // Status: in progress
00014 //
00015 // Revision History:
00016 //
00017 
00018 
00019 #ifndef _HNN_PROBLEMS_H_
00020 #define _HNN_PROBLEMS_H_
00021 
00022 #include "IsFreeProblem.h"
00023 #include "fastProblems.h"
00024 
00025 // ========================================================================= //
00026 // ============================= FASTPROBLEMS.H ============================ //
00027 // ========================================================================= //
00028 
00029 class MakeHNNExtOfFreeGroup : public FastComputation
00030 {
00031 public:
00032 
00033   MakeHNNExtOfFreeGroup( const SMFPGroup& G,
00034                          const class SMSubgroup& S1, const class SMSubgroup& S2 )
00035     : theStableLetter( "t" /*stableLetter*/ ), 
00036       subgroup1( S1 ), subgroup2( S2 )
00037   { }
00038 
00039   void takeControl( );              // overrides ComputationManager
00040     
00041 private:
00042     
00043   const Chars theStableLetter;
00044   const class SMSubgroup& subgroup1;
00045   const class SMSubgroup& subgroup2;
00046 };
00047 
00048 
00049 class HNNofFreeGroup_IsTrivial : public FastComputation 
00050 {
00051 public:
00052 
00053   HNNofFreeGroup_IsTrivial( const SMFPGroup& G )
00054     : group( G )
00055   { }
00056 
00057   void takeControl( );
00058 
00059 private:
00060 
00061   const SMFPGroup& group;
00062 };
00063 
00064 class HNNofFreeGroup_IsFinite : public FastComputation 
00065 {
00066 public:
00067 
00068   HNNofFreeGroup_IsFinite( const SMFPGroup& G )
00069     : group( G )
00070   { }
00071 
00072   void takeControl( );
00073 
00074 private:
00075 
00076   const SMFPGroup& group;
00077 };
00078 
00079 class HNNofFreeGroup_IsAbelian : public FastComputation 
00080 {
00081 public:
00082   HNNofFreeGroup_IsAbelian( const SMFPGroup& G )
00083     : group( G )
00084   { }
00085 
00086   void takeControl( );
00087 
00088 private:
00089 
00090   const SMFPGroup& group;
00091 };
00092 
00093 
00094 class HNNofFreeGroup_ConjugacyProblem : public FastComputation 
00095 {
00096 public:
00097 
00098   HNNofFreeGroup_ConjugacyProblem( const SMWord& x, const SMWord& y )
00099     : word1( x ), word2( y ) 
00100   { }
00101 
00102   void takeControl( );
00103 
00104 private:
00105 
00106   const SMWord& word1;
00107   const SMWord& word2;
00108 };
00109 
00110 class HNNofFreeGroup_WordProblem : public FastComputation 
00111 {
00112 public:
00113 
00114   HNNofFreeGroup_WordProblem( const SMWord& x ) : word( x ) { }
00115 
00116   void takeControl( );
00117 
00118 private:
00119 
00120   const SMWord& word;
00121 };
00122 
00123 class HNNofFreeGroup_ReducedForm : public FastComputation 
00124 {
00125 public:
00126 
00127   HNNofFreeGroup_ReducedForm( const SMWord& x ) : word( x ) { }
00128 
00129   void takeControl( );
00130 
00131 private:
00132 
00133   const SMWord& word;
00134 };
00135 
00136 class HNNofFreeGroup_NormalForm : public FastComputation 
00137 {
00138 public:
00139 
00140   HNNofFreeGroup_NormalForm( const SMWord& x ) : word( x ) { }
00141 
00142   void takeControl( );
00143 
00144 private:
00145 
00146   const SMWord& word;
00147 };
00148 
00149 class HNNofFreeGroup_CyclicallyReducedForm : public FastComputation 
00150 {
00151 public:
00152 
00153   HNNofFreeGroup_CyclicallyReducedForm( const SMWord& x ) : word( x ) { }
00154 
00155   void takeControl( );
00156 
00157 private:
00158 
00159   const SMWord& word;
00160 };
00161 
00162 class HNNofFreeGroup_IsProperPowerOfSecond : public FastComputation 
00163 {
00164 public:
00165 
00166   HNNofFreeGroup_IsProperPowerOfSecond( const SMWord& x, const SMWord& y )
00167     : word1( x ), word2( y )
00168   { }
00169 
00170   void takeControl( );
00171 
00172 private:
00173 
00174   const SMWord& word1;
00175   const SMWord& word2;
00176 };
00177 
00178 class HNNofFreeGroup_IsProperPower : public FastComputation 
00179 {
00180 public:
00181 
00182   HNNofFreeGroup_IsProperPower( const SMWord& x ) : word( x ) { }
00183 
00184   void takeControl( );
00185 
00186 private:
00187 
00188   const SMWord& word;
00189 };
00190 
00191 class HNNofFreeGroup_MaximalRoot : public FastComputation 
00192 {
00193 public:
00194 
00195   HNNofFreeGroup_MaximalRoot( const SMWord& x ) : word( x ) { }
00196 
00197   void takeControl( );
00198 
00199 private:
00200 
00201   const SMWord& word;
00202 };
00203 
00204 
00205 class HNNofFreeGroup_AreEqual : public FastComputation 
00206 {
00207 public:
00208 
00209   HNNofFreeGroup_AreEqual( const SMWord& x, const SMWord& y )
00210     : word1( x ), word2( y )
00211   { }
00212 
00213   void takeControl( );
00214 
00215 private:
00216 
00217   const SMWord& word1;
00218   const SMWord& word2;
00219 };
00220 
00221 
00222 class HNNofFreeGroup_IsSGTrivial : public FastComputation 
00223 {
00224 public:
00225 
00226   HNNofFreeGroup_IsSGTrivial( const SMSubgroup& S )
00227     : subgroup( S )
00228   { }
00229 
00230   void takeControl( );
00231 
00232 private:
00233 
00234   const SMSubgroup& subgroup;
00235 };
00236 
00237 
00238 class HNNofFreeGroup_IsSGAbelian : public FastComputation 
00239 {
00240 public:
00241 
00242   HNNofFreeGroup_IsSGAbelian( const SMSubgroup& S )
00243     : subgroup( S )
00244   { }
00245 
00246   void takeControl( );
00247 
00248 private:
00249 
00250   const SMSubgroup& subgroup;
00251 };
00252 
00253 class CheckinHNNofFreeGroup : public FastComputation
00254 {
00255 public:
00256 
00257   CheckinHNNofFreeGroup( ) { }
00258 
00259   void takeControl( );              // overrides ComputationManager
00260 };
00261 
00262 // +++++++++++++++++++++++++++++ FASTPROBLEMS.H ++++++++++++++++++++++++++++ //
00263 
00264 
00265 
00266 /*
00267 // ---------------------- HNNofFreeIsFreeArcer --------------------------- //
00268 
00269 
00270 class HNNofFreeIsFreeArcer : public ARCer
00271 {
00272 public:
00273 
00274   /////////////////////////////////////////////////////////////////////////
00275   //                                                                     //
00276   // Constructors:                                                       //
00277   //                                                                     //
00278   /////////////////////////////////////////////////////////////////////////
00279 
00280   HNNofFreeIsFreeArcer( ComputationManager& boss ) 
00281     : ARCer( boss ), theAnswer( dontknow ), theGroup( 0 ) 
00282   { }
00283 
00284   ~HNNofFreeIsFreeArcer( );
00285 
00286 
00287   /////////////////////////////////////////////////////////////////////////
00288   //                                                                     //
00289   // Accessors:                                                          //
00290   //                                                                     //
00291   /////////////////////////////////////////////////////////////////////////
00292 
00293   void setArguments( const HNNExtOfFreeGroup& H );
00294 
00295   // Inherited from ARCer:
00296   // bool takeControl( );
00297 
00298   Trichotomy answer() const { return theAnswer; }
00299   
00300   /////////////////////////////////////////////////////////////////////////
00301   //                                                                     //
00302   // IPC interaction members:                                            //
00303   //                                                                     //
00304   /////////////////////////////////////////////////////////////////////////
00305 
00306   void runComputation( );
00307  
00308   void writeResults( ostream& ostr );
00309 
00310   void readResults( istream& istr );
00311 
00312 
00313 private:
00314 
00315   /////////////////////////////////////////////////////////////////////////
00316   //                                                                     //
00317   // Data Members:                                                       //
00318   //                                                                     //
00319   /////////////////////////////////////////////////////////////////////////
00320 
00321   HNNExtOfFreeGroup *theGroup;
00322   Trichotomy theAnswer;
00323 };
00324 */
00325 
00326 // --------------------------------------------------------------------- //
00327 // ------------------------- HNNofFreeIsFree --------------------------- //
00328 // --------------------------------------------------------------------- //
00329 
00330 
00331 class HNNofFreeIsFree : public ComputationManager
00332 {
00333 public:
00334 
00335   /////////////////////////////////////////////////////////////////////////
00336   //                                                                     //
00337   // Constructors:                                                       //
00338   //                                                                     //
00339   /////////////////////////////////////////////////////////////////////////
00340 
00341   HNNofFreeIsFree( class SMFPGroup& F );
00342 
00343   ~HNNofFreeIsFree();
00344     
00345   /////////////////////////////////////////////////////////////////////////
00346   //                                                                     //
00347   // Accessors:                                                          //
00348   //                                                                     //
00349   /////////////////////////////////////////////////////////////////////////
00350 
00351 
00352   /////////////////////////////////////////////////////////////////////////
00353   //                                                                     //
00354   // Front End Interfacing:                                              //
00355   //                                                                     //
00356   /////////////////////////////////////////////////////////////////////////
00357 
00358   void viewStructure(ostream& ostr) const;  // overrides SMObject
00359 
00360   /////////////////////////////////////////////////////////////////////////
00361   //                                                                     //
00362   // Control:                                                            //
00363   //                                                                     //
00364   /////////////////////////////////////////////////////////////////////////
00365 
00366   void takeControl( );         // overrides ComputationManager
00367 
00368   /////////////////////////////////////////////////////////////////////////
00369   //                                                                     //
00370   // State Transitions:                                                  //
00371   //                                                                     //
00372   /////////////////////////////////////////////////////////////////////////
00373 
00374   void start( ) { }              // overrides ComputationManager
00375 
00376   void terminate( ) { }          // overrides ComputationManager
00377 
00378 
00379 private:
00380 
00381   /////////////////////////////////////////////////////////////////////////
00382   //                                                                     //
00383   // Data Members:                                                       //
00384   //                                                                     //
00385   /////////////////////////////////////////////////////////////////////////
00386 
00387   class SMFPGroup& theGroup;
00388   
00389   ORProblems* theORProblems;
00390   ORIsFreeProblemARCer arcer;
00391   
00392   //HNNofFreeIsFreeArcer arcer;
00393 };
00394 
00395 
00396 // ====================================================================== //
00397 //                                                                        // 
00398 //                                                                        // 
00399 //       Amalgamated product of free groups's problems                    // 
00400 //                                                                        // 
00401 //                                                                        // 
00402 // ====================================================================== //
00403 
00404 
00405 // ------- Freeness of an amalgamated product of free groups  -------- //
00406 
00407 class APofFreeIsFreeArcer : public ARCer
00408 {
00409 public:
00410 
00411   /////////////////////////////////////////////////////////////////////////
00412   //                                                                     //
00413   // Constructors:                                                       //
00414   //                                                                     //
00415   /////////////////////////////////////////////////////////////////////////
00416 
00417   APofFreeIsFreeArcer( ComputationManager& boss ) 
00418     : ARCer( boss ), theAnswer( dontknow ), theGroup( 0 ) 
00419   { }
00420 
00421   ~APofFreeIsFreeArcer( ) { delete theGroup; }
00422 
00423 
00424   /////////////////////////////////////////////////////////////////////////
00425   //                                                                     //
00426   // Accessors:                                                          //
00427   //                                                                     //
00428   /////////////////////////////////////////////////////////////////////////
00429 
00430   void setArguments( const AmalgProductOfFreeGroups& G );
00431 
00432   // Inherited from ARCer:
00433   // bool takeControl( );
00434 
00435   Trichotomy answer() const { return theAnswer; }
00436   
00437   /////////////////////////////////////////////////////////////////////////
00438   //                                                                     //
00439   // IPC interaction members:                                            //
00440   //                                                                     //
00441   /////////////////////////////////////////////////////////////////////////
00442 
00443   void runComputation( );
00444  
00445   void writeResults( ostream& ostr );
00446 
00447   void readResults( istream& istr );
00448 
00449 
00450 private:
00451 
00452   /////////////////////////////////////////////////////////////////////////
00453   //                                                                     //
00454   // Data Members:                                                       //
00455   //                                                                     //
00456   /////////////////////////////////////////////////////////////////////////
00457 
00458   AmalgProductOfFreeGroups *theGroup;
00459   Trichotomy theAnswer;
00460 };
00461 
00462 class APofFreeIsFree : public ComputationManager
00463 {
00464 public:
00465 
00466   /////////////////////////////////////////////////////////////////////////
00467   //                                                                     //
00468   // Constructors:                                                       //
00469   //                                                                     //
00470   /////////////////////////////////////////////////////////////////////////
00471 
00472   APofFreeIsFree( class SMFPGroup& F );
00473 
00474   /////////////////////////////////////////////////////////////////////////
00475   //                                                                     //
00476   // Accessors:                                                          //
00477   //                                                                     //
00478   /////////////////////////////////////////////////////////////////////////
00479 
00480   /////////////////////////////////////////////////////////////////////////
00481   //                                                                     //
00482   // Front End Interfacing:                                              //
00483   //                                                                     //
00484   /////////////////////////////////////////////////////////////////////////
00485 
00486   void viewStructure(ostream& ostr) const;  // overrides SMObject
00487 
00488   /////////////////////////////////////////////////////////////////////////
00489   //                                                                     //
00490   // Control:                                                            //
00491   //                                                                     //
00492   /////////////////////////////////////////////////////////////////////////
00493 
00494   void takeControl( );         // overrides ComputationManager
00495 
00496   /////////////////////////////////////////////////////////////////////////
00497   //                                                                     //
00498   // State Transitions:                                                  //
00499   //                                                                     //
00500   /////////////////////////////////////////////////////////////////////////
00501 
00502   void start( ) { }              // overrides ComputationManager
00503   void terminate( ) { }          // overrides ComputationManager
00504 
00505 private:
00506 
00507   /////////////////////////////////////////////////////////////////////////
00508   //                                                                     //
00509   // Data Members:                                                       //
00510   //                                                                     //
00511   /////////////////////////////////////////////////////////////////////////
00512 
00513   class SMFPGroup& theGroup;
00514   APofFreeIsFreeArcer arcer;
00515 };
00516 
00517 
00518 
00519 // --------- Is an amalgamated product of free groups perfect  --------- //
00520 
00521 class APofFreeIsPerfect : public Supervisor
00522 {
00523 public:
00524 
00525   /////////////////////////////////////////////////////////////////////////
00526   //                                                                     //
00527   // Constructors:                                                       //
00528   //                                                                     //
00529   /////////////////////////////////////////////////////////////////////////
00530 
00531   APofFreeIsPerfect( class SMFPGroup& F );
00532 
00533   /////////////////////////////////////////////////////////////////////////
00534   //                                                                     //
00535   // Accessors:                                                          //
00536   //                                                                     //
00537   /////////////////////////////////////////////////////////////////////////
00538 
00539   /////////////////////////////////////////////////////////////////////////
00540   //                                                                     //
00541   // Front End Interfacing:                                              //
00542   //                                                                     //
00543   /////////////////////////////////////////////////////////////////////////
00544 
00545   void viewStructure(ostream& ostr) const;  // overrides SMObject
00546 
00547   /////////////////////////////////////////////////////////////////////////
00548   //                                                                     //
00549   // Control:                                                            //
00550   //                                                                     //
00551   /////////////////////////////////////////////////////////////////////////
00552 
00553   void takeControl( );         // overrides ComputationManager
00554 
00555   /////////////////////////////////////////////////////////////////////////
00556   //                                                                     //
00557   // State Transitions:                                                  //
00558   //                                                                     //
00559   /////////////////////////////////////////////////////////////////////////
00560 
00561   void start( ) { };              // overrides ComputationManager
00562   void terminate( ) { };          // overrides ComputationManager
00563 
00564 private:
00565 
00566   /////////////////////////////////////////////////////////////////////////
00567   //                                                                     //
00568   // Data Members:                                                       //
00569   //                                                                     //
00570   /////////////////////////////////////////////////////////////////////////
00571 
00572   class SMFPGroup& theGroup;
00573   MirrorSubordinate abelianInvariants;
00574 };
00575 
00576 
00577 // --------- Homology of an amalgamated product of free groups  -------- //
00578 
00579 class APofFreeHomologyArcer : public ARCer
00580 {
00581 public:
00582 
00583   /////////////////////////////////////////////////////////////////////////
00584   //                                                                     //
00585   // Constructors:                                                       //
00586   //                                                                     //
00587   /////////////////////////////////////////////////////////////////////////
00588 
00589   APofFreeHomologyArcer( ComputationManager& boss ) 
00590     : ARCer( boss ), theGroup( 0 ), theRankOfH2(-1)
00591   { }
00592 
00593   ~APofFreeHomologyArcer( ) { delete theGroup; }
00594 
00595 
00596   /////////////////////////////////////////////////////////////////////////
00597   //                                                                     //
00598   // Accessors:                                                          //
00599   //                                                                     //
00600   /////////////////////////////////////////////////////////////////////////
00601 
00602   void setArguments( const AmalgProductOfFreeGroups& G );
00603 
00604   // Inherited from ARCer:
00605   // bool takeControl( );
00606 
00607   int rankOfH2() const { return theRankOfH2; }
00608   
00609   /////////////////////////////////////////////////////////////////////////
00610   //                                                                     //
00611   // IPC interaction members:                                            //
00612   //                                                                     //
00613   /////////////////////////////////////////////////////////////////////////
00614 
00615   void runComputation( );
00616  
00617   void writeResults( ostream& ostr );
00618 
00619   void readResults( istream& istr );
00620 
00621 
00622 private:
00623 
00624   /////////////////////////////////////////////////////////////////////////
00625   //                                                                     //
00626   // Data Members:                                                       //
00627   //                                                                     //
00628   /////////////////////////////////////////////////////////////////////////
00629 
00630   AmalgProductOfFreeGroups *theGroup;
00631   int theRankOfH2;
00632 };
00633 
00634 class APofFreeHomologyProblem : public Supervisor //ComputationManager
00635 {
00636 public:
00637 
00638   /////////////////////////////////////////////////////////////////////////
00639   //                                                                     //
00640   // Constructors:                                                       //
00641   //                                                                     //
00642   /////////////////////////////////////////////////////////////////////////
00643 
00644   APofFreeHomologyProblem( class SMFPGroup& F );
00645 
00646   /////////////////////////////////////////////////////////////////////////
00647   //                                                                     //
00648   // Accessors:                                                          //
00649   //                                                                     //
00650   /////////////////////////////////////////////////////////////////////////
00651 
00652   /////////////////////////////////////////////////////////////////////////
00653   //                                                                     //
00654   // Front End Interfacing:                                              //
00655   //                                                                     //
00656   /////////////////////////////////////////////////////////////////////////
00657 
00658   void viewStructure(ostream& ostr) const;  // overrides SMObject
00659 
00660   /////////////////////////////////////////////////////////////////////////
00661   //                                                                     //
00662   // Control:                                                            //
00663   //                                                                     //
00664   /////////////////////////////////////////////////////////////////////////
00665 
00666   void takeControl( );         // overrides ComputationManager
00667 
00668   /////////////////////////////////////////////////////////////////////////
00669   //                                                                     //
00670   // State Transitions:                                                  //
00671   //                                                                     //
00672   /////////////////////////////////////////////////////////////////////////
00673 
00674   void start( ) { }              // overrides ComputationManager
00675   void terminate( ) { }          // overrides ComputationManager
00676 
00677 private:
00678 
00679   /////////////////////////////////////////////////////////////////////////
00680   //                                                                     //
00681   // Data Members:                                                       //
00682   //                                                                     //
00683   /////////////////////////////////////////////////////////////////////////
00684 
00685   class SMFPGroup& theGroup;
00686   APofFreeHomologyArcer arcer;
00687   MirrorSubordinate abelianInvariants;
00688   bool cyclicSubgroup;
00689   bool abDone;
00690   bool arcerStarted;
00691 };
00692 
00693 
00694 
00695 
00696 
00697 #endif

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