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

/magnus/back_end/SMApps/include/NilpotentProblems.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: NilpotentProblems.h,v 1.11 2000/02/09 06:33:14 alex Exp $
00003  */
00004  
00005 // Copyright (C) 1995 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 //
00008 // Contents: Declarations of classes NilpotentWP, NilpotentCenterProblem,
00009 //           NilpotentCentralizersProblem,
00010 //           NilpotentIsAbelianProblemARCer, NilpotentIsAbelianProblem,
00011 //           NilpotentOrderProblemARCer, NilpotentOrderProblem,
00012 //           NilpotentOrderOfEltProblemARCer, NilpotentOrderOfEltProblem,
00013 //           NilpotentIsSGTrivialProblemARCer, NilpotentIsSGTrivialProblem,
00014 //           NilpotentIsSGFiniteProblemARCer, NilpotentIsSGFiniteProblem,
00015 //           NilpotentIsSGAbelianProblemARCer, NilpotentIsSGAbelianProblem
00016 //
00017 // Principal Author: Roger Needham, Dmitry Bormotov, Alexei Myasnikov
00018 //
00019 // Status: in progress
00020 //
00021 // Revision History:
00022 //
00023 
00024 
00025 #ifndef _NILPOTENTPROBLEMS_H_
00026 #define _NILPOTENTPROBLEMS_H_
00027 
00028 
00029 //@rn  This is specialized for the moment to work only on the specific class of
00030 //@rn  a group which was checked in as nilpotent. It can, in principle, work
00031 //@rn  on any nilpotent quotient of any FP group.
00032 
00033 
00034 #include "Integer.h"
00035 #include "Supervisor.h"
00036 #include "ComputationManager.h"
00037 #include "NilpotentQuotients.h"
00038 #include "NilpotentGroup.h"
00039 #include "List.h"
00040 #include "ARCer.h"
00041 
00042 // ------------------ NilpotentOrderOfEltProblemARCer ---------------------- //
00043 
00044 
00045 class NGOrderOfEltProblemARCer : public ARCer
00046 {
00047 public:
00048 
00049   /////////////////////////////////////////////////////////////////////////
00050   //                                                                     //
00051   // Constructors:                                                       //
00052   //                                                                     //
00053   /////////////////////////////////////////////////////////////////////////
00054 
00055   NGOrderOfEltProblemARCer( ComputationManager& boss ) 
00056     : ARCer( boss ), theNG( 0 ) { } 
00057   
00058 
00059   /////////////////////////////////////////////////////////////////////////
00060   //                                                                     //
00061   // Accessors:                                                          //
00062   //                                                                     //
00063   /////////////////////////////////////////////////////////////////////////
00064 
00065   void setArguments( const NilpotentGroup&, const Word& );
00066 
00067   Integer getOrder() const { return retValue; }
00068 
00069   // Inherited from ARCer:
00070   // bool takeControl( );
00071 
00072 
00073   /////////////////////////////////////////////////////////////////////////
00074   //                                                                     //
00075   // IPC interaction members:                                            //
00076   //                                                                     //
00077   /////////////////////////////////////////////////////////////////////////
00078 
00079   void runComputation( );
00080  
00081   void writeResults( ostream& );
00082 
00083   void readResults( istream& );
00084 
00085   
00086 private:
00087 
00088   /////////////////////////////////////////////////////////////////////////
00089   //                                                                     //
00090   // Data Members:                                                       //
00091   //                                                                     //
00092   /////////////////////////////////////////////////////////////////////////
00093 
00094   const NilpotentGroup* theNG;
00095   
00096   Integer retValue;
00097 
00098   Word theWord;
00099 };
00100 
00101 // --------------------- NGorderOfEltProblem ------------------------ //
00102 
00103 
00104 class NGorderOfEltProblem : public Supervisor
00105 {
00106 public:
00107 
00108   /////////////////////////////////////////////////////////////////////////
00109   //                                                                     //
00110   // Constructors:                                                       //
00111   //                                                                     //
00112   /////////////////////////////////////////////////////////////////////////
00113 
00114   NGorderOfEltProblem( class SMWord& );
00115 
00116 
00117   /////////////////////////////////////////////////////////////////////////
00118   //                                                                     //
00119   // Front End Interfacing:                                              //
00120   //                                                                     //
00121   /////////////////////////////////////////////////////////////////////////
00122 
00123   void viewStructure(ostream& ostr) const;  // overrides SMObject
00124 
00125 
00126   /////////////////////////////////////////////////////////////////////////
00127   //                                                                     //
00128   // Control:                                                            //
00129   //                                                                     //
00130   /////////////////////////////////////////////////////////////////////////
00131 
00132   void takeControl( );         // overrides ComputationManager
00133 
00134 
00135   /////////////////////////////////////////////////////////////////////////
00136   //                                                                     //
00137   // State Transitions:                                                  //
00138   //                                                                     //
00139   /////////////////////////////////////////////////////////////////////////
00140 
00141   void start( ) { }            // overrides ComputationManager
00142 
00143   void terminate( ) { }        // overrides ComputationManager
00144 
00145 
00146 private:
00147 
00148   /////////////////////////////////////////////////////////////////////////
00149   //                                                                     //
00150   // Data Members:                                                       //
00151   //                                                                     //
00152   /////////////////////////////////////////////////////////////////////////
00153 
00154   class SMWord& theWord;
00155 
00156   class GIC& theGIC;
00157 
00158   MirrorSubordinate computeBasis;
00159   NGOrderOfEltProblemARCer arcer;
00160   bool started;
00161 };
00162 
00163 // --------------------- NGHirschNumberProblem ------------------------ //
00164 
00165 
00166 class NGHirschNumberProblem : public Supervisor
00167 {
00168 public:
00169 
00170   /////////////////////////////////////////////////////////////////////////
00171   //                                                                     //
00172   // Constructors:                                                       //
00173   //                                                                     //
00174   /////////////////////////////////////////////////////////////////////////
00175 
00176   NGHirschNumberProblem( class SMFPGroup& );
00177 
00178 
00179   /////////////////////////////////////////////////////////////////////////
00180   //                                                                     //
00181   // Front End Interfacing:                                              //
00182   //                                                                     //
00183   /////////////////////////////////////////////////////////////////////////
00184 
00185   void viewStructure(ostream& ostr) const;  // overrides SMObject
00186 
00187 
00188   /////////////////////////////////////////////////////////////////////////
00189   //                                                                     //
00190   // Control:                                                            //
00191   //                                                                     //
00192   /////////////////////////////////////////////////////////////////////////
00193 
00194   void takeControl( );         // overrides ComputationManager
00195 
00196 
00197   /////////////////////////////////////////////////////////////////////////
00198   //                                                                     //
00199   // State Transitions:                                                  //
00200   //                                                                     //
00201   /////////////////////////////////////////////////////////////////////////
00202 
00203   void start( ) { }            // overrides ComputationManager
00204 
00205   void terminate( ) { }        // overrides ComputationManager
00206 
00207 
00208 private:
00209 
00210   /////////////////////////////////////////////////////////////////////////
00211   //                                                                     //
00212   // Data Members:                                                       //
00213   //                                                                     //
00214   /////////////////////////////////////////////////////////////////////////
00215 
00216   class SMFPGroup& theGroup;
00217 
00218   class GIC& theGIC;
00219 
00220   MirrorSubordinate computeBasis;
00221 };
00222 
00223 // --------------------- NGcomputeLCSQuotientsProblem ------------------------ //
00224 
00225 
00226 class NGcomputeLCSQuotientsProblem : public Supervisor
00227 {
00228 public:
00229 
00230   /////////////////////////////////////////////////////////////////////////
00231   //                                                                     //
00232   // Constructors:                                                       //
00233   //                                                                     //
00234   /////////////////////////////////////////////////////////////////////////
00235 
00236  NGcomputeLCSQuotientsProblem( class SMFPGroup& );
00237 
00238 
00239   /////////////////////////////////////////////////////////////////////////
00240   //                                                                     //
00241   // Front End Interfacing:                                              //
00242   //                                                                     //
00243   /////////////////////////////////////////////////////////////////////////
00244 
00245   void viewStructure(ostream& ostr) const;  // overrides SMObject
00246 
00247 
00248   /////////////////////////////////////////////////////////////////////////
00249   //                                                                     //
00250   // Control:                                                            //
00251   //                                                                     //
00252   /////////////////////////////////////////////////////////////////////////
00253 
00254   void takeControl( );         // overrides ComputationManager
00255 
00256 
00257   /////////////////////////////////////////////////////////////////////////
00258   //                                                                     //
00259   // State Transitions:                                                  //
00260   //                                                                     //
00261   /////////////////////////////////////////////////////////////////////////
00262 
00263   void start( ) { }            // overrides ComputationManager
00264 
00265   void terminate( ) { }        // overrides ComputationManager
00266 
00267 
00268 private:
00269 
00270   /////////////////////////////////////////////////////////////////////////
00271   //                                                                     //
00272   // Data Members:                                                       //
00273   //                                                                     //
00274   /////////////////////////////////////////////////////////////////////////
00275 
00276   class SMFPGroup& theGroup;
00277 
00278   class GIC& theGIC;
00279 
00280   MirrorSubordinate computeBasis;
00281   MirrorSubordinate computeLCSQuotientsComp;
00282 };
00283 // --------------------- NGcomputeNClassProblem ------------------------ //
00284 
00285 
00286 class NGcomputeNClassProblem : public Supervisor
00287 {
00288 public:
00289 
00290   /////////////////////////////////////////////////////////////////////////
00291   //                                                                     //
00292   // Constructors:                                                       //
00293   //                                                                     //
00294   /////////////////////////////////////////////////////////////////////////
00295 
00296   NGcomputeNClassProblem( class SMFPGroup& );
00297 
00298 
00299   /////////////////////////////////////////////////////////////////////////
00300   //                                                                     //
00301   // Front End Interfacing:                                              //
00302   //                                                                     //
00303   /////////////////////////////////////////////////////////////////////////
00304 
00305   void viewStructure(ostream& ostr) const;  // overrides SMObject
00306 
00307 
00308   /////////////////////////////////////////////////////////////////////////
00309   //                                                                     //
00310   // Control:                                                            //
00311   //                                                                     //
00312   /////////////////////////////////////////////////////////////////////////
00313 
00314   void takeControl( );         // overrides ComputationManager
00315 
00316 
00317   /////////////////////////////////////////////////////////////////////////
00318   //                                                                     //
00319   // State Transitions:                                                  //
00320   //                                                                     //
00321   /////////////////////////////////////////////////////////////////////////
00322 
00323   void start( ) { }            // overrides ComputationManager
00324 
00325   void terminate( ) { }        // overrides ComputationManager
00326 
00327 
00328 private:
00329 
00330   /////////////////////////////////////////////////////////////////////////
00331   //                                                                     //
00332   // Data Members:                                                       //
00333   //                                                                     //
00334   /////////////////////////////////////////////////////////////////////////
00335 
00336   class SMFPGroup& theGroup;
00337 
00338   class GIC& theGIC;
00339   MirrorSubordinate abelianInvariants;
00340   MirrorSubordinate computeBasis;
00341   //MirrorSubordinate computeLCSQuotientsComp;
00342 };
00343 
00344 // --------------------- NGisFreeNilpotentProblem ------------------------ //
00345 
00346 
00347 class NGisFreeNilpotentProblem : public Supervisor
00348 {
00349 public:
00350 
00351   /////////////////////////////////////////////////////////////////////////
00352   //                                                                     //
00353   // Constructors:                                                       //
00354   //                                                                     //
00355   /////////////////////////////////////////////////////////////////////////
00356 
00357  NGisFreeNilpotentProblem( class SMFPGroup& );
00358 
00359 
00360   /////////////////////////////////////////////////////////////////////////
00361   //                                                                     //
00362   // Front End Interfacing:                                              //
00363   //                                                                     //
00364   /////////////////////////////////////////////////////////////////////////
00365 
00366   void viewStructure(ostream& ostr) const;  // overrides SMObject
00367 
00368 
00369   /////////////////////////////////////////////////////////////////////////
00370   //                                                                     //
00371   // Control:                                                            //
00372   //                                                                     //
00373   /////////////////////////////////////////////////////////////////////////
00374 
00375   void takeControl( );         // overrides ComputationManager
00376 
00377 
00378   /////////////////////////////////////////////////////////////////////////
00379   //                                                                     //
00380   // State Transitions:                                                  //
00381   //                                                                     //
00382   /////////////////////////////////////////////////////////////////////////
00383 
00384   void start( ) { }            // overrides ComputationManager
00385 
00386   void terminate( ) { }        // overrides ComputationManager
00387 
00388 
00389 private:
00390 
00391   /////////////////////////////////////////////////////////////////////////
00392   //                                                                     //
00393   // Data Members:                                                       //
00394   //                                                                     //
00395   /////////////////////////////////////////////////////////////////////////
00396 
00397   class SMFPGroup& theGroup;
00398 
00399   class GIC& theGIC;
00400 
00401   MirrorSubordinate abelianInvariants;
00402   MirrorSubordinate computeBasis;
00403   //MirrorSubordinate computeLCSQuotientsComp;
00404   Trichotomy answer;
00405   int freeRank, freeClass;
00406 };
00407 
00408 
00409 // --------------------- NGdecomposeWordProblem ------------------------ //
00410 
00411 
00412 class NGdecomposeWordProblem : public Supervisor
00413 {
00414 public:
00415 
00416   /////////////////////////////////////////////////////////////////////////
00417   //                                                                     //
00418   // Constructors:                                                       //
00419   //                                                                     //
00420   /////////////////////////////////////////////////////////////////////////
00421 
00422  NGdecomposeWordProblem( class SMWord& );
00423 
00424 
00425   /////////////////////////////////////////////////////////////////////////
00426   //                                                                     //
00427   // Front End Interfacing:                                              //
00428   //                                                                     //
00429   /////////////////////////////////////////////////////////////////////////
00430 
00431   void viewStructure(ostream& ostr) const;  // overrides SMObject
00432 
00433 
00434   /////////////////////////////////////////////////////////////////////////
00435   //                                                                     //
00436   // Control:                                                            //
00437   //                                                                     //
00438   /////////////////////////////////////////////////////////////////////////
00439 
00440   void takeControl( );         // overrides ComputationManager
00441 
00442 
00443   /////////////////////////////////////////////////////////////////////////
00444   //                                                                     //
00445   // State Transitions:                                                  //
00446   //                                                                     //
00447   /////////////////////////////////////////////////////////////////////////
00448 
00449   void start( ) { }            // overrides ComputationManager
00450 
00451   void terminate( ) { }        // overrides ComputationManager
00452 
00453 
00454 private:
00455 
00456   /////////////////////////////////////////////////////////////////////////
00457   //                                                                     //
00458   // Data Members:                                                       //
00459   //                                                                     //
00460   /////////////////////////////////////////////////////////////////////////
00461 
00462   class SMWord& theWord;
00463 
00464   class WIC& theWIC;
00465 
00466   MirrorSubordinate computeBasis;
00467   MirrorSubordinate ngDecomposeWord;
00468 };
00469 
00470 // --------------------- NGisWordInCommutatorSGProblem ------------------------ //
00471 
00472 
00473 class NGisWordInCommutatorSGProblem : public Supervisor
00474 {
00475 public:
00476 
00477   /////////////////////////////////////////////////////////////////////////
00478   //                                                                     //
00479   // Constructors:                                                       //
00480   //                                                                     //
00481   /////////////////////////////////////////////////////////////////////////
00482 
00483  NGisWordInCommutatorSGProblem( class SMWord& );
00484 
00485 
00486   /////////////////////////////////////////////////////////////////////////
00487   //                                                                     //
00488   // Front End Interfacing:                                              //
00489   //                                                                     //
00490   /////////////////////////////////////////////////////////////////////////
00491 
00492   void viewStructure(ostream& ostr) const;  // overrides SMObject
00493 
00494 
00495   /////////////////////////////////////////////////////////////////////////
00496   //                                                                     //
00497   // Control:                                                            //
00498   //                                                                     //
00499   /////////////////////////////////////////////////////////////////////////
00500 
00501   void takeControl( );         // overrides ComputationManager
00502 
00503 
00504   /////////////////////////////////////////////////////////////////////////
00505   //                                                                     //
00506   // State Transitions:                                                  //
00507   //                                                                     //
00508   /////////////////////////////////////////////////////////////////////////
00509 
00510   void start( ) { }            // overrides ComputationManager
00511 
00512   void terminate( ) { }        // overrides ComputationManager
00513 
00514 
00515 private:
00516 
00517   /////////////////////////////////////////////////////////////////////////
00518   //                                                                     //
00519   // Data Members:                                                       //
00520   //                                                                     //
00521   /////////////////////////////////////////////////////////////////////////
00522 
00523   class SMWord& theWord;
00524 
00525   class GIC& theGIC;
00526 
00527   MirrorSubordinate abelianInvariants;
00528 };
00529 // ------------------ NGweightOfWordARCer ---------------------- //
00530 
00531 
00532 class NGweightOfWordARCer : public ARCer
00533 {
00534 public:
00535 
00536   /////////////////////////////////////////////////////////////////////////
00537   //                                                                     //
00538   // Constructors:                                                       //
00539   //                                                                     //
00540   /////////////////////////////////////////////////////////////////////////
00541 
00542   NGweightOfWordARCer( ComputationManager& boss ) 
00543     : ARCer( boss ),theNG(NULL) { } 
00544   
00545   ~NGweightOfWordARCer() { delete theNG; }
00546 
00547   /////////////////////////////////////////////////////////////////////////
00548   //                                                                     //
00549   // Accessors:                                                          //
00550   //                                                                     //
00551   /////////////////////////////////////////////////////////////////////////
00552 
00553   void setArguments( const NilpotentGroup&, const Word& );
00554 
00555   int getWeight() { return weight; }
00556 
00557   // Inherited from ARCer:
00558   // bool takeControl( );
00559 
00560 
00561   /////////////////////////////////////////////////////////////////////////
00562   //                                                                     //
00563   // IPC interaction members:                                            //
00564   //                                                                     //
00565   /////////////////////////////////////////////////////////////////////////
00566 
00567   void runComputation( );
00568  
00569   void writeResults( ostream& );
00570 
00571   void readResults( istream& );
00572 
00573   
00574 private:
00575 
00576   /////////////////////////////////////////////////////////////////////////
00577   //                                                                     //
00578   // Data Members:                                                       //
00579   //                                                                     //
00580   /////////////////////////////////////////////////////////////////////////
00581 
00582   NilpotentGroup* theNG;
00583   
00584   int weight;
00585 
00586   Word theWord;
00587 };
00588 
00589 // --------------------- NGweightOfWordProblem ------------------------ //
00590 
00591 
00592 class NGweightOfWordProblem : public Supervisor
00593 {
00594 public:
00595 
00596   /////////////////////////////////////////////////////////////////////////
00597   //                                                                     //
00598   // Constructors:                                                       //
00599   //                                                                     //
00600   /////////////////////////////////////////////////////////////////////////
00601 
00602   NGweightOfWordProblem( class SMWord& );
00603 
00604 
00605   /////////////////////////////////////////////////////////////////////////
00606   //                                                                     //
00607   // Front End Interfacing:                                              //
00608   //                                                                     //
00609   /////////////////////////////////////////////////////////////////////////
00610 
00611   void viewStructure(ostream& ostr) const;  // overrides SMObject
00612 
00613 
00614   /////////////////////////////////////////////////////////////////////////
00615   //                                                                     //
00616   // Control:                                                            //
00617   //                                                                     //
00618   /////////////////////////////////////////////////////////////////////////
00619 
00620   void takeControl( );         // overrides ComputationManager
00621 
00622 
00623   /////////////////////////////////////////////////////////////////////////
00624   //                                                                     //
00625   // State Transitions:                                                  //
00626   //                                                                     //
00627   /////////////////////////////////////////////////////////////////////////
00628 
00629   void start( ) { }            // overrides ComputationManager
00630 
00631   void terminate( ) { }        // overrides ComputationManager
00632 
00633 
00634 private:
00635 
00636   /////////////////////////////////////////////////////////////////////////
00637   //                                                                     //
00638   // Data Members:                                                       //
00639   //                                                                     //
00640   /////////////////////////////////////////////////////////////////////////
00641 
00642   class SMWord& theWord;
00643 
00644   class WIC& theWIC;
00645 
00646   MirrorSubordinate computeBasis;
00647   //MirrorSubordinate computeLCSQuotientsComp;
00648   bool started;
00649   int weight;
00650   NGweightOfWordARCer arcer;
00651 };
00652 // --------------------- NGorderOfTorsionSubgroupProblem ------------------------ //
00653 
00654 
00655 class NGorderOfTorsionSubgroupProblem : public Supervisor
00656 {
00657 public:
00658 
00659   /////////////////////////////////////////////////////////////////////////
00660   //                                                                     //
00661   // Constructors:                                                       //
00662   //                                                                     //
00663   /////////////////////////////////////////////////////////////////////////
00664 
00665   NGorderOfTorsionSubgroupProblem( class SMFPGroup& );
00666 
00667 
00668   /////////////////////////////////////////////////////////////////////////
00669   //                                                                     //
00670   // Front End Interfacing:                                              //
00671   //                                                                     //
00672   /////////////////////////////////////////////////////////////////////////
00673 
00674   void viewStructure(ostream& ostr) const;  // overrides SMObject
00675 
00676 
00677   /////////////////////////////////////////////////////////////////////////
00678   //                                                                     //
00679   // Control:                                                            //
00680   //                                                                     //
00681   /////////////////////////////////////////////////////////////////////////
00682 
00683   void takeControl( );         // overrides ComputationManager
00684 
00685 
00686   /////////////////////////////////////////////////////////////////////////
00687   //                                                                     //
00688   // State Transitions:                                                  //
00689   //                                                                     //
00690   /////////////////////////////////////////////////////////////////////////
00691 
00692   void start( ) { }            // overrides ComputationManager
00693 
00694   void terminate( ) { }        // overrides ComputationManager
00695 
00696 
00697 private:
00698 
00699   /////////////////////////////////////////////////////////////////////////
00700   //                                                                     //
00701   // Data Members:                                                       //
00702   //                                                                     //
00703   /////////////////////////////////////////////////////////////////////////
00704 
00705   class SMFPGroup& theGroup;
00706 
00707   class GIC& theGIC;
00708 
00709   MirrorSubordinate computeBasis;
00710   //MirrorSubordinate computeLCSQuotientsComp;
00711   Integer order;
00712 };
00713 //-----------------------------------------------------------------//
00714 //-------------------- NGbuildPresentationProblem ----------------//
00715 //-----------------------------------------------------------------//
00716 
00717 
00718 class NGbuildPresentationProblem : public Supervisor
00719 {
00720 public:
00721 
00722   /////////////////////////////////////////////////////////////////////////
00723   //                                                                     //
00724   // Constructors:                                                       //
00725   //                                                                     //
00726   /////////////////////////////////////////////////////////////////////////
00727 
00728    NGbuildPresentationProblem(class SMFPGroup& group);
00729 
00730   /////////////////////////////////////////////////////////////////////////
00731   //                                                                     //
00732   // Accessors:                                                          //
00733   //                                                                     //
00734   /////////////////////////////////////////////////////////////////////////
00735 
00736 
00737   /////////////////////////////////////////////////////////////////////////
00738   //                                                                     //
00739   // Front End Interfacing:                                              //
00740   //                                                                     //
00741   /////////////////////////////////////////////////////////////////////////
00742 
00743   void viewStructure(ostream& ostr) const;  // overrides SMObject
00744 
00745   /////////////////////////////////////////////////////////////////////////
00746   //                                                                     //
00747   // Control:                                                            //
00748   //                                                                     //
00749   /////////////////////////////////////////////////////////////////////////
00750 
00751   void takeControl( );         // overrides ComputationManager
00752 
00753   /////////////////////////////////////////////////////////////////////////
00754   //                                                                     //
00755   // State Transitions:                                                  //
00756   //                                                                     //
00757   /////////////////////////////////////////////////////////////////////////
00758 
00759   void start( );              // overrides ComputationManager
00760 
00761   void terminate( );          // overrides ComputationManager
00762 
00763 
00764 private:
00765 
00766   /////////////////////////////////////////////////////////////////////////
00767   //                                                                     //
00768   // Data Members:                                                       //
00769   //                                                                     //
00770   /////////////////////////////////////////////////////////////////////////
00771   NGPresentationARCer arcer;
00772   class SMFPGroup& theGroup;
00773   MirrorSubordinate computeBasis;
00774   bool started;
00775 };
00776 
00777 // --------------------- NGAutoIsIAAut ------------------------ //
00778 
00779 
00780 class NGAutoIsIAAut : public Supervisor
00781 {
00782 public:
00783 
00784   /////////////////////////////////////////////////////////////////////////
00785   //                                                                     //
00786   // Constructors:                                                       //
00787   //                                                                     //
00788   /////////////////////////////////////////////////////////////////////////
00789 
00790  NGAutoIsIAAut( class SMMap& );
00791 
00792 
00793   /////////////////////////////////////////////////////////////////////////
00794   //                                                                     //
00795   // Front End Interfacing:                                              //
00796   //                                                                     //
00797   /////////////////////////////////////////////////////////////////////////
00798 
00799   void viewStructure(ostream& ostr) const;  // overrides SMObject
00800 
00801 
00802   /////////////////////////////////////////////////////////////////////////
00803   //                                                                     //
00804   // Control:                                                            //
00805   //                                                                     //
00806   /////////////////////////////////////////////////////////////////////////
00807 
00808   void takeControl( );         // overrides ComputationManager
00809 
00810 
00811   /////////////////////////////////////////////////////////////////////////
00812   //                                                                     //
00813   // State Transitions:                                                  //
00814   //                                                                     //
00815   /////////////////////////////////////////////////////////////////////////
00816 
00817   void start( ) { }            // overrides ComputationManager
00818 
00819   void terminate( ) { }        // overrides ComputationManager
00820 
00821 
00822 private:
00823 
00824   /////////////////////////////////////////////////////////////////////////
00825   //                                                                     //
00826   // Data Members:                                                       //
00827   //                                                                     //
00828   /////////////////////////////////////////////////////////////////////////
00829 
00830   class SMMap& theMap;
00831 
00832   class GIC& theGIC;
00833 
00834   MirrorSubordinate abelianInvariants;
00835 };
00836 
00837 // ----------------- NGisCentralARCer ---------------------- //
00838 
00839 class NGisCentralARCer : public ARCer
00840 {
00841 public:
00842 
00843   /////////////////////////////////////////////////////////////////////////
00844   //                                                                     //
00845   // Constructors:                                                       //
00846   //                                                                     //
00847   /////////////////////////////////////////////////////////////////////////
00848 
00849   NGisCentralARCer( ComputationManager& boss ) 
00850     : ARCer( boss ),theNG( 0 ),theAnswer(dontknow) { } 
00851   
00852   ~NGisCentralARCer( ) { delete theNG; }
00853 
00854   /////////////////////////////////////////////////////////////////////////
00855   //                                                                     //
00856   // Accessors:                                                          //
00857   //                                                                     //
00858   /////////////////////////////////////////////////////////////////////////
00859 
00860   void setArguments(const NilpotentGroup& NG, const Word& theWord );
00861   Trichotomy getAnswer() const { return theAnswer;}
00862 
00863   // Inherited from ARCer:
00864   // bool takeControl( );
00865 
00866 
00867   /////////////////////////////////////////////////////////////////////////
00868   //                                                                     //
00869   // IPC interaction members:                                            //
00870   //                                                                     //
00871   /////////////////////////////////////////////////////////////////////////
00872 
00873   void runComputation( );
00874  
00875   void writeResults( ostream& );
00876 
00877   void readResults( istream& );
00878 
00879   
00880 private:
00881 
00882   /////////////////////////////////////////////////////////////////////////
00883   //                                                                     //
00884   // Data Members:                                                       //
00885   //                                                                     //
00886   /////////////////////////////////////////////////////////////////////////
00887 
00888   NilpotentGroup* theNG;
00889   Word theWord;
00890   Trichotomy theAnswer;
00891 };
00892 //---------------------------------------------------------------------------//
00893 //-------------------- NGisCentralProblem ---------------------------//
00894 //---------------------------------------------------------------------------//
00895 
00896 
00897 class NGisCentralProblem : public Supervisor
00898 {
00899 public:
00900 
00901   /////////////////////////////////////////////////////////////////////////
00902   //                                                                     //
00903   // Constructors:                                                       //
00904   //                                                                     //
00905   /////////////////////////////////////////////////////////////////////////
00906 
00907    NGisCentralProblem( class SMWord& w);
00908 
00909   /////////////////////////////////////////////////////////////////////////
00910   //                                                                     //
00911   // Accessors:                                                          //
00912   //                                                                     //
00913   /////////////////////////////////////////////////////////////////////////
00914 
00915 
00916   /////////////////////////////////////////////////////////////////////////
00917   //                                                                     //
00918   // Front End Interfacing:                                              //
00919   //                                                                     //
00920   /////////////////////////////////////////////////////////////////////////
00921 
00922   void viewStructure(ostream& ostr) const;  // overrides SMObject
00923 
00924   /////////////////////////////////////////////////////////////////////////
00925   //                                                                     //
00926   // Control:                                                            //
00927   //                                                                     //
00928   /////////////////////////////////////////////////////////////////////////
00929 
00930   void takeControl( );         // overrides ComputationManager
00931 
00932   /////////////////////////////////////////////////////////////////////////
00933   //                                                                     //
00934   // State Transitions:                                                  //
00935   //                                                                     //
00936   /////////////////////////////////////////////////////////////////////////
00937 
00938   void start( );              // overrides ComputationManager
00939 
00940   void terminate( );          // overrides ComputationManager
00941 
00942 
00943 private:
00944 
00945   /////////////////////////////////////////////////////////////////////////
00946   //                                                                     //
00947   // Data Members:                                                       //
00948   //                                                                     //
00949   /////////////////////////////////////////////////////////////////////////
00950   NGisCentralARCer arcer;
00951   MirrorSubordinate   computeBasis;
00952   class SMWord& theWord;
00953   Trichotomy answer;
00954   bool started;
00955 };
00956 
00957 // ---------------------- NGMaximalRootARCer --------------------------- //
00958 
00959 class NGMaximalRootARCer : public ARCer
00960 {
00961 public:
00962 
00963   /////////////////////////////////////////////////////////////////////////
00964   //                                                                     //
00965   // Constructors:                                                       //
00966   //                                                                     //
00967   /////////////////////////////////////////////////////////////////////////
00968 
00969   NGMaximalRootARCer( ComputationManager& boss ) 
00970     : ARCer( boss ), NG( 0 ), thePower(0) { } 
00971 
00972   ~NGMaximalRootARCer( ) { delete NG; } 
00973 
00974 
00975   /////////////////////////////////////////////////////////////////////////
00976   //                                                                     //
00977   // Accessors:                                                          //
00978   //                                                                     //
00979   /////////////////////////////////////////////////////////////////////////
00980 
00981   void setArguments( const NilpotentGroup& group, const Word& w);
00982 
00983   // Inherited from ARCer:
00984   // bool takeControl( );
00985 
00986   int getPower() const;
00987   Word getRoot() const;
00988   
00989   
00990   /////////////////////////////////////////////////////////////////////////
00991   //                                                                     //
00992   // IPC interaction members:                                            //
00993   //                                                                     //
00994   /////////////////////////////////////////////////////////////////////////
00995 
00996   void runComputation( );
00997  
00998   void writeResults( ostream& );
00999 
01000   void readResults( istream& );
01001 
01002 
01003 private:
01004 
01005   /////////////////////////////////////////////////////////////////////////
01006   //                                                                     //
01007   // Data Members:                                                       //
01008   //                                                                     //
01009   /////////////////////////////////////////////////////////////////////////
01010 
01011   NilpotentGroup* NG;
01012   int thePower;
01013   Word theRoot;
01014   Word theWord;
01015 };
01016 
01017 //-----------------------------------------------------------------//
01018 //-------------------- NGMaximalRootProblem ----------------------//
01019 //-----------------------------------------------------------------//
01020 
01021 
01022 class NGMaximalRootProblem : public Supervisor
01023 {
01024 public:
01025 
01026   /////////////////////////////////////////////////////////////////////////
01027   //                                                                     //
01028   // Constructors:                                                       //
01029   //                                                                     //
01030   /////////////////////////////////////////////////////////////////////////
01031 
01032    NGMaximalRootProblem( class SMWord& w);
01033 
01034   /////////////////////////////////////////////////////////////////////////
01035   //                                                                     //
01036   // Accessors:                                                          //
01037   //                                                                     //
01038   /////////////////////////////////////////////////////////////////////////
01039 
01040 
01041   /////////////////////////////////////////////////////////////////////////
01042   //                                                                     //
01043   // Front End Interfacing:                                              //
01044   //                                                                     //
01045   /////////////////////////////////////////////////////////////////////////
01046 
01047   void viewStructure(ostream& ostr) const;  // overrides SMObject
01048 
01049   /////////////////////////////////////////////////////////////////////////
01050   //                                                                     //
01051   // Control:                                                            //
01052   //                                                                     //
01053   /////////////////////////////////////////////////////////////////////////
01054 
01055   void takeControl( );         // overrides ComputationManager
01056 
01057   /////////////////////////////////////////////////////////////////////////
01058   //                                                                     //
01059   // State Transitions:                                                  //
01060   //                                                                     //
01061   /////////////////////////////////////////////////////////////////////////
01062 
01063   void start( );              // overrides ComputationManager
01064 
01065   void terminate( );          // overrides ComputationManager
01066 
01067 
01068 private:
01069 
01070   /////////////////////////////////////////////////////////////////////////
01071   //                                                                     //
01072   // Data Members:                                                       //
01073   //                                                                     //
01074   /////////////////////////////////////////////////////////////////////////
01075   NGMaximalRootARCer arcer;
01076   MirrorSubordinate computeBasis;
01077   class SMWord& theWord;
01078   bool started;
01079 };
01080 
01081 //-----------------------------------------------------------------//
01082 //-------------------- NGIsProperPower ----------------------//
01083 //-----------------------------------------------------------------//
01084 
01085 
01086 class NGIsProperPower : public Supervisor
01087 {
01088 public:
01089 
01090   /////////////////////////////////////////////////////////////////////////
01091   //                                                                     //
01092   // Constructors:                                                       //
01093   //                                                                     //
01094   /////////////////////////////////////////////////////////////////////////
01095 
01096    NGIsProperPower( class SMWord& w);
01097 
01098   /////////////////////////////////////////////////////////////////////////
01099   //                                                                     //
01100   // Accessors:                                                          //
01101   //                                                                     //
01102   /////////////////////////////////////////////////////////////////////////
01103 
01104 
01105   /////////////////////////////////////////////////////////////////////////
01106   //                                                                     //
01107   // Front End Interfacing:                                              //
01108   //                                                                     //
01109   /////////////////////////////////////////////////////////////////////////
01110 
01111   void viewStructure(ostream& ostr) const;  // overrides SMObject
01112 
01113   /////////////////////////////////////////////////////////////////////////
01114   //                                                                     //
01115   // Control:                                                            //
01116   //                                                                     //
01117   /////////////////////////////////////////////////////////////////////////
01118 
01119   void takeControl( );         // overrides ComputationManager
01120 
01121   /////////////////////////////////////////////////////////////////////////
01122   //                                                                     //
01123   // State Transitions:                                                  //
01124   //                                                                     //
01125   /////////////////////////////////////////////////////////////////////////
01126 
01127   void start( );              // overrides ComputationManager
01128 
01129   void terminate( );          // overrides ComputationManager
01130 
01131 
01132 private:
01133 
01134   /////////////////////////////////////////////////////////////////////////
01135   //                                                                     //
01136   // Data Members:                                                       //
01137   //                                                                     //
01138   /////////////////////////////////////////////////////////////////////////
01139   NGMaximalRootARCer arcer;
01140   MirrorSubordinate computeBasis;
01141   class SMWord& theWord;
01142   bool started;
01143 };
01144 // ---------------------- NGInverseAutoARCer --------------------------- //
01145 
01146 
01147 class NGInverseAutoARCer : public ARCer
01148 {
01149 public:
01150 
01151   /////////////////////////////////////////////////////////////////////////
01152   //                                                                     //
01153   // Constructors:                                                       //
01154   //                                                                     //
01155   /////////////////////////////////////////////////////////////////////////
01156 
01157   NGInverseAutoARCer( ComputationManager& boss ) 
01158     : ARCer( boss ), NG( 0 ), result(0) { } 
01159 
01160   ~NGInverseAutoARCer( ) { delete NG; } 
01161 
01162 
01163   /////////////////////////////////////////////////////////////////////////
01164   //                                                                     //
01165   // Accessors:                                                          //
01166   //                                                                     //
01167   /////////////////////////////////////////////////////////////////////////
01168 
01169   void setArguments( const NilpotentGroup& group, const VectorOf<Word>& image);
01170 
01171   // Inherited from ARCer:
01172   // bool takeControl( );
01173 
01174   const VectorOf<Word> getInverse() const {return result;}
01175   
01176   
01177   /////////////////////////////////////////////////////////////////////////
01178   //                                                                     //
01179   // IPC interaction members:                                            //
01180   //                                                                     //
01181   /////////////////////////////////////////////////////////////////////////
01182 
01183   void runComputation( );
01184  
01185   void writeResults( ostream& );
01186 
01187   void readResults( istream& );
01188 
01189 
01190 private:
01191 
01192   /////////////////////////////////////////////////////////////////////////
01193   //                                                                     //
01194   // Data Members:                                                       //
01195   //                                                                     //
01196   /////////////////////////////////////////////////////////////////////////
01197 
01198   NilpotentGroup* NG;
01199   VectorOf<Word> theImages;
01200   VectorOf<Word> result;
01201 };
01202 // ---------------------- NGInverseAuto --------------------------- //
01203 
01204 class NGInverseAuto  : public Supervisor
01205 {
01206 public:
01207 
01208   /////////////////////////////////////////////////////////////////////////
01209   //                                                                     //
01210   // Constructors:                                                       //
01211   //                                                                     //
01212   /////////////////////////////////////////////////////////////////////////
01213 
01214   NGInverseAuto(const class SMHomomorphism& );
01215 
01216   /////////////////////////////////////////////////////////////////////////
01217   //                                                                     //
01218   // Front End Interfacing:                                              //
01219   //                                                                     //
01220   /////////////////////////////////////////////////////////////////////////
01221 
01222   void viewStructure(ostream& ostr) const;  // overrides SMObject
01223 
01224   /////////////////////////////////////////////////////////////////////////
01225   //                                                                     //
01226   // Control:                                                            //
01227   //                                                                     //
01228   /////////////////////////////////////////////////////////////////////////
01229 
01230   void takeControl( );         // overrides ComputationManager
01231 
01232   /////////////////////////////////////////////////////////////////////////
01233   //                                                                     //
01234   // State Transitions:                                                  //
01235   //                                                                     //
01236   /////////////////////////////////////////////////////////////////////////
01237 
01238   void start( ) { };          // overrides ComputationManager
01239 
01240   void terminate( ) { };      // overrides ComputationManager
01241 
01242 
01243 private:
01244 
01245   /////////////////////////////////////////////////////////////////////////
01246   //                                                                     //
01247   // Data Members:                                                       //
01248   //                                                                     //
01249   /////////////////////////////////////////////////////////////////////////
01250 
01251   const class SMHomomorphism& theAuto;
01252   NGInverseAutoARCer arcer;
01253 };
01254 
01255 // ---------------------- NGcentralizerARCer --------------------------- //
01256 
01257 
01258 class NGcentralizerARCer : public ARCer
01259 {
01260 public:
01261 
01262   /////////////////////////////////////////////////////////////////////////
01263   //                                                                     //
01264   // Constructors:                                                       //
01265   //                                                                     //
01266   /////////////////////////////////////////////////////////////////////////
01267 
01268   NGcentralizerARCer( ComputationManager& boss ) 
01269     : ARCer( boss ), NG( 0 ), result(0) { } 
01270 
01271   ~NGcentralizerARCer( ) { delete NG; } 
01272 
01273 
01274   /////////////////////////////////////////////////////////////////////////
01275   //                                                                     //
01276   // Accessors:                                                          //
01277   //                                                                     //
01278   /////////////////////////////////////////////////////////////////////////
01279 
01280   void setArguments( const NilpotentGroup& group, const Word& w);
01281 
01282   // Inherited from ARCer:
01283   // bool takeControl( );
01284 
01285   const VectorOf<Word>& getCentralizer() const;
01286   
01287   
01288   /////////////////////////////////////////////////////////////////////////
01289   //                                                                     //
01290   // IPC interaction members:                                            //
01291   //                                                                     //
01292   /////////////////////////////////////////////////////////////////////////
01293 
01294   void runComputation( );
01295  
01296   void writeResults( ostream& );
01297 
01298   void readResults( istream& );
01299 
01300 
01301 private:
01302 
01303   /////////////////////////////////////////////////////////////////////////
01304   //                                                                     //
01305   // Data Members:                                                       //
01306   //                                                                     //
01307   /////////////////////////////////////////////////////////////////////////
01308 
01309   NilpotentGroup* NG;
01310   Word theWord;
01311   VectorOf<Word> result;
01312 };
01313 // ---------------------- NGcentralizer --------------------------- //
01314 
01315 class NGcentralizer  : public Supervisor
01316 {
01317 public:
01318 
01319   /////////////////////////////////////////////////////////////////////////
01320   //                                                                     //
01321   // Constructors:                                                       //
01322   //                                                                     //
01323   /////////////////////////////////////////////////////////////////////////
01324 
01325   NGcentralizer( class SMWord& );
01326 
01327   /////////////////////////////////////////////////////////////////////////
01328   //                                                                     //
01329   // Front End Interfacing:                                              //
01330   //                                                                     //
01331   /////////////////////////////////////////////////////////////////////////
01332 
01333   void viewStructure(ostream& ostr) const;  // overrides SMObject
01334 
01335   /////////////////////////////////////////////////////////////////////////
01336   //                                                                     //
01337   // Control:                                                            //
01338   //                                                                     //
01339   /////////////////////////////////////////////////////////////////////////
01340 
01341   void takeControl( );         // overrides ComputationManager
01342 
01343   /////////////////////////////////////////////////////////////////////////
01344   //                                                                     //
01345   // State Transitions:                                                  //
01346   //                                                                     //
01347   /////////////////////////////////////////////////////////////////////////
01348 
01349   void start( ) { };          // overrides ComputationManager
01350 
01351   void terminate( ) { };      // overrides ComputationManager
01352 
01353 
01354 private:
01355 
01356   /////////////////////////////////////////////////////////////////////////
01357   //                                                                     //
01358   // Data Members:                                                       //
01359   //                                                                     //
01360   /////////////////////////////////////////////////////////////////////////
01361 
01362   NGcentralizerARCer arcer;
01363   MirrorSubordinate computeBasis;
01364   class SMWord& theWord;
01365   bool started;
01366 };
01367 
01368 // ---------------------- NGIsomorphismARCer --------------------------- //
01369 
01370 class NGIsomorphismARCer : public ARCer
01371 {
01372 public:
01373 
01374   /////////////////////////////////////////////////////////////////////////
01375   //                                                                     //
01376   // Constructors:                                                       //
01377   //                                                                     //
01378   /////////////////////////////////////////////////////////////////////////
01379 
01380   NGIsomorphismARCer( ComputationManager& boss ) 
01381     : ARCer( boss ),
01382       g1( ),
01383       g2( ),
01384       ans(dontknow)
01385     { } 
01386 
01387   /////////////////////////////////////////////////////////////////////////
01388   //                                                                     //
01389   // Accessors:                                                          //
01390   //                                                                     //
01391   /////////////////////////////////////////////////////////////////////////
01392 
01393   void setArguments( const FPGroup& gr1 , const FPGroup& gr2 , 
01394                      int n1 , int n2 );
01395 
01396   // Inherited from ARCer:
01397   // bool takeControl( );
01398 
01399   Trichotomy getAnswer() const
01400     {
01401       return ans;
01402     }
01403   
01404   /////////////////////////////////////////////////////////////////////////
01405   //                                                                     //
01406   // IPC interaction members:                                            //
01407   //                                                                     //
01408   /////////////////////////////////////////////////////////////////////////
01409 
01410   void runComputation( );
01411  
01412   void writeResults( ostream& );
01413 
01414   void readResults( istream& );
01415 
01416 
01417 private:
01418 
01419   /////////////////////////////////////////////////////////////////////////
01420   //                                                                     //
01421   // Data Members:                                                       //
01422   //                                                                     //
01423   /////////////////////////////////////////////////////////////////////////
01424 
01425   FPGroup g1;
01426   FPGroup g2;
01427   int nc1;
01428   int nc2;
01429   Trichotomy ans;
01430 };
01431 
01432 // ------------------------- NGIsomorphismProblem ------------------------- //
01433 
01434 class NGIsomorphismProblem  : public ComputationManager
01435 {
01436 public:
01437 
01438   /////////////////////////////////////////////////////////////////////////
01439   //                                                                     //
01440   // Constructors:                                                       //
01441   //                                                                     //
01442   /////////////////////////////////////////////////////////////////////////
01443 
01444   NGIsomorphismProblem( class SMFPGroup& , class SMFPGroup& );
01445 
01446   /////////////////////////////////////////////////////////////////////////
01447   //                                                                     //
01448   // Front End Interfacing:                                              //
01449   //                                                                     //
01450   /////////////////////////////////////////////////////////////////////////
01451 
01452   void viewStructure(ostream& ostr) const;  // overrides SMObject
01453 
01454   /////////////////////////////////////////////////////////////////////////
01455   //                                                                     //
01456   // Control:                                                            //
01457   //                                                                     //
01458   /////////////////////////////////////////////////////////////////////////
01459 
01460   void takeControl( );         // overrides ComputationManager
01461 
01462   /////////////////////////////////////////////////////////////////////////
01463   //                                                                     //
01464   // State Transitions:                                                  //
01465   //                                                                     //
01466   /////////////////////////////////////////////////////////////////////////
01467 
01468   void start( ) { };          // overrides ComputationManager
01469 
01470   void terminate( ) { };      // overrides ComputationManager
01471 
01472 
01473 private:
01474 
01475   /////////////////////////////////////////////////////////////////////////
01476   //                                                                     //
01477   // Data Members:                                                       //
01478   //                                                                     //
01479   /////////////////////////////////////////////////////////////////////////
01480 
01481   NGIsomorphismARCer arcer;
01482   SMFPGroup& theGroup1;
01483   SMFPGroup& theGroup2;
01484 
01485   int flag;
01486 };
01487 
01488 #endif

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