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

/magnus/back_end/SMApps/include/ToddCoxeter.h

Go to the documentation of this file.
00001 /*
00002  *   $Id:
00003  */
00004  
00005 // Copyright (C) 1997 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 //
00008 // Contents: Declaration of class ToddCoxeterARCer ToddCoxeter,
00009 //           SGIndexToddCoxeter, SchreierTransversal, PermutationRepProblem,
00010 //           WordRepresentativeProblem, WordRepresentativeProblem 
00011 //
00012 // Principal Author: Alexei Myasnikov
00013 //
00014 // Status: Usable
00015 //
00016 // Revision History:
00017 //
00018 
00019 
00020 #ifndef _TODD_COXETER_H_
00021 #define _TODD_COXETER_H_
00022 
00023 
00024 #include "Supervisor.h"
00025 #include "CosetEnumerator.h"
00026 #include "File.h"
00027 
00028 // ------------------ ToddCoxeterARCer ---------------------- //
00029 
00030 
00031 class ToddCoxeterARCer : public ARCer
00032 {
00033 public:
00034 
00035   /////////////////////////////////////////////////////////////////////////
00036   //                                                                     //
00037   // Constructors:                                                       //
00038   //                                                                     //
00039   /////////////////////////////////////////////////////////////////////////
00040 
00041   ToddCoxeterARCer( ComputationManager& boss,const FPGroup& group ) 
00042     : ARCer( boss ), enumerator(group),permutationRepresentation(NULL),
00043     theGroup(group) { } 
00044 
00045   ToddCoxeterARCer( ComputationManager& boss,const FPGroup& group,
00046                     const VectorOf<Word>& subgroup) 
00047     : ARCer( boss ), permutationRepresentation(NULL),
00048     enumerator(group,subgroup), theGroup(group) { } 
00049   
00050 
00051   /////////////////////////////////////////////////////////////////////////
00052   //                                                                     //
00053   // Accessors:                                                          //
00054   //                                                                     //
00055   /////////////////////////////////////////////////////////////////////////
00056 
00057   int getRetValue() const{ return retValue; }
00058 
00059   // Inherited from ARCer:
00060   // bool takeControl( );
00061   const PermutationRepresentation& getTransversal()const;
00062 
00063   /////////////////////////////////////////////////////////////////////////
00064   //                                                                     //
00065   // IPC interaction members:                                            //
00066   //                                                                     //
00067   /////////////////////////////////////////////////////////////////////////
00068 
00069   void runComputation( );
00070  
00071   void writeResults( ostream& );
00072 
00073   void readResults( istream& );
00074 
00075   
00076 private:
00077 
00078   /////////////////////////////////////////////////////////////////////////
00079   //                                                                     //
00080   // Data Members:                                                       //
00081   //                                                                     //
00082   /////////////////////////////////////////////////////////////////////////
00083 
00084   CosetEnumerator enumerator;
00085   FPGroup theGroup;
00086 
00087   int retValue;
00088   PermutationRepresentation* permutationRepresentation;
00089 };
00090 
00091 // -------------------------- ToddCoxeter ---------------------------- //
00092 
00093 
00094 class ToddCoxeter : public ComputationManager
00095 {
00096 public:
00097 
00098   /////////////////////////////////////////////////////////////////////////
00099   //                                                                     //
00100   // Constructors:                                                       //
00101   //                                                                     //
00102   /////////////////////////////////////////////////////////////////////////
00103 
00104   ToddCoxeter(class GCM& gcm);
00105 
00106 
00107   /////////////////////////////////////////////////////////////////////////
00108   //                                                                     //
00109   // Accessors:                                                          //
00110   //                                                                     //
00111   /////////////////////////////////////////////////////////////////////////
00112 
00113   /////////////////////////////////////////////////////////////////////////
00114   //                                                                     //
00115   // Control:                                                            //
00116   //                                                                     //
00117   /////////////////////////////////////////////////////////////////////////
00118 
00119   void takeControl( );         // overrides ComputationManager
00120 
00121 
00122   /////////////////////////////////////////////////////////////////////////
00123   //                                                                     //
00124   // State Transitions:                                                  //
00125   //                                                                     //
00126   /////////////////////////////////////////////////////////////////////////
00127 
00128   void start( ) { };          // overrides ComputationManager
00129 
00130   void terminate( ) { };      // overrides ComputationManager
00131 
00132 
00133 private:
00134 
00135   /////////////////////////////////////////////////////////////////////////
00136   //                                                                     //
00137   // Data Members:                                                       //
00138   //                                                                     //
00139   /////////////////////////////////////////////////////////////////////////
00140 
00141   class GCM& theGCM;
00142   class SMFPGroup& theGroup;
00143   ToddCoxeterARCer* arcer;
00144 };
00145 
00146 // -------------------------- SGIndexToddCoxeter ------------------------- //
00147 
00148 
00149 class SGIndexToddCoxeter : public ComputationManager
00150 {
00151 public:
00152 
00153   /////////////////////////////////////////////////////////////////////////
00154   //                                                                     //
00155   // Constructors:                                                       //
00156   //                                                                     //
00157   /////////////////////////////////////////////////////////////////////////
00158 
00159   SGIndexToddCoxeter(class SCM& scm);
00160 
00161 
00162   /////////////////////////////////////////////////////////////////////////
00163   //                                                                     //
00164   // Accessors:                                                          //
00165   //                                                                     //
00166   /////////////////////////////////////////////////////////////////////////
00167 
00168   /////////////////////////////////////////////////////////////////////////
00169   //                                                                     //
00170   // Control:                                                            //
00171   //                                                                     //
00172   /////////////////////////////////////////////////////////////////////////
00173 
00174   void takeControl( );         // overrides ComputationManager
00175 
00176 
00177   /////////////////////////////////////////////////////////////////////////
00178   //                                                                     //
00179   // State Transitions:                                                  //
00180   //                                                                     //
00181   /////////////////////////////////////////////////////////////////////////
00182 
00183   void start( ) { };          // overrides ComputationManager
00184 
00185   void terminate( ) { };      // overrides ComputationManager
00186 
00187 
00188 private:
00189 
00190   /////////////////////////////////////////////////////////////////////////
00191   //                                                                     //
00192   // Data Members:                                                       //
00193   //                                                                     //
00194   /////////////////////////////////////////////////////////////////////////
00195 
00196   class SCM& theSCM;
00197   class SMSubgroup& theSubgroup;
00198   ToddCoxeterARCer arcer;
00199 };
00200 
00201 
00202 //---------------------------------------------------------------------------//
00203 //--------------------------- SchreierTransversal ---------------------------//
00204 //---------------------------------------------------------------------------//
00205 
00206 
00207 class SchreierTransversal : public Supervisor
00208 {
00209 public:
00210 
00211   /////////////////////////////////////////////////////////////////////////
00212   //                                                                     //
00213   // Constructors:                                                       //
00214   //                                                                     //
00215   /////////////////////////////////////////////////////////////////////////
00216 
00217   SchreierTransversal(class SMFPGroup& );
00218   SchreierTransversal(class SMSubgroup& );
00219 
00220   /////////////////////////////////////////////////////////////////////////
00221   //                                                                     //
00222   // Front End Interfacing:                                              //
00223   //                                                                     //
00224   /////////////////////////////////////////////////////////////////////////
00225 
00226   void viewStructure(ostream& ostr) const;  // overrides SMObject
00227 
00228   /////////////////////////////////////////////////////////////////////////
00229   //                                                                     //
00230   // Control:                                                            //
00231   //                                                                     //
00232   /////////////////////////////////////////////////////////////////////////
00233 
00234   void takeControl( );         // overrides ComputationManager
00235 
00236   
00237   bool haveSchreierTransvl()const;
00238   
00239   const VectorOf<Word>& getRepresentatives()const;
00240   bool isInfinite()const;
00241  
00242   
00243   /////////////////////////////////////////////////////////////////////////
00244   //                                                                     //
00245   // State Transitions:                                                  //
00246   //                                                                     //
00247   /////////////////////////////////////////////////////////////////////////
00248 
00249   void start( ) { }              // overrides ComputationManager
00250 
00251   void terminate( ) { }          // overrides ComputationManager
00252 
00253 
00254 private:
00255 
00256   /////////////////////////////////////////////////////////////////////////
00257   //                                                                     //
00258   // Data Members:                                                       //
00259   //                                                                     //
00260   /////////////////////////////////////////////////////////////////////////
00261 
00262   class AlgebraicObject& theObject;
00263   class SMFPGroup& theGroup;
00264   
00265   MirrorSubordinate theToddCoxeter;
00266   
00267 };
00268 
00269 //---------------------------------------------------------------------------//
00270 //--------------------------- PermutationRepProblem -------------------------//
00271 //---------------------------------------------------------------------------//
00272 
00273 
00274 class PermutationRepProblem : public Supervisor
00275 {
00276 public:
00277 
00278   /////////////////////////////////////////////////////////////////////////
00279   //                                                                     //
00280   // Constructors:                                                       //
00281   //                                                                     //
00282   /////////////////////////////////////////////////////////////////////////
00283 
00284   PermutationRepProblem(class SMFPGroup& );
00285   PermutationRepProblem(class SMSubgroup& );
00286 
00287   /////////////////////////////////////////////////////////////////////////
00288   //                                                                     //
00289   // Front End Interfacing:                                              //
00290   //                                                                     //
00291   /////////////////////////////////////////////////////////////////////////
00292 
00293   void viewStructure(ostream& ostr) const;  // overrides SMObject
00294 
00295   /////////////////////////////////////////////////////////////////////////
00296   //                                                                     //
00297   // Control:                                                            //
00298   //                                                                     //
00299   /////////////////////////////////////////////////////////////////////////
00300 
00301   void takeControl( );         // overrides ComputationManager
00302 
00303   
00304   bool haveSchreierTransvl()const;
00305   bool isInfinite()const;
00306   const class PermutationRepresentation& getPermutations()const;
00307  
00308   
00309   /////////////////////////////////////////////////////////////////////////
00310   //                                                                     //
00311   // State Transitions:                                                  //
00312   //                                                                     //
00313   /////////////////////////////////////////////////////////////////////////
00314 
00315   void start( ) { }              // overrides ComputationManager
00316 
00317   void terminate( ) { }          // overrides ComputationManager
00318 
00319 
00320 private:
00321 
00322   /////////////////////////////////////////////////////////////////////////
00323   //                                                                     //
00324   // Data Members:                                                       //
00325   //                                                                     //
00326   /////////////////////////////////////////////////////////////////////////
00327 
00328   class AlgebraicObject& theObject;
00329   class SMFPGroup& theGroup;
00330   
00331   MirrorSubordinate theToddCoxeter;
00332   
00333 };
00334 
00335 //---------------------------------------------------------------------------//
00336 //--------------------------- WordRepresentativeProblem ---------------------//
00337 //---------------------------------------------------------------------------//
00338 
00339 
00340 
00341 class WordRepresentativeARCer : public ARCer
00342 {
00343 public:
00344 
00345   /////////////////////////////////////////////////////////////////////////
00346   //                                                                     //
00347   // Constructors:                                                       //
00348   //                                                                     //
00349   /////////////////////////////////////////////////////////////////////////
00350 
00351   WordRepresentativeARCer( ComputationManager& boss ) 
00352     : ARCer( boss ), permutationRepresentation(NULL)
00353     { } 
00354 
00355   void setArguments(const PermutationRepresentation&,const Word&);
00356 
00357   /////////////////////////////////////////////////////////////////////////
00358   //                                                                     //
00359   // Accessors:                                                          //
00360   //                                                                     //
00361   /////////////////////////////////////////////////////////////////////////
00362 
00363   Word getRetValue() const{ return retValue; }
00364 
00365   // Inherited from ARCer:
00366   // bool takeControl( );
00367  
00368   /////////////////////////////////////////////////////////////////////////
00369   //                                                                     //
00370   // IPC interaction members:                                            //
00371   //                                                                     //
00372   /////////////////////////////////////////////////////////////////////////
00373 
00374   void runComputation( );
00375  
00376   void writeResults( ostream& );
00377 
00378   void readResults( istream& );
00379 
00380   
00381 private:
00382 
00383   /////////////////////////////////////////////////////////////////////////
00384   //                                                                     //
00385   // Data Members:                                                       //
00386   //                                                                     //
00387   /////////////////////////////////////////////////////////////////////////
00388 
00389   Word retValue;
00390   Word theWord;
00391   PermutationRepresentation* permutationRepresentation;
00392 };
00393 
00394 
00395 
00396 
00397 
00398 
00399 
00400 
00401 class WordRepresentative : public ComputationManager
00402 {
00403 public:
00404 
00405   /////////////////////////////////////////////////////////////////////////
00406   //                                                                     //
00407   // Constructors:                                                       //
00408   //                                                                     //
00409   /////////////////////////////////////////////////////////////////////////
00410 
00411   WordRepresentative( class WordRepresentativeProblem& boss );
00412 
00413   WordRepresentative( class SubgroupContainmentProblem& boss );
00414 
00415   WordRepresentative( class IsSGNormal& boss );
00416 
00417   /////////////////////////////////////////////////////////////////////////
00418   //                                                                     //
00419   // Accessors:                                                          //
00420   //                                                                     //
00421   /////////////////////////////////////////////////////////////////////////
00422 
00423   bool haveSchreierTransvl( ) const;
00424 
00425   bool isInfinite( ) const;
00426 
00427   const class PermutationRepresentation& getPermutations( ) const;
00428 
00429   VectorOf<bool> foundWordsReps( ) const { return theWordsRepsFound; }
00430 
00431   VectorOf<Word> getWordsReps( ) const { return theWordsReps; }
00432 
00433   /////////////////////////////////////////////////////////////////////////
00434   //                                                                     //
00435   // Control:                                                            //
00436   //                                                                     //
00437   /////////////////////////////////////////////////////////////////////////
00438 
00439   void takeControl( );         // overrides ComputationManager
00440 
00441 
00442   /////////////////////////////////////////////////////////////////////////
00443   //                                                                     //
00444   // State Transitions:                                                  //
00445   //                                                                     //
00446   /////////////////////////////////////////////////////////////////////////
00447 
00448   void start( ) { };          // overrides ComputationManager
00449 
00450   void terminate( ) { };      // overrides ComputationManager
00451 
00452 
00453 private:
00454 
00455   /////////////////////////////////////////////////////////////////////////
00456   //                                                                     //
00457   // Data Members:                                                       //
00458   //                                                                     //
00459   /////////////////////////////////////////////////////////////////////////
00460 
00461   const class AlgebraicObject& theParent;
00462   const class SMFPGroup& theGroup;
00463   VectorOf<Word> theTestWords;
00464 
00465   VectorOf<Word> theWordsReps;
00466   VectorOf<bool> theWordsRepsFound;
00467   int checkedWord;
00468 
00469   WordRepresentativeARCer arcer;
00470   bool arcerStarted;
00471 };
00472 
00473 
00474 class WordRepresentativeProblem : public Supervisor
00475 {
00476 public:
00477 
00478   /////////////////////////////////////////////////////////////////////////
00479   //                                                                     //
00480   // Constructors:                                                       //
00481   //                                                                     //
00482   /////////////////////////////////////////////////////////////////////////
00483 
00484   WordRepresentativeProblem(class SMWord& );
00485   WordRepresentativeProblem(class SMSubgroup&,class SMWord& );
00486 
00487   /////////////////////////////////////////////////////////////////////////
00488   //                                                                     //
00489   // Front End Interfacing:                                              //
00490   //                                                                     //
00491   /////////////////////////////////////////////////////////////////////////
00492 
00493   void viewStructure(ostream& ostr) const;  // overrides SMObject
00494 
00495   /////////////////////////////////////////////////////////////////////////
00496   //                                                                     //
00497   // Control:                                                            //
00498   //                                                                     //
00499   /////////////////////////////////////////////////////////////////////////
00500 
00501   void takeControl( );         // overrides ComputationManager
00502 
00503   
00504   bool haveSchreierTransvl()const;
00505   bool isInfinite()const;
00506   //  const class PermutationRepresentation& getPermutations()const;
00507 
00508   const class AlgebraicObject& getParent( ) const { return theParent; }
00509   const class SMFPGroup& getGroup() const { return theGroup; }
00510   const class SMWord& getWord( ) const { return theWord; }
00511 
00512   /////////////////////////////////////////////////////////////////////////
00513   //                                                                     //
00514   // State Transitions:                                                  //
00515   //                                                                     //
00516   /////////////////////////////////////////////////////////////////////////
00517 
00518   void start( ) { }              // overrides ComputationManager
00519 
00520   void terminate( ) { }          // overrides ComputationManager
00521 
00522 
00523 private:
00524 
00525   /////////////////////////////////////////////////////////////////////////
00526   //                                                                     //
00527   // Data Members:                                                       //
00528   //                                                                     //
00529   /////////////////////////////////////////////////////////////////////////
00530 
00531   class AlgebraicObject& theParent;
00532   class SMFPGroup& theGroup;
00533   class SMWord& theWord;
00534   MirrorSubordinate theToddCoxeter;
00535   Subordinate<WordRepresentativeProblem,WordRepresentative> theWordRepCM;
00536 };
00537 
00538 #endif
00539 
00540 
00541 
00542 
00543 
00544 
00545 
00546 
00547 

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