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

/magnus/back_end/SessionManager/include/GIC.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: GIC.h,v 1.20 2000/03/03 01:35:09 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: Declaration of class GIC (Group Information Center)
00009 //
00010 // Principal Author: Roger Needham, Dmitry Bormotov
00011 //
00012 // Status: this can never be complete
00013 //
00014 // Usage:
00015 //
00016 // For a given piece of info, there are up to four kinds of names needed:
00017 // 1) The data member
00018 // 2) The member function through which it is reported
00019 // 3) The member function via which its existence is queried
00020 // 4) The member function via which it is accessed
00021 // 
00022 // In an attempt at coherence, we try to use these conventions for a
00023 // Trichotomy (resp. bool) <I>
00024 // e.g., I == abelian, (resp. I == solvedWordProblem):
00025 // 
00026 // 1) <I>
00027 // 2) putIs<I>  resp. putHave<I>
00028 // 3) is<I>     resp. have<I>
00029 // 
00030 // and in other cases (e.g., I == confluentKBMachine):
00031 // 
00032 // 1) <I>
00033 // 2) putHave<I>
00034 // 3) have<I>
00035 // 4) get<I>
00036 //
00037 //
00038 // Next Implementation Steps:
00039 //
00040 // * Better exception instrumentation, e.g., conflicting reports of order
00041 //
00042 // * It is not clear how much the explanations will need to be accessed,
00043 //   since they are sent to the FE when the explained info is reported.
00044 //   Put accessors in as needed.
00045 //
00046 //
00047 // Revision History:
00048 //
00049 
00050 
00051 
00052 #ifndef _GIC_H_
00053 #define _GIC_H_
00054 
00055 
00056 //#include <Integer.h>
00057 //#include <DArray.h>
00058 //#include "Associations.h"
00059 //#include "Trichotomy.h"
00060 //#include "Chars.h"
00061 
00062 #include "FEData.h"
00063 #include "BaseProperties.h"
00064 #include "InformationCenter.h"
00065 #include "OID.h"
00066 
00067 // Types stored by the GIC:
00068 
00069 //#include "KBMachine.h"
00070 //#include "Map.h"
00071 //#include "DFSA.h"
00072 //#include "DiffMachine.h"
00073 //#include "AbelianGroup.h"
00074 //#include "FreeByCyclic.h"
00075 //#include "MSCGroup.h"
00076 //#include "NilpotentGroup.h"
00077 //#include "SubgroupGraph.h"
00078 //#include "CosetEnumerator.h"
00079 //#include "APwithOneRelator.h"
00080 
00081 
00082 //---------------------------------------------------------------------------//
00083 //--------------------- GIC PROPERTIES --------------------------------------//
00084 //---------------------------------------------------------------------------//
00085 
00086 class GroupOrderProperty : public IntegerProperty {
00087 public:
00088   GroupOrderProperty(const Integer& data, const Chars& descr) 
00089     : IntegerProperty(data, descr) {}
00090   PropertyType actualType  () const { return type(); }
00091   static PropertyType type() { return theTypeID; }
00092   Chars propertyName() const { return "GroupOrder";   }
00093 protected:
00094   GenericProperty* clone() const { return new GroupOrderProperty(*this); }
00095 private:
00096   static const PropertyType theTypeID;
00097 };
00098 
00099 /*
00100 class GroupOrderUpperBoundProperty : public IntegerProperty {
00101 public:
00102   GroupOrderUpperBoundProperty(const Integer& data, const Chars& descr) 
00103     : IntegerProperty(data, descr) {}
00104   PropertyType actualType  () const { return type(); }
00105   static PropertyType type() { return theTypeID; }
00106   Chars propertyName() const { return "GroupOrderUpperBound"; }
00107 private:
00108   static const PropertyType theTypeID;
00109 };
00110 */
00111 
00112 class SolvedWordProblemProperty : public NoDataProperty {
00113 public:
00114   SolvedWordProblemProperty(const Chars& descr) : NoDataProperty(descr) {}
00115   PropertyType actualType()   const { return type(); }
00116   static PropertyType type() { return theTypeID; }
00117   Chars propertyName() const { return "SolvedWordProblem"; }
00118 protected:
00119   GenericProperty* clone() const {return new SolvedWordProblemProperty(*this);}
00120 private:
00121   static const PropertyType theTypeID;
00122 };
00123 
00124 class FastWordProblemProperty : public NoDataProperty {
00125 public:
00126   FastWordProblemProperty(const Chars& descr) : NoDataProperty(descr) {}
00127   PropertyType actualType()   const { return type(); }
00128   static PropertyType type() { return theTypeID; }
00129   Chars propertyName() const { return "FastWordProblem"; }
00130 protected:
00131   GenericProperty* clone() const { return new FastWordProblemProperty(*this); }
00132 private:
00133   static const PropertyType theTypeID;
00134 };
00135 
00136 class CompleteCayleyGraphProperty : public SubgroupGraphProperty {
00137 public:
00138   CompleteCayleyGraphProperty(const SubgroupGraph& graph) 
00139     : SubgroupGraphProperty(graph) {}
00140   PropertyType actualType  () const { return type(); }
00141   static PropertyType type() { return theTypeID; }
00142   Chars propertyName() const { return "CompleteCayleyGraph"; }
00143 protected:
00144   GenericProperty* clone() const { 
00145     return new CompleteCayleyGraphProperty(*this); 
00146   }
00147 private:
00148   static const PropertyType theTypeID;
00149 };
00150 
00151 class ConfluentKBMachineProperty : public KBMachineProperty {
00152 public:
00153   ConfluentKBMachineProperty(const KBMachine& data) : KBMachineProperty(data){}
00154   PropertyType actualType()   const { return type(); }
00155   static PropertyType type() { return theTypeID; }
00156   Chars propertyName() const { return "ConfluentKBMachine"; }
00157 protected:
00158   GenericProperty* clone() const { return new ConfluentKBMachineProperty(*this); }
00159 private:
00160   static const PropertyType theTypeID;
00161 };
00162 
00163 
00164 class IsAutomaticProperty : public NoDataProperty {
00165 public:
00166   IsAutomaticProperty(const Chars& descr) : NoDataProperty(descr) {}
00167   PropertyType actualType()   const { return type(); }
00168   static PropertyType type() { return theTypeID; }
00169   Chars propertyName() const { return "IsAutomatic"; }
00170 protected:
00171   GenericProperty* clone() const { return new IsAutomaticProperty(*this); }
00172 private:
00173   static const PropertyType theTypeID;
00174 };
00175 
00176 class Automatic_GroupDFSAProperty : public GroupDFSAProperty {
00177 public:
00178   Automatic_GroupDFSAProperty(const GroupDFSA& data) 
00179     : GroupDFSAProperty(data) {}
00180   PropertyType actualType()   const { return type(); }
00181   static PropertyType type() { return theTypeID; }
00182   Chars propertyName() const { return "Automatic_GroupDFSA"; }
00183 protected:
00184   GenericProperty* clone() const { return new Automatic_GroupDFSAProperty(*this); }
00185 private:
00186   static const PropertyType theTypeID;
00187 };
00188 
00189 class Automatic_DiffMachineProperty : public DiffMachineProperty {
00190 public:
00191   Automatic_DiffMachineProperty(const DiffMachine& data) 
00192     : DiffMachineProperty(data) {}
00193   PropertyType actualType()   const { return type(); }
00194   static PropertyType type() { return theTypeID; }
00195   Chars propertyName() const { return "Automatic_DiffMachine"; }
00196 protected:
00197   GenericProperty* clone() const { return new Automatic_DiffMachineProperty(*this); }
00198 private:
00199   static const PropertyType theTypeID;
00200 };
00201 
00202 class OneRelatorProperty : public WordProperty {
00203 public:
00204   OneRelatorProperty(const Word& data) : WordProperty(data) {}
00205   PropertyType actualType()   const { return type(); }
00206   static PropertyType type() { return theTypeID; }
00207   Chars propertyName() const { return "OneRelator"; }
00208 protected:
00209   GenericProperty* clone() const { return new OneRelatorProperty(*this); }
00210 private:
00211   static const PropertyType theTypeID;
00212 };
00213 
00214 class OneRelatorWithTorsionProperty : public NoDataProperty {
00215 public:
00216   OneRelatorWithTorsionProperty() : NoDataProperty() {}
00217   PropertyType actualType()   const { return type(); }
00218   static PropertyType type() { return theTypeID; }
00219   Chars propertyName() const { return "OneRelatorWithTorsion"; }
00220 protected:
00221   GenericProperty* clone() const { return new OneRelatorWithTorsionProperty(*this); }
00222 private:
00223   static const PropertyType theTypeID;
00224 };
00225 
00226 class AbelianPresentationProperty : public AbelianGroupProperty {
00227 public:
00228   AbelianPresentationProperty(const AbelianGroup& data, 
00229                               const Chars descr = Chars() ) 
00230     : AbelianGroupProperty(data,descr) {}
00231   PropertyType actualType()   const { return type(); }
00232   static PropertyType type() { return theTypeID; }
00233   Chars propertyName() const { return "AbelianPresentation"; }
00234 protected:
00235   GenericProperty* clone() const { return new AbelianPresentationProperty(*this); }
00236 private:
00237   static const PropertyType theTypeID;
00238 };
00239 
00240 /*
00241 
00242 class CyclicDecompositionProperty : public AbelianGroupProperty {
00243 public:
00244   CyclicDecompositionProperty(const AbelianGroup& data) 
00245     : AbelianGroupProperty(data) {}
00246   PropertyType actualType()   const { return type(); }
00247   static PropertyType type() { return theTypeID; }
00248   Chars propertyName() const { return "CyclicDecomposition"; }
00249 private:
00250   static const PropertyType theTypeID;
00251 };
00252 
00253 class PrimaryDecompositionProperty : public AbelianGroupProperty {
00254 public:
00255   PrimaryDecompositionProperty(const AbelianGroup& data) 
00256     : AbelianGroupProperty(data) {}
00257   PropertyType actualType()   const { return type(); }
00258   static PropertyType type() { return theTypeID; }
00259   Chars propertyName() const { return "PrimaryDecomposition"; }
00260 private:
00261   static const PropertyType theTypeID;
00262 };
00263 
00264 class CanonicalSmithDecompositionProperty : public AbelianGroupProperty {
00265 public:
00266   CanonicalSmithDecompositionProperty(const AbelianGroup& data) 
00267     : AbelianGroupProperty(data) {}
00268   PropertyType actualType()   const { return type(); }
00269   static PropertyType type() { return theTypeID; }
00270   Chars propertyName() const { return "CanonicalSmithDecomposition"; }
00271 private:
00272   static const PropertyType theTypeID;
00273 };
00274 
00275 */
00276 
00277 class IsAbelianProperty : public NoDataProperty {
00278 public:
00279   IsAbelianProperty() : NoDataProperty() {}
00280   PropertyType actualType()   const { return type(); }
00281   static PropertyType type() { return theTypeID; }
00282   Chars propertyName() const { return "IsAbelian"; }
00283 protected:
00284   GenericProperty* clone() const { return new IsAbelianProperty(*this); }
00285 private:
00286   static const PropertyType theTypeID;
00287 };
00288 
00289 class IsFreeProperty : public NoDataProperty {
00290 public:
00291   IsFreeProperty(const Chars& descr) : NoDataProperty(descr) {}
00292   PropertyType actualType()   const { return type(); }
00293   static PropertyType type() { return theTypeID; }
00294   Chars propertyName() const { return "IsFree"; }
00295 protected:
00296   GenericProperty* clone() const { return new IsFreeProperty(*this); }
00297 private:
00298   static const PropertyType theTypeID;
00299 };
00300 
00301 class IsFiniteProperty : public NoDataProperty {
00302 public:
00303   IsFiniteProperty(const Chars& descr) : NoDataProperty(descr) {}
00304   PropertyType actualType()   const { return type(); }
00305   static PropertyType type() { return theTypeID; }
00306   Chars propertyName() const { return "IsFinite"; }
00307 protected:
00308   GenericProperty* clone() const { return new IsFiniteProperty(*this); }
00309 private:
00310   static const PropertyType theTypeID;
00311 };
00312 
00313 class NilpotencyClassProperty : public IntProperty {
00314 public:
00315   NilpotencyClassProperty(const int& data) : IntProperty(data) {}
00316   PropertyType actualType()   const { return type(); }
00317   static PropertyType type() { return theTypeID; }
00318   Chars propertyName() const { return "NilpotencyClass"; }
00319 protected:
00320   GenericProperty* clone() const { return new NilpotencyClassProperty(*this); }
00321 private:
00322   static const PropertyType theTypeID;
00323 };
00324 
00325 class NilpotentQuotientsProperty : public NilpGroupAssocProperty {
00326 public:
00327   NilpotentQuotientsProperty(const AssociationsOf<int,NilpotentGroup*>& data) 
00328     : NilpGroupAssocProperty(data) {}
00329   PropertyType actualType()   const { return type(); }
00330   static PropertyType type() { return theTypeID; }
00331   Chars propertyName() const { return "NilpotentQuotients"; }
00332 protected:
00333   GenericProperty* clone() const { return new NilpotentQuotientsProperty(*this); }
00334 private:
00335   static const PropertyType theTypeID;
00336 };
00337 
00338 class IsFreeNilpotentProperty : public NoDataProperty {
00339 public:
00340   IsFreeNilpotentProperty() : NoDataProperty() {}
00341   PropertyType actualType()   const { return type(); }
00342   static PropertyType type() { return theTypeID; }
00343   Chars propertyName() const { return "IsFreeNilpotent"; }
00344 protected:
00345   GenericProperty* clone() const { return new IsFreeNilpotentProperty(*this); }
00346 private:
00347   static const PropertyType theTypeID;
00348 };
00349 
00350 class ActualNilpotencyClassProperty : public IntProperty {
00351 public:
00352   ActualNilpotencyClassProperty(const int& data) : IntProperty(data) {}
00353   PropertyType actualType()   const { return type(); }
00354   static PropertyType type() { return theTypeID; }
00355   Chars propertyName() const { return "ActualNilpotentClass"; }
00356 protected:
00357   GenericProperty* clone() const { return new ActualNilpotencyClassProperty(*this); }
00358 private:
00359   static const PropertyType theTypeID;
00360 };
00361 
00362 
00363 class IsFreeByCyclicProperty : public FreeByCyclicProperty {
00364 public:
00365   IsFreeByCyclicProperty(const FreeByCyclic& data):FreeByCyclicProperty(data){}
00366   PropertyType actualType()   const { return type(); }
00367   static PropertyType type() { return theTypeID; }
00368   Chars propertyName() const { return "IsFreeByCyclic"; }
00369 protected:
00370   GenericProperty* clone() const { return new IsFreeByCyclicProperty(*this); }
00371 private:
00372   static const PropertyType theTypeID;
00373 };
00374 
00375 /*
00376 
00377 class IsFreeByCyclic_MapProperty : public MapProperty {
00378 public:
00379   IsFreeByCyclic_MapProperty(const Map& data) : MapProperty(data) {}
00380   PropertyType actualType()   const { return type(); }
00381   static PropertyType type() { return theTypeID; }
00382   Chars propertyName() const { return "IsFreeByCyclic_Map"; }
00383 private:
00384   static const PropertyType theTypeID;
00385 };
00386 
00387 */
00388 
00389 class MSCProperty : public MSCGroupProperty {
00390 public:
00391   MSCProperty(const FPGroup& G, int lambda) : MSCGroupProperty(G,lambda) {}
00392   PropertyType actualType()   const { return type(); }
00393   static PropertyType type() { return theTypeID; }
00394   Chars propertyName() const { return "MSC"; }
00395 protected:
00396   GenericProperty* clone() const { return new MSCProperty(*this); }
00397 private:
00398   static const PropertyType theTypeID;
00399 };
00400 
00401 class MSCLambdaProperty : public IntProperty {
00402 public:
00403   MSCLambdaProperty(const int& data, const Chars& descr = Chars()) 
00404     : IntProperty(data,descr) {}
00405   PropertyType actualType()   const { return type(); }
00406   static PropertyType type() { return theTypeID; }
00407   Chars propertyName() const { return "MSCLambda"; }
00408 protected:
00409   GenericProperty* clone() const { return new MSCLambdaProperty(*this); }
00410 private:
00411   static const PropertyType theTypeID;
00412 };
00413 
00414 class APofFreeProperty : public AmalgProductOfFreeGroupsProperty {
00415 public:
00416   APofFreeProperty(const AmalgProductOfFreeGroups& data) 
00417     : AmalgProductOfFreeGroupsProperty(data) {}
00418   PropertyType actualType()   const { return type(); }
00419   static PropertyType type() { return theTypeID; }
00420   Chars propertyName() const { return "APofFree"; }
00421 protected:
00422   GenericProperty* clone() const { return new APofFreeProperty(*this); }
00423 private:
00424   static const PropertyType theTypeID;
00425 };
00426 
00427 class HNNofFreeProperty : public HNNExtOfFreeGroupProperty {
00428 public:
00429   HNNofFreeProperty(const HNNExtOfFreeGroup& data) 
00430     : HNNExtOfFreeGroupProperty(data) {}
00431   PropertyType actualType()   const { return type(); }
00432   static PropertyType type() { return theTypeID; }
00433   Chars propertyName() const { return "HNNofFree"; }
00434 protected:
00435   GenericProperty* clone() const { return new HNNofFreeProperty(*this); }
00436 private:
00437   static const PropertyType theTypeID;
00438 };
00439 
00440 class SchreierTransversalProperty : public PermutationRepresentationProperty {
00441 public:
00442   SchreierTransversalProperty(const PermutationRepresentation& data) 
00443     : PermutationRepresentationProperty(data) {}
00444   PropertyType actualType()   const { return type(); }
00445   static PropertyType type() { return theTypeID; }
00446   Chars propertyName() const { return "SchreierTransversal"; }
00447 protected:
00448   GenericProperty* clone() const { return new SchreierTransversalProperty(*this); }
00449 private:
00450   static const PropertyType theTypeID;
00451 };
00452 
00453 class WordDecomposerProperty : public DecomposeInSubgroupOfFPGroupProperty {
00454 public:
00455   WordDecomposerProperty(const DecomposeInSubgroupOfFPGroup& data) 
00456     : DecomposeInSubgroupOfFPGroupProperty(data) {}
00457   PropertyType actualType()   const { return type(); }
00458   static PropertyType type() { return theTypeID; }
00459   Chars propertyName() const { return "WordDecomposer"; }
00460 protected:
00461   GenericProperty* clone() const { return new WordDecomposerProperty(*this); }
00462 private:
00463   static const PropertyType theTypeID;
00464 };
00465 
00466 
00467 // By its nature as a `knowledge representer', which no one knows how to
00468 // do, this has evolved in odd and sometimes conflicting ways as
00469 // requirements have become apparent.  It will need combing and
00470 // rethinking periodically.
00471 
00472 
00473 //---------------------------------------------------------------------------//
00474 //-------------------------------- GIC --------------------------------------//
00475 //---------------------------------------------------------------------------//
00476 
00477 
00478 class GIC : public InformationCenter, protected FEData
00479 {  
00480 public:
00481 
00482 // ----------------- Flags for solutions of word problem ------------------ //
00483 
00484  enum AlgorithmID { NONE, AB_INV, NORM_CLOSURE, REWR_SYSTEM, 
00485                      AUT_STRUCTURE, GENETIC, FREE };
00486 
00487   /////////////////////////////////////////////////////////////////////////
00488   //                                                                     //
00489   // Constructors:                                                       //
00490   //                                                                     //
00491   /////////////////////////////////////////////////////////////////////////
00492   
00493   GIC(OID group_oid);
00494 
00495   ~GIC( );
00496 
00497   /////////////////////////////////////////////////////////////////////////
00498   //                                                                     //
00499   // Reporting Information:                                              //
00500   //                                                                     //
00501   /////////////////////////////////////////////////////////////////////////
00502 
00503   void putHaveOrder( Integer the_order, Chars explanation = "", 
00504                      bool showExplanation = true );
00505 
00506   //void putHaveOrderUpperBound(Integer the_bound, Chars explanation);
00507 
00508   void putHaveSolvedWordProblem( Chars explanation, 
00509                                  bool bShowExplanation = true );
00510 
00511   void putHaveFastWordProblem( Chars explanation,
00512                                bool bShowExplanation = true );
00513 
00514   void putHaveCompleteCayleyGraph(SubgroupGraph CG);
00515 
00516   void putHaveConfluentKBMachine(KBMachine kbm);
00517 
00518   void putIsAutomatic( Trichotomy IsAutomatic );
00519 
00520   void putHaveAutomatic(GroupDFSA wa, DiffMachine dm);
00521 
00522   void putIsOneRelator(const Word& relator);
00523 
00524   void putIsOneRelatorWithTorsion(const Word& relator);
00525 
00526   void putHaveCyclicDecomposition( const AbelianGroup& );
00527 
00528   void putHavePrimaryDecomposition(const AbelianGroup& );
00529 
00530   void putHaveCanonicalSmithPresentation( const AbelianGroup& );
00531 
00532   void putIsAbelian( );
00533 
00534   void putIsFree( bool IsFree = true, Chars explanation = "" );
00535 
00536   void putIsFinite( bool IsFinite = true, Chars explanation = "",
00537                     bool showExplanation = true );
00538 
00539   void putHaveNilpotentQuotInited(const NilpotentGroup& theQuot, int theClass);
00540   void putHaveNilpotentGroupInited(const NilpotentGroup& theGroup, 
00541                                    Chars filename);
00542   void putIsFreeNilpotent(const FreeGroup& F, int theClass);
00543   void putIsNilpotent(int theClass);
00544 
00545 
00546   void putIsFreeByCyclic(const FreeGroup& F, const Map& aut);
00547 
00548   void putHaveMSC(FPGroup G, int lambda);
00549 
00550   void putHaveMSCLambda( int lambda );
00551 
00552   void putHaveAPOfFree( const AmalgProductOfFreeGroups& );
00553 
00554   void putHaveHNNofFree( const class HNNExtOfFreeGroup& );
00555 
00556   void putHaveSchreierTransvl(const PermutationRepresentation&);
00557 
00558   void putHaveWordDecomposer( const class DecomposeInSubgroupOfFPGroup& );
00559 
00560   /////////////////////////////////////////////////////////////////////////
00561   //                                                                     //
00562   // Reporting Secondary Information:                                    //
00563   //                                                                     //
00564   /////////////////////////////////////////////////////////////////////////
00565 
00566   void postSecondaryLogMessage(Chars message);
00567   // This may not be such a good place for this, but we at least have
00568   // a central location for reporting secondary chatter about what, e.g.,
00569   // a computation manager is doing to the log of the group.
00570 
00571   /////////////////////////////////////////////////////////////////////////
00572   //                                                                     //
00573   // Accessing Information:                                              //
00574   //                                                                     //
00575   /////////////////////////////////////////////////////////////////////////
00576 
00577   bool haveOrder( ) const;
00578   const Integer& getOrder( ) const;
00579   const Chars    getOrderExplanation( ) const;
00580   const Chars    getOrderMessage( ) const; 
00581 
00582   //@dp: const Integer& getOrderUpperBound( ) const; 
00583   //@dp: const Integer& getOrderLowerBound( ) const;
00584 
00585   bool haveSolvedWordProblem( ) const;
00586   bool haveFastWordProblem( ) const;
00587 
00588   bool haveCompleteCayleyGraph( ) const;
00589   SubgroupGraph getCompleteCayleyGraph( ) const; 
00590 
00591   bool haveConfluentKBMachine( ) const;
00592   const KBMachine& getConfluentKBMachine( ) const;
00593 
00594   Trichotomy isAutomatic( ) const;
00595   bool haveAutomatic( ) const;
00596   const Chars getAutomaticMessage( ) const;
00597   const GroupDFSA& getWordAcceptor( ) const;
00598   const DiffMachine& getDiffMachine( ) const;
00599 
00600   bool isOneRelatorWithTorsion( ) const;
00601   bool isOneRelator( ) const;
00602   Word getOneRelator( ) const;
00603   // When the group is one relator (but not necessarily the given
00604   // presentation), this returns the relator.
00605 
00606   bool haveCyclicDecomposition( ) const;
00607   bool havePrimaryDecomposition( ) const;
00608   const AbelianGroup& getCyclicDecomposition( ) const; 
00609   const Chars getCyclicDecompositionMessage( ) const;
00610 
00611   Trichotomy  isAbelian( ) const;
00612   Trichotomy  isFree( ) const;
00613   Trichotomy  isFinite( ) const;
00614   const Chars getFiniteExplanation( ) const;
00615   const Chars getFiniteMessage( ) const;
00616 
00617   bool haveNilpotentQuotInited (int theClass) const;
00618   bool haveNilpotentGroupInited(            ) const;
00619 
00620   //@dp: bool haveLCSQuotients() const;
00621 
00622   const NilpotentGroup& getNilpotentQuotInited (int theClass) const;
00623   const NilpotentGroup& getNilpotentGroupInited(            ) const;
00624   const Chars& getBasisFileName() const { return BCfileName; }
00625 
00626   Trichotomy isFreeNilpotent( ) const;
00627   Trichotomy isNilpotent( ) const;
00628   int getNilpotentcyClass( ) const;
00629 
00630   void putActualNilpotencyClass(int c );
00631   bool haveActualNilpotencyClass( ) const;
00632   int  getActualNilpotencyClass ( ) const;
00633 
00634 
00635   bool isFreeByCyclic( ) const;
00636   const FreeByCyclic& getFreeByCyclic( ) const;
00637 
00638   bool haveMSC( ) const;
00639   const MSCGroup& getMSC( ) const;
00640 
00641   bool haveMSCLambda( ) const;
00642   int  getMSCLambda( ) const;
00643   Chars getMSCMessage() const;
00644 
00645   bool haveAPOfFree( ) const;
00646   const AmalgProductOfFreeGroups& getAPOfFree( ) const;
00647 
00648   bool haveHNNofFree( ) const;
00649   const class HNNExtOfFreeGroup& getHNNofFree() const;
00650   
00651   bool haveSchreierTransvl() const;
00652   const PermutationRepresentation& getSchreierTransvl() const;
00653 
00654   bool haveWordDecomposer( ) const;
00655   const class DecomposeInSubgroupOfFPGroup& getWordDecomposer( ) const;
00656 
00657 private:
00658 
00659   GIC(const GIC&); // Disable copying
00660 
00661 
00662   AssociationsOf<int,NilpotentGroup*>& getNilpotentQuotients() const;
00663   
00664   /////////////////////////////////////////////////////////////////////////
00665   //                                                                     //
00666   // Data Members:                                                       //
00667   //                                                                     //
00668   /////////////////////////////////////////////////////////////////////////
00669 
00670   OID groupOID;
00671   // Need this for composing messages about what has been found.
00672   
00673   //  Trichotomy abelian;
00674   //  Trichotomy nilpotent;
00675   //  Trichotomy freeNilpotent;
00676 
00677   //  Trichotomy free;
00678   //  Chars freeExplanation;
00679 
00680   //  Trichotomy finite;
00681   //  Chars finiteExplanation;
00682   //  Chars finiteMessage;
00683 
00684   //  Integer order;
00685   //  Chars orderExplanation;
00686   //  Chars orderMessage;
00687   //  Integer orderUpperBound;
00688   //  Chars explainOrderUpperBound;
00689   //  Integer orderLowerBound;
00690 
00691   //  bool solvedWordProblem;
00692   //  bool fastWordProblem;
00693   //  Chars explainSolvedWordProblem;
00694 
00695   //  SubgroupGraph* theCayleyGraph;
00696   //  // Non-Null only when the group is finite, and we have built a
00697   //  // complete Cayley graph.
00698 
00699   //  bool KBMachineIsConfluent;
00700   //  KBMachine confluentKBMachine;
00701   //  // By default, machine accepting empty set
00702 
00703   //  Trichotomy IsAutomatic;
00704   //  Chars automaticMessage;
00705   //  GroupDFSA wordAcceptor;
00706   //  DiffMachine diffMachine;
00707 
00708   //  bool ORWithTorsion, OR;
00709   //  Word theOneRelator;
00710   //  // Is the relator iff the group is one relator.
00711 
00712   //  AbelianGroup* theAbelianGroup;
00713   //  // We may not have this yet. It is the structure of the group's
00714   //  // abelianization, which is the group itself when it is abelian.
00715   //  Chars theCyclicDecompositionMessage;
00716   //  FreeByCyclic* theFreeByCyclic;
00717 
00718   //  MSCGroup* theMSCGroup;
00719   //  // We may not have this yet. It is the MSC presentation in the
00720   //  // generators given by the end user.
00721 
00722   //  int MSCLambda;
00723   //  Chars MSCMessage;
00724 
00725   //  int nilpotencyClass;
00726   // Stores the class of nilpotent group. 
00727 
00728   //  int actualNilpotencyClass;
00729   // Computed class of nilpotent group.
00730 
00731   //AssociationsOf<int, NilpotentGroup*> theNilpotentQuotients;
00732 
00733   //  AmalgProductOfFreeGroups* theAPOfFree;
00734   //  class HNNExtOfFreeGroup* theHNNofFree;
00735   Chars BCfileName;
00736   //  PermutationRepresentation* permutationRepresentation;
00737   //  class DecomposeInSubgroupOfFPGroup *theWordDecomposer;
00738 };
00739 
00740 
00741 #endif

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