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

/magnus/back_end/SMApps/include/SGNilpotentQuotients.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: SGNilpotentQuotients.h,v 1.1 1998/08/03 22:46:43 bormotov 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  
00009 
00010 //
00011 // Principal Author: Dmitry Pechkin
00012 //
00013 // Status: in progress
00014 //
00015 // Revision History:
00016 //
00017 
00018 
00019 #ifndef _SGNILPOTENT_QUOTIENTS_H_
00020 #define _SGNILPOTENT_QUOTIENTS_H_
00021 
00022 
00023 //@rn  This is specialized for the moment to work only on the specific class of
00024 //@rn  a group which was checked in as nilpotent. It can, in principle, work
00025 //@rn  on any nilpotent quotient of any FP group.
00026 
00027 
00028 #include "Supervisor.h"
00029 #include "NilpotentGroup.h"
00030 #include "ComputationManager.h"
00031 //#include "List.h"
00032 //#include "File.h"
00033 //#include "Presentation.h"
00034 
00035 // ---------------------- SCPNilpotentARCer --------------------------- //
00036 
00037 
00038 class SCPNilpotentARCer : public ARCer
00039 {
00040 public:
00041 
00042   /////////////////////////////////////////////////////////////////////////
00043   //                                                                     //
00044   // Constructors:                                                       //
00045   //                                                                     //
00046   /////////////////////////////////////////////////////////////////////////
00047 
00048   SCPNilpotentARCer( ComputationManager& boss );
00049 
00050   ~SCPNilpotentARCer( );
00051 
00052 
00053   /////////////////////////////////////////////////////////////////////////
00054   //                                                                     //
00055   // Accessors:                                                          //
00056   //                                                                     //
00057   /////////////////////////////////////////////////////////////////////////
00058 
00059   void setArguments( const class SGOfNilpotentGroup& subgroup,
00060                      const SetOf<Word>& testWords );
00061 
00062   // Inherited from ARCer:
00063   //   bool takeControl( );
00064 
00065   Trichotomy contains() const;
00066   
00067   
00068   /////////////////////////////////////////////////////////////////////////
00069   //                                                                     //
00070   // IPC interaction members:                                            //
00071   //                                                                     //
00072   /////////////////////////////////////////////////////////////////////////
00073 
00074   void runComputation( );
00075  
00076   void writeResults( ostream& );
00077 
00078   void readResults( istream& );
00079 
00080 
00081 private:
00082 
00083   /////////////////////////////////////////////////////////////////////////
00084   //                                                                     //
00085   // Data Members:                                                       //
00086   //                                                                     //
00087   /////////////////////////////////////////////////////////////////////////
00088 
00089   SetOf<Word> theTestWords;
00090   class SGOfNilpotentGroup* theSubgroup;
00091   Trichotomy theAnswer;
00092 };
00093 
00094 //---------------------------------------------------------------------------//
00095 //---------------------------- SCPinNilpotentQuotients ----------------------//
00096 //---------------------------------------------------------------------------//
00097 
00098 
00099 class SCPinNilpotentQuotients : public ComputationManager
00100 {
00101 public:
00102   
00103   /////////////////////////////////////////////////////////////////////////
00104   //                                                                     //
00105   // Constructors:                                                       //
00106   //                                                                     //
00107   /////////////////////////////////////////////////////////////////////////
00108 
00109   SCPinNilpotentQuotients( Supervisor& boss );
00110   // Constructor gets abstract supervisor, so you can call this
00111   // computation manager from any supervisor.
00112 
00113   void initialize( const SetOf<Word>& testWords, 
00114                    const class SMSubgroup* subgroup,
00115                    int startClass = 2);
00116   // Initializing for checking of words set.
00117   // You have to call initialize, before running start, because we
00118   // need to initialize words and subgroup for running problem.
00119   
00120   /////////////////////////////////////////////////////////////////////////
00121   //                                                                     //
00122   // Accessors:                                                          //
00123   //                                                                     //
00124   /////////////////////////////////////////////////////////////////////////
00125 
00126   Trichotomy contains( int& nClass ) const;
00127   // Returns no if there is a word which doesn't lie in the subgroup.
00128 
00129   /////////////////////////////////////////////////////////////////////////
00130   //                                                                     //
00131   // Control:                                                            //
00132   //                                                                     //
00133   /////////////////////////////////////////////////////////////////////////
00134 
00135   void takeControl( );         // overrides ComputationManager
00136 
00137   /////////////////////////////////////////////////////////////////////////
00138   //                                                                     //
00139   // State Transitions:                                                  //
00140   //                                                                     //
00141   /////////////////////////////////////////////////////////////////////////
00142 
00143   void start( ) { };              // overrides ComputationManager
00144 
00145   void terminate( ) { };          // overrides ComputationManager
00146 
00147 
00148 private:
00149 
00150   /////////////////////////////////////////////////////////////////////////
00151   //                                                                     //
00152   // Data Members:                                                       //
00153   //                                                                     //
00154   /////////////////////////////////////////////////////////////////////////
00155 
00156   SetOf<Word> theTestWords; 
00157   // Set of words to be checked.
00158 
00159   const SMSubgroup* theSubgroup;
00160 
00161   Trichotomy theAnswer;
00162 
00163   int currentClass;
00164   // Class of quotient in which the word problem is solving.
00165 
00166   int upperBound;
00167   // Upper class for quotients. For nilpotent groups - nilpotency class-1,
00168   // for others - 10.
00169 
00170   SCPNilpotentARCer arcer;
00171   bool arcerStarted;
00172 };
00173 
00174 // ---------------------- NGcomputeBasisARCer --------------------------- //
00175 
00176 
00177 class  SGofNGinitPreimageARCer : public ARCer
00178 {
00179 public:
00180 
00181   /////////////////////////////////////////////////////////////////////////
00182   //                                                                     //
00183   // Constructors:                                                       //
00184   //                                                                     //
00185   /////////////////////////////////////////////////////////////////////////
00186 
00187   SGofNGinitPreimageARCer( ComputationManager& boss );
00188 
00189   ~SGofNGinitPreimageARCer( );
00190 
00191 
00192   /////////////////////////////////////////////////////////////////////////
00193   //                                                                     //
00194   // Accessors:                                                          //
00195   //                                                                     //
00196   /////////////////////////////////////////////////////////////////////////
00197  
00198   void setArguments( const NilpotentGroup& NG, const VectorOf<Word>& gens );
00199 
00200   // Inherited from ARCer:
00201   //   bool takeControl( );
00202 
00203   const SGOfNilpotentGroup& getSubgroup() const;
00204 
00205   /////////////////////////////////////////////////////////////////////////
00206   //                                                                     //
00207   // IPC interaction members:                                            //
00208   //                                                                     //
00209   /////////////////////////////////////////////////////////////////////////
00210 
00211   void runComputation( );
00212  
00213   void writeResults( ostream& );
00214 
00215   void readResults( istream& );
00216 
00217 
00218 private:
00219 
00220   /////////////////////////////////////////////////////////////////////////
00221   //                                                                     //
00222   // Data Members:                                                       //
00223   //                                                                     //
00224   /////////////////////////////////////////////////////////////////////////
00225 
00226   SGOfNilpotentGroup* theSubgroup;
00227 };
00228 
00229 
00230 //---------------------------------------------------------------------------//
00231 //------------------------ SGNilpotentQuotients -----------------------------//
00232 //---------------------------------------------------------------------------//
00233 
00234 
00235 class SGNilpotentQuotients : public ComputationManager
00236 {
00237 public:
00238 
00239   /////////////////////////////////////////////////////////////////////////
00240   //                                                                     //
00241   // Constructors:                                                       //
00242   //                                                                     //
00243   /////////////////////////////////////////////////////////////////////////
00244 
00245   SGNilpotentQuotients(class SCM& scm, bool internal = true);
00246   
00247   ~SGNilpotentQuotients( );
00248 
00249   /////////////////////////////////////////////////////////////////////////
00250   //                                                                     //
00251   // Accessors:                                                          //
00252   //                                                                     //
00253   /////////////////////////////////////////////////////////////////////////
00254 
00255 
00256   /////////////////////////////////////////////////////////////////////////
00257   //                                                                     //
00258   // Front End Interfacing:                                              //
00259   //                                                                     //
00260   /////////////////////////////////////////////////////////////////////////
00261 
00262   void viewStructure(ostream& ostr) const { }  // overrides SMObject
00263 
00264   /////////////////////////////////////////////////////////////////////////
00265   //                                                                     //
00266   // Control:                                                            //
00267   //                                                                     //
00268   /////////////////////////////////////////////////////////////////////////
00269 
00270   void takeControl( );         // overrides ComputationManager
00271 
00272   /////////////////////////////////////////////////////////////////////////
00273   //                                                                     //
00274   // State Transitions:                                                  //
00275   //                                                                     //
00276   /////////////////////////////////////////////////////////////////////////
00277 
00278   void start( );              // overrides ComputationManager
00279 
00280   void terminate( );          // overrides ComputationManager
00281 
00282 
00283 private:
00284 
00285   bool increaseCurrentClass();
00286 
00287   void setNewSubgroup( );
00288 
00289   /////////////////////////////////////////////////////////////////////////
00290   //                                                                     //
00291   // Data Members:                                                       //
00292   //                                                                     //
00293   /////////////////////////////////////////////////////////////////////////
00294 
00295   SCM& theSCM;
00296 
00297   SMSubgroup& theSubgroup;
00298 
00299   SGofNGinitPreimageARCer arcer;
00300 
00301   int currentClass;
00302   // This is the class of currently computing quotient.
00303 
00304   int upperBound; 
00305   // The hard-wired upper bound on the classes we'll compute.
00306   // For Nilpotent groups it Nilpotency class - 1, for others 10.
00307   
00308 };
00309 
00310 
00311 int getNilpotencyUpperBound( const SMFPGroup& G );
00312 
00313 #endif

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