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

/magnus/back_end/SMApps/include/fastProblems.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: 
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 CM classes for fast problems
00009 //
00010 // Principal Author: Roger Needham, Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Revision History:
00015 //
00016 // * 10/11/96 @ep added:
00017 //          class SGOfFreeWhiteheadReduction : public FastComputation
00018 //          class SGOfFreeIsAFreeFactor : public FastComputation
00019 //
00020 //  * 10/09/96 @dp added:
00021 //      class FreeGetNextN_thElement : public FastComputation
00022 //      class TerminalSegmentOfWord : public FastComputation
00023 //      class SegmentOfWord : public FastComputation
00024 //
00025 //  * 10/16/96 @dp added:
00026 //      class APOfFreeNumberOfSubstitutions : public FastComputation
00027 //      class SGOfFreeIsMalnormal : public FastComputation
00028 //      class APOfFree_DoEltsCommute : public FastComputation
00029 //      class APOfFreeIsHyperbolic : public FastComputation
00030 //
00031 //  * 04/06/97 @dp added:
00032 //      class SGOfFreeRank : public FastComputation
00033 //      class WordInNielsenBasisSGOfFree : public FastComputation
00034 //
00035 // Each derivative of class FastComputation has merely a ctor which takes
00036 // the SMObject argument(s), data members to store them, and the
00037 // `takeControl' method. It would involve less typing at least to factor
00038 // out all but the last in a base class parameterized by an int, then
00039 // specialize `takeControl' for values of the int. But of course gcc
00040 // 2.6.3 can't handle template method specialization.
00041 
00042 
00043 #ifndef _FASTPROBLEMS_H_
00044 #define _FASTPROBLEMS_H_
00045 
00046 
00047 #include "ComputationManager.h"
00048 #include "Word.h"
00049 #include "SMVectorOfWords.h"
00050 #include "SMEnumerator.h"
00051 
00052 //---------------------------------------------------------------------------//
00053 //------------------------- FastComputation ---------------------------------//
00054 //---------------------------------------------------------------------------//
00055 
00056 
00057 class FastComputation : public ComputationManager
00058 {
00059 public:
00060 
00061   FastComputation( );
00062 
00063   void readMessage(class istream &) { }       // overrides SMObject
00064 
00065   void viewStructure(ostream& ostr) const;    // overrides SMObject
00066 
00067   void start( ) { }                           // overrides ComputationManager
00068 
00069   void terminate( ) { }                       // overrides ComputationManager
00070 };
00071 
00072 
00073 //---------------------------------------------------------------------------//
00074 //--------------------- Free Group Computations -----------------------------//
00075 //---------------------------------------------------------------------------//
00076 
00077 
00078 class CommutatorInFree : public FastComputation
00079 {
00080 public:
00081 
00082   CommutatorInFree(const class SMWord& w) : theWord( w ) { }
00083 
00084   void takeControl( );              // overrides ComputationManager
00085 
00086 private:
00087 
00088   const class SMWord& theWord;
00089 };
00090 
00091 
00092 class FreeInCommutatorSG : public FastComputation
00093 {
00094 public:
00095 
00096   FreeInCommutatorSG(const class SMWord& w) : theWord( w ) { }
00097 
00098   void takeControl( );              // overrides ComputationManager
00099 
00100 private:
00101 
00102   const class SMWord& theWord;
00103 };
00104 
00105 class ProductOfCommutators : public FastComputation
00106 {
00107 public:
00108 
00109   ProductOfCommutators(const class SMWord& w) : 
00110     theWord( w ),
00111     theFile( )
00112     { }
00113 
00114   void takeControl( );              // overrides ComputationManager
00115 
00116 private:
00117 
00118   const class SMWord& theWord;
00119   File theFile;
00120 };
00121 
00122 class ProductOfSquares : public FastComputation
00123 {
00124 public:
00125 
00126   ProductOfSquares(const class SMWord& w) : 
00127     theWord( w ),
00128     theFile( )
00129     { }
00130 
00131   void takeControl( );              // overrides ComputationManager
00132 
00133 private:
00134 
00135   const class SMWord& theWord;
00136   File theFile;
00137 };
00138 
00139 class FreeIsElementAProperPower : public FastComputation
00140 {
00141 public:
00142 
00143   FreeIsElementAProperPower(const class SMWord& w) : theWord( w ) { }
00144 
00145   void takeControl( );              // overrides ComputationManager
00146 
00147 private:
00148 
00149   const class SMWord& theWord;
00150 };
00151 
00152 
00153 class FreeMaximalRootOfElement : public FastComputation
00154 {
00155 public:
00156 
00157   FreeMaximalRootOfElement(const class SMWord& w) : theWord( w ) { }
00158 
00159   void takeControl( );              // overrides ComputationManager
00160 
00161 private:
00162 
00163   const class SMWord& theWord;
00164 };
00165 
00166 
00167 class FreeCentolizerOfElement : public FastComputation
00168 {
00169 public:
00170 
00171   FreeCentolizerOfElement(const class SMWord& w) : theWord( w ) { }
00172 
00173   void takeControl( );              // overrides ComputationManager
00174 
00175 private:
00176 
00177   const class SMWord& theWord;
00178 };
00179 
00180 class FreeGetN_thElement : public FastComputation
00181 {
00182 public:
00183 
00184   FreeGetN_thElement( class SMFPGroup& G, int n = 0 ) : 
00185     theGroup( G ), theNumber( n ) { }
00186 
00187   void takeControl( );              // overrides ComputationManager
00188 
00189 private:
00190 
00191   class SMFPGroup& theGroup;
00192   int theNumber;
00193 };
00194 
00195 class FreeGetNextN_thElement : public FastComputation
00196 {
00197 public:
00198 
00199   FreeGetNextN_thElement( class SMWord& w, int n = 0 ) : 
00200     theWord( w ), theNumber( n ) { }
00201 
00202   void takeControl( );              // overrides ComputationManager
00203 
00204 private:
00205 
00206   class SMWord& theWord;
00207   int theNumber;
00208 };
00209 
00210 
00211 class WordProblemInFree : public FastComputation
00212 {
00213 public:
00214 
00215   WordProblemInFree(const class SMWord& w) : theWord( w ) { }
00216 
00217   void takeControl( );              // overrides ComputationManager
00218 
00219 private:
00220 
00221   const class SMWord& theWord;
00222 };
00223 
00224 
00225 class WordsAreEqual : public FastComputation
00226 {
00227 public:
00228 
00229   WordsAreEqual(const class SMWord& w1, const class SMWord& w2)
00230     : word1( w1 ), word2( w2 )
00231   { }
00232 
00233   void takeControl( );              // overrides ComputationManager
00234 
00235 private:
00236 
00237   const class SMWord& word1;
00238   const class SMWord& word2;
00239 };
00240 
00241 
00242 class EndoOnFreeIsMono : public FastComputation
00243 {
00244 public:
00245 
00246   EndoOnFreeIsMono( class SMMap& m ) : map( m ) { }
00247 
00248   void takeControl( );              // overrides ComputationManager
00249 
00250 private:
00251 
00252   class SMMap& map;
00253 };
00254 
00255 
00256 class EndoOnFreeIsEpi : public FastComputation
00257 {
00258 public:
00259 
00260   EndoOnFreeIsEpi( class SMMap& m ) : map( m ) { }
00261 
00262   void takeControl( );              // overrides ComputationManager
00263 
00264 private:
00265 
00266   class SMMap& map;
00267 };
00268 
00269 
00270 class EndoOnFreeIsAut : public FastComputation
00271 {
00272 public:
00273 
00274   EndoOnFreeIsAut(const class SMMap& m) : map( m ) { }
00275 
00276   void takeControl( );              // overrides ComputationManager
00277 
00278 private:
00279 
00280   const class SMMap& map;
00281 };
00282 
00283 
00284 class EndoOnFreeIsInner : public FastComputation
00285 {
00286 public:
00287 
00288   EndoOnFreeIsInner(const class SMMap& m) : map( m ) { }
00289 
00290   void takeControl( );              // overrides ComputationManager
00291 
00292 private:
00293 
00294   const class SMMap& map;
00295 };
00296 
00297 class EndoOnFreeIsIAAut : public FastComputation
00298 {
00299 public:
00300 
00301   EndoOnFreeIsIAAut(const class SMMap& m) : map( m ) { }
00302 
00303   void takeControl( );              // overrides ComputationManager
00304 
00305 private:
00306 
00307   const class SMMap& map;
00308 };
00309 
00310 
00311 class InverseAuto : public FastComputation
00312 {
00313 public:
00314 
00315   InverseAuto(const class SMMap& m) : map( m ) { }
00316 
00317   void takeControl( );              // overrides ComputationManager
00318 
00319 private:
00320 
00321   const class SMMap& map;
00322 };
00323 
00324 class AutoWhiteheadDecomposition : public FastComputation
00325 {
00326 public:
00327 
00328   AutoWhiteheadDecomposition(const class SMMap& m) : map( m ) { }
00329 
00330   void takeControl( );              // overrides ComputationManager
00331 
00332 private:
00333 
00334   const class SMMap& map;
00335 };
00336 
00337 
00338 class WordInSGOfFree : public FastComputation
00339 {
00340 public:
00341 
00342   WordInSGOfFree(const class SMSubgroup& S, const class SMWord& w)
00343     : word( w ), subgroup( S )
00344   { }
00345 
00346   void takeControl( );              // overrides ComputationManager
00347 
00348 private:
00349 
00350   const class SMWord& word;
00351   const class SMSubgroup& subgroup;
00352 };
00353 
00354 
00355 class PowerOfWordInSGOfFree : public FastComputation
00356 {
00357 public:
00358 
00359   PowerOfWordInSGOfFree(const class SMSubgroup& S, const class SMWord& w)
00360     : word( w ), subgroup( S )
00361   { }
00362 
00363   void takeControl( );              // overrides ComputationManager
00364 
00365 private:
00366 
00367   const class SMWord& word;
00368   const class SMSubgroup& subgroup;
00369 };
00370 
00371 
00372 class ConjugacyProblemInFree : public FastComputation
00373 {
00374 public:
00375 
00376   ConjugacyProblemInFree(const class SMWord& w1, const class SMWord& w2)
00377     : word1( w1 ), word2( w2 )
00378   { }
00379 
00380   void takeControl( );              // overrides ComputationManager
00381 
00382 private:
00383 
00384   const class SMWord& word1;
00385   const class SMWord& word2;
00386 };
00387 
00388 class ConjugateOfWordInSGOfFree : public FastComputation
00389 {
00390 public:
00391 
00392   ConjugateOfWordInSGOfFree(const class SMSubgroup& S, const class SMWord& w)
00393     : word( w ), subgroup( S )
00394   { }
00395 
00396   void takeControl( );              // overrides ComputationManager
00397 
00398 private:
00399 
00400   const class SMWord& word;
00401   const class SMSubgroup& subgroup;
00402 };
00403 
00404 
00405 class WordInNielsenBasisSGOfFree : public FastComputation
00406 {
00407 public:
00408 
00409   WordInNielsenBasisSGOfFree(const class SMSubgroup& S, const class SMWord& w)
00410     : word( w ), subgroup( S )
00411   { }
00412 
00413   void takeControl( );              // overrides ComputationManager
00414 
00415 private:
00416 
00417   const class SMWord& word;
00418   const class SMSubgroup& subgroup;
00419 };
00420 
00421 class SchreierRepOfWordInSGOfFree : public FastComputation
00422 {
00423 public:
00424 
00425   SchreierRepOfWordInSGOfFree(const class SMSubgroup& S, const class SMWord& w)
00426     : word( w ), subgroup( S )
00427   { }
00428 
00429   void takeControl( );              // overrides ComputationManager
00430 
00431 private:
00432 
00433   const class SMWord& word;
00434   const class SMSubgroup& subgroup;
00435 };
00436 
00437 
00438 class SGOfFreeContainment : public FastComputation
00439 {
00440 public:
00441 
00442   SGOfFreeContainment(const class SMSubgroup& S1, const class SMSubgroup& S2)
00443     : subgroup1( S1 ), subgroup2( S2 )
00444   { }
00445 
00446   void takeControl( );              // overrides ComputationManager
00447 
00448 private:
00449 
00450   const class SMSubgroup& subgroup1;
00451   const class SMSubgroup& subgroup2;
00452 };
00453 
00454 
00455 class SGOfFreeAreEqual : public FastComputation
00456 {
00457 public:
00458 
00459   SGOfFreeAreEqual(const class SMSubgroup& S1, const class SMSubgroup& S2)
00460     : subgroup1( S1 ), subgroup2( S2 )
00461   { }
00462 
00463   void takeControl( );              // overrides ComputationManager
00464 
00465 private:
00466 
00467   const class SMSubgroup& subgroup1;
00468   const class SMSubgroup& subgroup2;
00469 };
00470 
00471 
00472 
00473 
00474 class SGOfFreeJoin : public FastComputation
00475 {
00476 public:
00477 
00478   SGOfFreeJoin(const class SMSubgroup& S1, const class SMSubgroup& S2)
00479     : subgroup1( S1 ), subgroup2( S2 )
00480   { }
00481 
00482   void takeControl( );              // overrides ComputationManager
00483 
00484 private:
00485 
00486   const class SMSubgroup& subgroup1;
00487   const class SMSubgroup& subgroup2;
00488 };
00489 
00490 
00491 
00492 class SGOfFreeIntersection : public FastComputation
00493 {
00494 public:
00495 
00496   SGOfFreeIntersection(const class SMSubgroup& S1, const class SMSubgroup& S2)
00497     : subgroup1( S1 ), subgroup2( S2 )
00498   { }
00499 
00500   void takeControl( );              // overrides ComputationManager
00501 
00502 private:
00503 
00504   const class SMSubgroup& subgroup1;
00505   const class SMSubgroup& subgroup2;
00506 };
00507 
00508 
00509 class SGOfFreeIsNormal : public FastComputation
00510 {
00511 public:
00512 
00513   SGOfFreeIsNormal( class SMSubgroup& S) : subgroup( S ) { }
00514 
00515   void takeControl( );              // overrides ComputationManager
00516 
00517 private:
00518 
00519   class SMSubgroup& subgroup;
00520 };
00521 
00522 
00523 class SGOfFreeIsAFreeFactor : public FastComputation
00524 {
00525 public:
00526 
00527   SGOfFreeIsAFreeFactor(const class SMSubgroup& S) : subgroup( S ) { }
00528 
00529   void takeControl( );              // overrides ComputationManager
00530 
00531 private:
00532 
00533   const class SMSubgroup& subgroup;
00534 };
00535 
00536 
00537 class SGOfFreeIsMalnormal : public FastComputation
00538 {
00539 public:
00540 
00541   SGOfFreeIsMalnormal(const class SMSubgroup& S) : subgroup( S ) { }
00542 
00543   void takeControl( );              // overrides ComputationManager
00544 
00545 private:
00546 
00547   const class SMSubgroup& subgroup;
00548 };
00549 
00550 
00551 class QuadEquationSurfaceForm : public FastComputation
00552 {
00553 public:
00554 
00555   QuadEquationSurfaceForm(const class SMEquation& S) : equation( S ) { }
00556 
00557   void takeControl( );              // overrides ComputationManager
00558 
00559 private:
00560 
00561   const class SMEquation& equation;
00562 };
00563 
00564 
00565 class SGOfFreeWhiteheadReduction : public FastComputation
00566 {
00567 public:
00568 
00569   SGOfFreeWhiteheadReduction(const class SMVectorOfWords& S) : vect( S ) { }
00570 
00571   void takeControl( );              // overrides ComputationManager
00572 
00573 private:
00574 
00575   const class SMVectorOfWords& vect;
00576 };
00577 
00578 
00579 class SGOfFreeNielsenBasis : public FastComputation
00580 {
00581 public:
00582 
00583   SGOfFreeNielsenBasis(const class SMSubgroup& S) : subgroup( S ) { }
00584 
00585   void takeControl( );              // overrides ComputationManager
00586 
00587 private:
00588 
00589   const class SMSubgroup& subgroup;
00590 };
00591 
00592 
00593 class SGOfFreeIndex : public FastComputation
00594 {
00595 public:
00596 
00597   SGOfFreeIndex(const class SMSubgroup& S) : subgroup( S ) { }
00598 
00599   void takeControl( );              // overrides ComputationManager
00600 
00601 private:
00602 
00603   const class SMSubgroup& subgroup;
00604 };
00605 
00606 class SGOfFreeRank : public FastComputation
00607 {
00608 public:
00609 
00610   SGOfFreeRank(const class SMSubgroup& S) : subgroup( S ) { }
00611 
00612   void takeControl( );              // overrides ComputationManager
00613 
00614 private:
00615 
00616   const class SMSubgroup& subgroup;
00617 };
00618 
00619 
00620 class SGOfFreeNormaliser : public FastComputation
00621 {
00622 public:
00623 
00624   SGOfFreeNormaliser(const class SMSubgroup& S) : subgroup( S ) { }
00625 
00626   void takeControl( );              // overrides ComputationManager
00627 
00628 private:
00629 
00630   const class SMSubgroup& subgroup;
00631 };
00632 
00633 
00634 class SGOfFreeHallCompletion : public FastComputation
00635 {
00636 public:
00637 
00638   SGOfFreeHallCompletion(const class SMSubgroup& S) : subgroup( S ) { }
00639 
00640   void takeControl( );              // overrides ComputationManager
00641 
00642 private:
00643 
00644   const class SMSubgroup& subgroup;
00645 };
00646 
00647 
00648 class FreeIsSGTrivial : public FastComputation
00649 {
00650 public:
00651 
00652   FreeIsSGTrivial(const class SMSubgroup& S) : subgroup( S ) { }
00653 
00654   void takeControl( );              // overrides ComputationManager
00655 
00656 private:
00657 
00658   const class SMSubgroup& subgroup;
00659 };
00660 
00661 
00662 class FreeIsAutomatic : public FastComputation
00663 {
00664 public:
00665 
00666   FreeIsAutomatic(const class SMFPGroup& G) : group( G ) { }
00667 
00668   void takeControl( );              // overrides ComputationManager
00669 
00670 private:
00671 
00672   const class SMFPGroup& group;
00673 };
00674 
00675 //---------------------------------------------------------------------------//
00676 //---------------------- Misc Fast Computations -----------------------------//
00677 //---------------------------------------------------------------------------//
00678 
00679 
00680 
00681 class FreelyReduceWord : public FastComputation
00682 {
00683 public:
00684 
00685   FreelyReduceWord(const class SMWord& w) : theWord( w ) { }
00686 
00687   void takeControl( );              // overrides ComputationManager
00688 
00689 private:
00690 
00691   const class SMWord& theWord;
00692 };
00693 
00694 
00695 class CyclicallyReduceWord : public FastComputation
00696 {
00697 public:
00698 
00699   CyclicallyReduceWord(const class SMWord& w) : theWord( w ) { }
00700 
00701   void takeControl( );              // overrides ComputationManager
00702 
00703 private:
00704 
00705   const class SMWord& theWord;
00706 };
00707 
00708 
00709 class FormalInverseOfWord : public FastComputation
00710 {
00711 public:
00712 
00713   FormalInverseOfWord(const class SMWord& w) : theWord( w ) { }
00714 
00715   void takeControl( );              // overrides ComputationManager
00716 
00717 private:
00718 
00719   const class SMWord& theWord;
00720 };
00721 
00722 
00723 class WordLength : public FastComputation
00724 {
00725 public:
00726 
00727   WordLength( const class SMWord& w )
00728     : theWord ( w ) 
00729   { }
00730   
00731   void takeControl( );              // overrides ComputationManager  
00732   
00733 private:
00734   
00735   const SMWord& theWord;
00736 };
00737 
00738 
00739 class InitialSegmentOfWord : public FastComputation
00740 {
00741 public:
00742 
00743   InitialSegmentOfWord(const class SMWord& w, int length = 1) : 
00744     theWord( w ), theLength( length ) { }
00745 
00746   void takeControl( );              // overrides ComputationManager
00747 
00748 private:
00749 
00750   const class SMWord& theWord;
00751   int theLength;
00752 };
00753 
00754 class TerminalSegmentOfWord : public FastComputation
00755 {
00756 public:
00757 
00758   TerminalSegmentOfWord(const class SMWord& w, int length = 1) : 
00759     theWord( w ), theLength( length ) { }
00760 
00761   void takeControl( );              // overrides ComputationManager
00762 
00763 private:
00764 
00765   const class SMWord& theWord;
00766   int theLength;
00767 };
00768 
00769 class SegmentOfWord : public FastComputation
00770 {
00771 public:
00772 
00773   SegmentOfWord(const class SMWord& w, int start = 1, int length = 1) : 
00774     // @dp bogus ctor in gcc 2.7.2.1: don't work without default parameters!!!
00775     theWord( w ), theStart( start ), theLength( length ) { }
00776 
00777   void takeControl( );              // overrides ComputationManager
00778 
00779 private:
00780 
00781   const class SMWord& theWord;
00782   int theStart;
00783   int theLength;
00784 };
00785 
00786 
00787 class FormalProductOfWords : public FastComputation
00788 {
00789 public:
00790 
00791   FormalProductOfWords(const class SMWord& w1, const class SMWord& w2)
00792     : word1( w1 ), word2( w2 )
00793   { }
00794 
00795   void takeControl( );              // overrides ComputationManager
00796 
00797 private:
00798 
00799   const class SMWord& word1;
00800   const class SMWord& word2;
00801 };
00802 
00803 
00804 class ConjugateOfWord : public FastComputation
00805 {
00806 public:
00807 
00808   ConjugateOfWord(const class SMWord& w1, const class SMWord& w2)
00809     : theWord1( w1 ), theWord2( w2 )
00810   { }
00811 
00812   void takeControl( );              // overrides ComputationManager
00813 
00814 private:
00815 
00816   const class SMWord& theWord1;
00817   const class SMWord& theWord2;
00818 };
00819 
00820 
00821 class CommutatorOfWords : public FastComputation
00822 {
00823 public:
00824 
00825   CommutatorOfWords(const class SMWord& w1, const class SMWord& w2)
00826     : theWord1( w1 ), theWord2( w2 )
00827   { }
00828 
00829   void takeControl( );              // overrides ComputationManager
00830 
00831 private:
00832 
00833   const class SMWord& theWord1;
00834   const class SMWord& theWord2;
00835 };
00836 
00837 
00838 class PowerOfMap : public FastComputation
00839 {
00840 public:
00841 
00842   PowerOfMap(const class SMMap& m, int p) : map( m ), power( p ) { }
00843 
00844   PowerOfMap(const class SMMap& m) : map( m ) { }
00845   //@rn Bogus ctor; see `But no' comment in Menu.h.
00846 
00847   void takeControl( );              // overrides ComputationManager
00848 
00849 private:
00850 
00851   const class SMMap& map;
00852   int power;
00853 };
00854 
00855 
00856 class ComposeMaps : public FastComputation
00857 {
00858 public:
00859 
00860   ComposeMaps(const class SMMap& m1, const class SMMap& m2)
00861     : map1( m1 ), map2( m2 )
00862   { }
00863 
00864   void takeControl( );              // overrides ComputationManager
00865 
00866 private:
00867 
00868   const class SMMap& map1;
00869   const class SMMap& map2;
00870 };
00871 
00872 
00873 class FreeAreHomsEqual : public FastComputation
00874 {
00875 public:
00876 
00877   FreeAreHomsEqual(const class SMMap& m1, const class SMMap& m2)
00878     : map1( m1 ), map2( m2 )
00879   { }
00880 
00881   void takeControl( );              // overrides ComputationManager
00882 
00883 private:
00884 
00885   const class SMMap& map1;
00886   const class SMMap& map2;
00887 };
00888 
00889 
00890 class ImageUnderMap : public FastComputation
00891 {
00892 public:
00893 
00894   ImageUnderMap(const class SMMap& m, const class SMWord& w)
00895     : map( m ), word( w )
00896   { }
00897 
00898   void takeControl( );              // overrides ComputationManager
00899 
00900 private:
00901 
00902   const class SMMap& map;
00903   const class SMWord& word;
00904 };
00905 
00906 
00907 class SGImageUnderMap : public FastComputation
00908 {
00909 public:
00910 
00911   SGImageUnderMap(const class SMMap& m, const class SMSubgroup& S)
00912     : map( m ), subgroup( S )
00913   { }
00914 
00915   void takeControl( );              // overrides ComputationManager
00916 
00917 private:
00918 
00919   const class SMMap& map;
00920   const class SMSubgroup& subgroup;
00921 };
00922 
00923 
00924 class ExtendFreeByAut : public FastComputation
00925 {
00926 public:
00927 
00928   ExtendFreeByAut(const class SMMap& m);
00929 
00930   void takeControl( );              // overrides ComputationManager
00931 
00932 private:
00933 
00934   const class SMFPGroup& theGroup;
00935   const class SMMap& theMap;
00936 };
00937 
00938 
00939 class FPIsMSC : public FastComputation
00940 {
00941 public:
00942 
00943   FPIsMSC(class SMFPGroup& G) : theGroup( G ) { }
00944 
00945   void takeControl( );              // overrides ComputationManager
00946 
00947 private:
00948 
00949   class SMFPGroup& theGroup;
00950 };
00951 
00952 
00953 class FastHomology : public FastComputation
00954 {
00955 public:
00956 
00957   // This handles all integral homology computations which are `hard-wired',
00958   // i.e., do not rely on other, potentially expensive computations, like
00959   // a rewrite system.
00960   // Envisaged thus far are one-relator, and abelian groups.
00961 
00962   FastHomology(class SMFPGroup& G) : theGroup( G ) { }
00963 
00964   void takeControl( );              // overrides ComputationManager
00965 
00966 private:
00967 
00968   class SMFPGroup& theGroup;
00969 };
00970 
00971 
00972 //--------------------- Abelian Group Computations --------------------------//
00973 
00974 
00975 class FastAbelianForm : public FastComputation
00976 {
00977 public:
00978 
00979   FastAbelianForm(const class SMWord& w) : theWord( w ) { }
00980 
00981   void takeControl( );              // overrides ComputationManager
00982 
00983 private:
00984 
00985   const class SMWord& theWord;
00986 };
00987 
00988 
00989 class FastInverseInAbelianForm : public FastComputation
00990 {
00991 public:
00992 
00993   FastInverseInAbelianForm(const class SMWord& w) : theWord( w ) { }
00994 
00995   void takeControl( );              // overrides ComputationManager
00996 
00997 private:
00998 
00999   const class SMWord& theWord;
01000 };
01001 
01002 
01003 class ProductInAbelianForm : public FastComputation
01004 {
01005 public:
01006 
01007   ProductInAbelianForm(const class SMWord& w1, const class SMWord& w2)
01008     : word1( w1 ), word2( w2 )
01009   { }
01010 
01011   void takeControl( );              // overrides ComputationManager
01012 
01013 private:
01014 
01015   const class SMWord& word1;
01016   const class SMWord& word2;
01017 };
01018 
01019 class AbelianSGJoin : public FastComputation
01020 {
01021 public:
01022 
01023   AbelianSGJoin(const class SMSubgroup& S1, const class SMSubgroup& S2)
01024     : subgroup1( S1 ), subgroup2( S2 )
01025   { }
01026 
01027   void takeControl( );              // overrides ComputationManager
01028 
01029 private:
01030 
01031   const class SMSubgroup& subgroup1;
01032   const class SMSubgroup& subgroup2;
01033 };
01034 
01035 //----------------------- MSC Group Computations ----------------------------//
01036 
01037 
01038 class MSCOrder : public FastComputation
01039 {
01040 public:
01041 
01042   MSCOrder(class SMFPGroup& G) : theGroup( G ) { }
01043 
01044   void takeControl( );              // overrides ComputationManager
01045 
01046 private:
01047 
01048   class SMFPGroup& theGroup;
01049 };
01050 
01051 
01052 class MSCIsTrivial : public FastComputation
01053 {
01054 public:
01055 
01056   MSCIsTrivial(class SMFPGroup& G) : theGroup( G ) { }
01057 
01058   void takeControl( );              // overrides ComputationManager
01059 
01060 private:
01061 
01062   class SMFPGroup& theGroup;
01063 };
01064 
01065 
01066 class MSCIsFinite : public FastComputation
01067 {
01068 public:
01069 
01070   MSCIsFinite(class SMFPGroup& G) : theGroup( G ) { }
01071 
01072   void takeControl( );              // overrides ComputationManager
01073 
01074 private:
01075 
01076   class SMFPGroup& theGroup;
01077 };
01078 
01079 
01080 class MSCIsAbelian : public FastComputation
01081 {
01082 public:
01083 
01084   MSCIsAbelian(class SMFPGroup& G) : theGroup( G ) { }
01085 
01086   void takeControl( );              // overrides ComputationManager
01087 
01088 private:
01089 
01090   class SMFPGroup& theGroup;
01091 };
01092 
01093 
01094 // ------------------ One Relator Group Computations ----------------------- //
01095 
01096 
01097 class ORIsTrivial : public FastComputation
01098 {
01099 public:
01100 
01101   ORIsTrivial(class SMFPGroup& G) : theGroup( G ) { }
01102 
01103   void takeControl( );              // overrides ComputationManager
01104 
01105 private:
01106 
01107   class SMFPGroup& theGroup;
01108 };
01109 
01110 
01111 class ORIsFinite : public FastComputation
01112 {
01113 public:
01114 
01115   ORIsFinite(class SMFPGroup& G) : theGroup( G ) { }
01116 
01117   void takeControl( );              // overrides ComputationManager
01118 
01119 private:
01120 
01121   class SMFPGroup& theGroup;
01122 };
01123 
01124 
01125 class ORIsAbelian : public FastComputation
01126 {
01127 public:
01128 
01129   ORIsAbelian(class SMFPGroup& G) : theGroup( G ) { }
01130 
01131   void takeControl( );              // overrides ComputationManager
01132 
01133 private:
01134 
01135   class SMFPGroup& theGroup;
01136 };
01137 
01138 
01139 class OROrder : public FastComputation
01140 {
01141 public:
01142 
01143   OROrder(class SMFPGroup& G) : theGroup( G ) { }
01144 
01145   void takeControl( );              // overrides ComputationManager
01146 
01147 private:
01148 
01149   class SMFPGroup& theGroup;
01150 };
01151 
01152 
01153 class ORWithTorsionEltFiniteOrder : public FastComputation
01154 {
01155 public:
01156 
01157   ORWithTorsionEltFiniteOrder(class SMWord& w) : theWord( w ) { }
01158 
01159   void takeControl( );              // overrides ComputationManager
01160 
01161 private:
01162 
01163   class SMWord& theWord;
01164 };
01165 
01166 
01167 class ORWithTorsionAreEltsEqual : public FastComputation
01168 {
01169 public:
01170 
01171   ORWithTorsionAreEltsEqual(class SMWord& w1, class SMWord& w2) 
01172     : theWord1( w1 ), theWord2( w2 ) { }
01173 
01174   void takeControl( );              // overrides ComputationManager
01175 
01176 private:
01177 
01178   class SMWord& theWord1;
01179   class SMWord& theWord2;
01180 };
01181 
01182 /*
01183 class ORWithTorsionWordProblem : public FastComputation
01184 {
01185 public:
01186 
01187   ORWithTorsionWordProblem(class SMWord& w) : theWord( w ) { }
01188 
01189   void takeControl( );              // overrides ComputationManager
01190 
01191 private:
01192 
01193   class SMWord& theWord;
01194 };
01195 */
01196 
01197 class ORWithTorsionExtendedWordProblem : public FastComputation
01198 {
01199 public:
01200 
01201   ORWithTorsionExtendedWordProblem(class SMSubgroup& S, class SMWord& w) 
01202     : theSubgroup( S ),  theWord( w ) { }
01203 
01204   void takeControl( );              // overrides ComputationManager
01205 
01206 private:
01207 
01208   class SMSubgroup& theSubgroup;
01209   class SMWord& theWord;
01210 };
01211 
01212 class ORWithTorsionCentralizerOfElt : public FastComputation
01213 {
01214 public:
01215 
01216   ORWithTorsionCentralizerOfElt(class SMWord& w) 
01217     : theWord( w ) { }
01218 
01219   void takeControl( );              // overrides ComputationManager
01220 
01221 private:
01222 
01223   class SMWord& theWord;
01224 };
01225 
01226 class ORWithTorsionConjugacyProblem : public FastComputation
01227 {
01228 public:
01229 
01230   ORWithTorsionConjugacyProblem(class SMWord& w1, class SMWord& w2) 
01231     : word1( w1 ), word2( w2 ) { }
01232 
01233   void takeControl( );              // overrides ComputationManager
01234 
01235 private:
01236 
01237   class SMWord& word1;
01238   class SMWord& word2;
01239 };
01240 
01241 
01242 ///////////////////////////////////////////////////////////////////////////////
01243 //                                                                           //
01244 //  Make Menu:                                                               //
01245 //                                                                           //
01246 ///////////////////////////////////////////////////////////////////////////////
01247 
01248 
01249 class MakeCyclicDecomposition : public FastComputation
01250 {
01251 public:
01252 
01253   MakeCyclicDecomposition(class SMFPGroup& G ) : theGroup( G ) { }
01254 
01255   void takeControl( );              // overrides ComputationManager
01256     
01257 private:
01258     
01259   class SMFPGroup& theGroup;
01260 };
01261 
01262 
01263 // ------------------------------ Quotients -------------------------------- //
01264 
01265 
01266 class MakeAbelianQuotient : public FastComputation
01267 {
01268 public:
01269 
01270   MakeAbelianQuotient(class SMFPGroup& G ) : theGroup( G ) { }
01271 
01272   void takeControl( );              // overrides ComputationManager
01273     
01274 private:
01275     
01276   class SMFPGroup& theGroup;
01277 };
01278 
01279 
01280 class MakeQuotientFromSubgroup : public FastComputation
01281 {
01282 public:
01283 
01284   MakeQuotientFromSubgroup(class SMSubgroup& S ) : theSubgroup( S ) { }
01285 
01286   void takeControl( );              // overrides ComputationManager
01287     
01288 private:
01289     
01290   class SMSubgroup& theSubgroup;
01291 };
01292 
01293 class MakeNilpotentQuotient : public FastComputation
01294 {
01295 public:
01296 
01297   MakeNilpotentQuotient( class SMFPGroup& G, int n = 1 ) : 
01298     theGroup( G ), theClass( n ) { }
01299   
01300   void takeControl( );              // overrides ComputationManager
01301 
01302 private:
01303 
01304   class SMFPGroup& theGroup;
01305   int theClass;
01306 };
01307 
01308 
01309 class MakeQuotient : public FastComputation
01310 {
01311 public:
01312 
01313   MakeQuotient( class SMFPGroup& G, const SetOf<Word>& S = SetOf<Word>() ) : 
01314     theGroup( G ), relators( S ) { }
01315   
01316   void takeControl( );              // overrides ComputationManager
01317 
01318 private:
01319 
01320   class SMFPGroup& theGroup;
01321   SetOf<Word> relators;
01322 };
01323 
01324 
01325 // ------------------------------ Products --------------------------------- //
01326 
01327 
01328 class MakeAPOfFree : public FastComputation
01329 {
01330 public:
01331 
01332   MakeAPOfFree( const SMFPGroup& G1, const SMFPGroup& G2,  
01333                 const SMSubgroup& S1, const SMSubgroup& S2 )
01334   : subgroup1( S1 ),
01335     subgroup2( S2 )
01336   { }
01337 
01338   void takeControl( );              // overrides ComputationManager
01339     
01340 private:
01341     
01342   const SMSubgroup& subgroup1;
01343   const SMSubgroup& subgroup2;
01344 };
01345 
01346 
01347 class APOfFreeReducedForm : public FastComputation
01348 {
01349 public:
01350 
01351   APOfFreeReducedForm(const class SMWord& w) : theWord( w ) { }
01352 
01353   void takeControl( );              // overrides ComputationManager
01354 
01355 private:
01356 
01357   const class SMWord& theWord;
01358 };
01359 
01360 
01361 class APOfFreeNormalForm : public FastComputation
01362 {
01363 public:
01364 
01365   APOfFreeNormalForm(const class SMWord& w) : theWord( w ) { }
01366 
01367   void takeControl( );              // overrides ComputationManager
01368 
01369 private:
01370 
01371   const class SMWord& theWord;
01372 };
01373 
01374 
01375 class APOfFreeCyclicNormalForm : public FastComputation
01376 {
01377 public:
01378 
01379   APOfFreeCyclicNormalForm(const class SMWord& w) : theWord( w ) { }
01380 
01381   void takeControl( );              // overrides ComputationManager
01382 
01383 private:
01384 
01385   const class SMWord& theWord;
01386 };
01387 
01388 
01389 class APOfFreeIsTrivial : public FastComputation
01390 {
01391 public:
01392 
01393   APOfFreeIsTrivial(class SMFPGroup& G) : theGroup( G ) { }
01394 
01395   void takeControl( );              // overrides ComputationManager
01396 
01397 private:
01398 
01399   class SMFPGroup& theGroup;
01400 };
01401 
01402 
01403 class APOfFreeIsHyperbolic : public FastComputation
01404 {
01405 public:
01406 
01407   APOfFreeIsHyperbolic(class SMFPGroup& G) : theGroup( G ) { }
01408 
01409   void takeControl( );              // overrides ComputationManager
01410 
01411 private:
01412 
01413   class SMFPGroup& theGroup;
01414 };
01415 
01416 
01417 class APOfFreeIsFinite : public FastComputation
01418 {
01419 public:
01420 
01421   APOfFreeIsFinite(class SMFPGroup& G) : theGroup( G ) { }
01422 
01423   void takeControl( );              // overrides ComputationManager
01424 
01425 private:
01426 
01427   class SMFPGroup& theGroup;
01428 };
01429 
01430 
01431 class APOfFreeIsAbelian : public FastComputation
01432 {
01433 public:
01434 
01435   APOfFreeIsAbelian(class SMFPGroup& G) : theGroup( G ) { }
01436 
01437   void takeControl( );              // overrides ComputationManager
01438 
01439 private:
01440 
01441   class SMFPGroup& theGroup;
01442 };
01443 
01444 
01445 class APOfFreeOrder : public FastComputation
01446 {
01447 public:
01448 
01449   APOfFreeOrder(class SMFPGroup& G) : theGroup( G ) { }
01450 
01451   void takeControl( );              // overrides ComputationManager
01452     
01453 private:
01454 
01455   class SMFPGroup& theGroup;
01456 };
01457 
01458 
01459 class APOfFreeWordProblem : public FastComputation
01460 {
01461 public:
01462 
01463   APOfFreeWordProblem(const class SMWord& w) : theWord( w ) { }
01464 
01465   void takeControl( );              // overrides ComputationManager
01466 
01467 private:
01468 
01469   const class SMWord& theWord;
01470 };
01471 
01472 
01473 class APOfFreeNumberOfSubstitutions : public FastComputation
01474 {
01475 public:
01476 
01477   APOfFreeNumberOfSubstitutions(const class SMWord& w) : theWord( w ) { }
01478 
01479   void takeControl( );              // overrides ComputationManager
01480 
01481 private:
01482 
01483   const class SMWord& theWord;
01484 };
01485 
01486 
01487 class APOfFreeAreEqual : public FastComputation
01488 {
01489 public:
01490 
01491   APOfFreeAreEqual(const class SMWord& w1, const class SMWord& w2)
01492     : word1( w1 ), word2( w2 )
01493   { }
01494 
01495   void takeControl( );              // overrides ComputationManager
01496 
01497 private:
01498 
01499   const class SMWord& word1;
01500   const class SMWord& word2;
01501 };
01502 
01503 
01504 class APOfFree_DoEltsCommute : public FastComputation
01505 {
01506 public:
01507 
01508   APOfFree_DoEltsCommute(const class SMWord& w1, const class SMWord& w2)
01509     : word1( w1 ), word2( w2 )
01510   { }
01511 
01512   void takeControl( );              // overrides ComputationManager
01513 
01514 private:
01515 
01516   const class SMWord& word1;
01517   const class SMWord& word2;
01518 };
01519 
01520 
01521 class APOfFreeIsSGTrivial : public FastComputation
01522 {
01523 public:
01524 
01525   APOfFreeIsSGTrivial(const class SMSubgroup& S) : subgroup( S ) { }
01526 
01527   void takeControl( );              // overrides ComputationManager
01528 
01529 private:
01530 
01531   const class SMSubgroup& subgroup;
01532 };
01533 
01534 
01535 class CheckinAPOfFree : public FastComputation
01536 {
01537 public:
01538 
01539   CheckinAPOfFree( ) { }
01540 
01541   void takeControl( );              // overrides ComputationManager
01542     
01543 //private:
01544 };
01545 
01546 
01547 class APOfFreeIsSGAbelian : public FastComputation
01548 {
01549 public:
01550 
01551   APOfFreeIsSGAbelian(const class SMSubgroup& S) : theSubgroup( S ) { }
01552 
01553   void takeControl( );              // overrides ComputationManager
01554 
01555 private:
01556 
01557   const class SMSubgroup& theSubgroup;
01558 };
01559 
01560 
01561 class APOfFreeCyclic_CentralizerOfElt : public FastComputation
01562 {
01563 public:
01564 
01565   APOfFreeCyclic_CentralizerOfElt(const class SMWord& w) : theWord( w ) { }
01566 
01567   void takeControl( );              // overrides ComputationManager
01568 
01569 private:
01570 
01571   const class SMWord& theWord;
01572 };
01573 
01574 class APOfFreeCyclic_ConjugacyProblem : public FastComputation
01575 {
01576 public:
01577 
01578   APOfFreeCyclic_ConjugacyProblem( const class SMWord& w1,
01579                                    const class SMWord& w2 )
01580     : word1( w1 ), word2( w2 )
01581   { }
01582 
01583   void takeControl( );              // overrides ComputationManager
01584 
01585 private:
01586 
01587   const class SMWord& word1;
01588   const class SMWord& word2;
01589 };
01590 
01591 
01592 class APOfFreeCyclic_MaximalRoot : public FastComputation
01593 {
01594 public:
01595 
01596   APOfFreeCyclic_MaximalRoot(const class SMWord& w) : theWord( w ) { }
01597 
01598   void takeControl( );              // overrides ComputationManager
01599 
01600 private:
01601 
01602   const class SMWord& theWord;
01603 };
01604 
01605 
01606 class APOfFreeCyclic_IsEltAProperPower : public FastComputation
01607 {
01608 public:
01609 
01610   APOfFreeCyclic_IsEltAProperPower(const class SMWord& w) : theWord( w ) { }
01611 
01612   void takeControl( );              // overrides ComputationManager
01613 
01614 private:
01615 
01616   const class SMWord& theWord;
01617 };
01618 
01619 
01620 class APOfFreeCyclic_IsEltAProperPowerOfSecond : public FastComputation
01621 {
01622 public:
01623 
01624   APOfFreeCyclic_IsEltAProperPowerOfSecond( const class SMWord& w1,
01625                                             const class SMWord& w2 ) 
01626     : word1( w1 ), word2( w2 ) 
01627   { }
01628 
01629   void takeControl( );              // overrides ComputationManager
01630 
01631 private:
01632 
01633   const class SMWord& word1;
01634   const class SMWord& word2;
01635 };
01636 
01637 //---------------------------------------------------------------------------//
01638 //--------------------- Nilpotent Group Computations ------------------------//
01639 //---------------------------------------------------------------------------//
01640 
01641 class FNGAutoIsIAAut : public FastComputation
01642 {
01643 public:
01644 
01645   FNGAutoIsIAAut(const class SMMap& m) : map( m ) { }
01646 
01647   void takeControl( );              // overrides ComputationManager
01648 
01649 private:
01650 
01651   const class SMMap& map;
01652 };
01653 
01654 class SGOfNGjoinSubgroupProblem : public FastComputation
01655 {
01656 public:
01657 
01658   SGOfNGjoinSubgroupProblem(const class SMSubgroup& s1, const class SMSubgroup& s2) 
01659     : subgroup1(s1), subgroup2(s2)
01660   { }
01661 
01662   void takeControl( );              // overrides ComputationManager
01663 
01664 private:
01665 
01666   const class SMSubgroup& subgroup1;
01667   const class SMSubgroup& subgroup2;
01668 
01669 };
01670 
01671 class NGLCStermGensProblem : public FastComputation
01672 {
01673 public:
01674 
01675   NGLCStermGensProblem( class SMFPGroup& g, int num = 1) 
01676     : group(g),number(num)
01677   { }
01678 
01679   void takeControl( );              // overrides ComputationManager
01680 
01681 private:
01682 
01683   class SMFPGroup& group;
01684   int number;
01685 };
01686 
01687 //------------------------------------------------------//
01688 // ------------------ Products Creation ----------------//
01689 //------------------------------------------------------//
01690 
01691 class MakeFreeProduct : public FastComputation
01692 {
01693 public:
01694 
01695   MakeFreeProduct( class SMFPGroup& g1, class SMFPGroup& g2);
01696 
01697   void takeControl( );              // overrides ComputationManager
01698 
01699 protected:
01700   
01701   void makeHomomorphisms(SMFPGroup* smo);
01702 
01703   class SMFPGroup& group1;
01704   class SMFPGroup& group2;
01705 
01706   FPGroup fpGroup1;
01707   FPGroup fpGroup2;
01708 
01709   bool isAbelian;
01710 
01711   class FreeProduct* fp;
01712 };
01713 
01714 class MakeDirectProduct : public MakeFreeProduct
01715 {
01716 public:
01717 
01718   MakeDirectProduct( class SMFPGroup& g1, class SMFPGroup& g2) 
01719     : MakeFreeProduct(g1,g2)
01720     { }
01721   
01722   void takeControl( );              // overrides ComputationManager
01723 
01724 };
01725 
01726 class MakeFactorGroup : public FastComputation
01727 {
01728 public:
01729 
01730   MakeFactorGroup( class SMFPGroup& F, class SMSubgroup& H) 
01731     : theGroup( F ), theSubgroup( H ) 
01732     { }
01733   
01734   void takeControl( );              // overrides ComputationManager
01735 
01736 private:
01737   class SMFPGroup& theGroup;
01738   class SMSubgroup& theSubgroup;
01739 };
01740 
01741 // -------------------------- List ------------------------- //
01742 
01743 class MakeListOfWords : public FastComputation
01744 {
01745 public:
01746 
01747   MakeListOfWords( EnumeratorProblem<Word>& e):
01748     enumerator( e ) { }
01749   
01750   void takeControl( );              // overrides ComputationManager
01751   
01752 protected:
01753   
01754   EnumeratorProblem<Word>& enumerator;
01755     
01756 };
01757 
01758 
01759 // --------------------------- RipsConstruction ---------------------------- //
01760 
01761 
01762 class MakeRipsConstruction : public FastComputation
01763 {
01764 public:
01765 
01766   MakeRipsConstruction(class SMFPGroup& G ) : theGroup( G ) { }
01767 
01768   void takeControl( );              // overrides ComputationManager
01769     
01770 private:
01771     
01772   class SMFPGroup& theGroup;
01773 };
01774 
01775 
01776 #endif 

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