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

/magnus/back_end/NilpotentGroup/include/FPNilpotentGroupRep.h

Go to the documentation of this file.
00001 
00002 // Copyright (C) 1994 The New York Group Theory Cooperative
00003 // See magnus/doc/COPYRIGHT for the full notice.
00004 
00005 // Contents: Definition of the FPNilpotentGroupRep class.
00006 //
00007 // Principal Author: Eugene Paderin
00008 //
00009 // Status: Draft
00010 //
00011 // Revision History:
00012 //
00013 // Special Notes:
00014 //
00015 //
00016 
00017 #ifndef _FP_NILPOTENT_GROUP_REP_H_
00018 #define _FP_NILPOTENT_GROUP_REP_H_
00019 
00020 #include "Chars.h"
00021 #include "NilpotentGroupRep.h"
00022 #include "BasicCommutators.h"
00023 #include "LCSQuotients.h"
00024 
00025 //=====================================================================
00026 //================== struct FPNilpotentGroupRep =======================
00027 //=====================================================================
00028 
00029 struct FPNilpotentGroupRep : public NilpotentGroupRep {
00030 
00031   //-------------------------------------------------------------------
00032   //    Constructors / initializers
00033   //-------------------------------------------------------------------
00034 
00035 
00036   // To construct a group with named generators, given nilpotency class
00037   FPNilpotentGroupRep(const VectorOf<Chars>& gennames, 
00038                       int nilclass,
00039                       const VectorOf<Word>& rels,
00040                       enum NilpotentCollector::Type collectorType 
00041                       );
00042 
00043 
00044   virtual void initialize() const;
00045   // initializes the group (computes LCS)
00046   // Slow
00047 
00048   //-------------------------------------------------------------------
00049   //    Accessors
00050   //-------------------------------------------------------------------
00051 
00052   const BasicCommutators& commutators() const {
00053     return theCollector.commutators();
00054   }
00055   //Returns the basic commutators of the group's free preimage
00056 
00057   int nilpotencyClass() const {
00058     return nilClass;
00059   }
00060   // Returns the nilpotency class
00061 
00062   const NGCollector& collector() const {
00063     return theCollector;
00064   }
00065 
00066   bool isInitialized() const {
00067     return LCScomputed;
00068   }
00069   // True iff the group is initialized
00070 
00071   VectorOf<Word> relators() const { 
00072     return theRelators; 
00073   }
00074 
00075   VectorOf<Word> relationSubgroupGenerators() const;
00076   // Returns the generators of the relation subgroup
00077   //Slow, does not require initialization
00078 
00079   VectorOf<PolyWord> basis() const;
00080   // The basis of the group
00081   //Fast, but requires initialization
00082 
00083   VectorOf<Chars> basisNames() const;
00084   // The basis of the group
00085   //Fast, but requires initialization
00086 
00087   static Type type( );
00088   // dominates FGGroupRep::type()
00089 
00090 
00091   //-------------------------------------------------------------------
00092   //    Methods dealing with the properties of the group:
00093   //-------------------------------------------------------------------
00094 
00095   // All methods within this section are fast but require initialization
00096 
00097   //  Redefine inherited from GroupRep:
00098   int order( ) const;
00099   Trichotomy isTrivial( ) const;
00100   Trichotomy isFinite( ) const;
00101   Trichotomy isInfinite( ) const;
00102   Trichotomy isAbelian( ) const;
00103   Trichotomy isFree( ) const;
00104 
00105   int theHirschNumber() const;
00106   // returns the Hirsch number (the number of basic commutators of infinite order)
00107   
00108   // Native methods
00109 
00110   bool isFreeNilpotent( int* freeRank, int* freeClass ) const;
00111   // returns true iff the group is free nilpotent.
00112   // in this case also returns its rank and nilpotency class.
00113 
00114   int minimalNilpotencyClass( ) const;
00115   // returns the minimal nilpotency class of the group
00116 
00117   bool isMalcevBasis() const;
00118   // returns true iff the basis found in computeLCSQuotients() 
00119   // is the Malcev basis
00120 
00121   Integer orderOfTheTorsionSubgroup( ) const;
00122   // Returns order of the torsion subgroup.
00123 
00124   //class PresentationForNG makePresentation() const;
00125   // produces FP presentation of the group
00126   // Inherited from NilpotentGroupRep
00127 
00128   ///////////////////////////////////////////////////////
00129   //                                                   //
00130   //  Methods which deal with morpisms                 //
00131   //                                                   //
00132   ///////////////////////////////////////////////////////
00133 
00134   VectorOf<Word> inverseAuto(const VectorOf<Word>& V) const{
00135       error("Inverse automorphism for FP nilpotent group not emplemented yet");
00136   }
00137  
00138   //-------------------------------------------------------------------
00139   //  Methods dealing with group elements
00140   //-------------------------------------------------------------------
00141 
00142   // Inherited from FGGroupRep:
00143 
00144   // virtual Elt makeIdentity( ) const;
00145   // returns empty Word
00146 
00147   // virtual Bool isSyntacticIdentity( const Elt& e) const;
00148 
00149   // virtual Elt firstElt( ) const;
00150   // virtual Elt nextElt( const Elt& e ) const;
00151   // virtual Elt multiply( const Elt& e1, const Elt& e2 ) const;
00152   // virtual Elt inverseOf( const Elt& e ) const;
00153   // virtual Elt raiseToPower(const Elt&, int) const;
00154   // virtual Elt conjugateBy(const Elt&, const Elt&) const;
00155   // virtual Elt commutator(const Elt&, const Elt&) const;
00156 
00157   //@ep an Elt of this group is a Word, so I left these methods unchanged.
00158   // Most of them demand more careful design of the whole hierarchy.
00159   
00160 
00161   // Inherited from NilpotentGroupRep:
00162 
00163   
00164   Trichotomy conjugacyProblem( const Word& u, const Word& v ) const;
00165   //@ep to do
00166 
00167   //virtual Trichotomy isTrivialElt( const Elt& e ) const;
00168 
00169   //virtual bool isProperPower(const PolyWord& pw) const;
00170   // returns true iff the word is proper power
00171 
00172 
00173   // The following methods override those from FGGroupRep
00174   
00175   Trichotomy wordProblem( const Word& w ) const;
00176 
00177   Trichotomy areEqual(const Elt& e1, const Elt& e2) const;
00178 
00179 
00180   //------------------------------------------------------------
00181   //  Conversions from one basis to another:
00182   //------------------------------------------------------------
00183 
00184   //virtual PolyWord decompose(const Word& w) const;
00185   // decomposes the given word in terms of the group basis
00186   // input: word in terms of group generators
00187   // output: word in terms of group basis.
00188   // Inherited
00189 
00190   virtual PolyWord decompose(const PolyWord& w) const;
00191   // decomposes the given word in terms of the group basis
00192   // input: word in terms of basic commutators (not collected)
00193   // output: word in terms of group basis.
00194 
00195 
00196   //Word toWord(const PolyWord& w) const;
00197   // Transforms the given PolyWord to a common Word in terms of
00198   // the group
00199   //Inherited
00200 
00201   virtual PolyWord toCommutatorWord(const PolyWord& pw) const;
00202   //input: word in terms of the group basis
00203   //output: word in terms of the basic commutators (not collected)
00204 
00205   //Chars asDecomposition(const PolyWord& decomposition) const;
00206   // Input: word in terms of group basis.
00207   // Output: text in terms of group basis.
00208   //Inherited
00209 
00210 
00211   //-----------------------------------------------------------
00212   //  Properties of the group elements:
00213   //-----------------------------------------------------------
00214 
00215   virtual int weightOf(const Word& w) const;
00216   // determines in which term of the lower central series w lies
00217   // nilclass + 1 if the word is trivial
00218 
00219   virtual int weightOf(const PolyWord& pw) const {
00220     return weightOfDecomposed(pw);
00221   }
00222   // determines in which term of the lower central series w lies
00223   // nilClass + 1 if the word is trivial
00224   //w is given in terms of the group basis
00225 
00226 
00227   virtual int orderOfBasic(Generator g) const;
00228   //Returns order of the basic word corresponding to the generator g.
00229   //0 means infinity.
00230 
00231   virtual int orderOf(const Word& w) const;
00232   //Returns the order of the word given in terms of group generators
00233 
00234   virtual int orderOf(const PolyWord& w) const;
00235   //Returns the order of the word given in terms of group basis
00236 
00237    VectorOf<Word> centralizer( const Word& w) const;
00238 
00239   // Inherited from NilpotentGroupRep:
00240 
00241   //virtual bool isInCommutatorSubgroup(const Word& w) const;
00242 
00243   //virtual bool isCentral(const Word& w) const;
00244   // returns true iff w lies in the group center
00245   // time consuming
00246 
00247   //void maximalRoot(const Word& w, PolyWord& root, int& power ) const;
00248 
00249   virtual void maximalRoot(const PolyWord& pw, PolyWord& root, int& power ) const;
00250   // finds maximal root of pw.
00251   // Time consuming.
00252   // pw is in terms of the group basis.
00253   // root is in terms of the group basis.
00254   //@ep NOT IMPLEMENTED
00255 
00256   // bool isProperPower(const PolyWord& pw) const;
00257   // returns true iff the word is proper power
00258   // Inherited from NilpotentGroupRep
00259 
00260   virtual LCSQuotient getLCSQuotient( int N ) const; 
00261   // returns the N_th LCSQuotient 
00262   // can be used only after calling initialize()
00263 
00264   
00265   //-------------------------------------------------------------------
00266   // I/O:
00267   //-------------------------------------------------------------------
00268 
00269   virtual void printBasis( ostream& BClist ) const;
00270   // outputs the basis to a file
00271 
00272   virtual void write( ostream& ostr ) const;
00273   virtual void read( istream& istr );
00274   //IPC tools
00275 
00276   //-------------------------------------------------------------------
00277   // Internal methods
00278   //-------------------------------------------------------------------
00279 
00280 
00281   void computeLCSQuotients() const;    // Logical const!
00282 
00283   void computeQuotient( int theWeight );
00284 
00285   PolyWord decomposeInQuotient(PolyWord& rest, int k ) const;
00286 
00287   Word decomposeInQuotientPresentation(const Word& w, int k ) const;
00288 
00289   PolyWord decomposeFromQuotientPresentation(const PolyWord& w, int k ) const;
00290 
00291  const AbelianGroup& abelianization() const;
00292   //Returns LCS[1]
00293 
00294   virtual int weightOfDecomposed( const PolyWord& pw) const;
00295   // Returns the weight of the word decomposed in terms of group basis.
00296 
00297   //-------------------------------------------------------------------
00298   //    Representation methods
00299   //-------------------------------------------------------------------
00300         
00301   PureRep* clone( ) const { return new FPNilpotentGroupRep(*this); }
00302   // overrides NilpotentGroupRep::clone()
00303 
00304   static const Type theFPNilpotentGroupType;
00305 
00306 
00307   Type actualType( ) const { return type(); }
00308   // overrides FGGroupRep::actualType();
00309   
00310   //-------------------------------------------------------------------
00311   // Data members:
00312   //-------------------------------------------------------------------
00313 
00314   // Inherited:
00315   // int theOrder;
00316   // int theNumberOfGenerators;
00317   // VectorOf<Chars> theNamesOfGenerators;
00318 
00319   int nilClass;  
00320   NGCollector theCollector;
00321 
00322   VectorOf<Word> theRelators;
00323 
00324   VectorOf<LCSQuotient> LCS;
00325   bool LCScomputed;
00326   int hirschNumber;
00327 
00328   VectorOf<PolyWord> theBasis;
00329   VectorOf<Chars> theBasisNames;
00330   VectorOf<int> theBasisOrders;
00331   
00332 };
00333 
00334 #endif
00335 

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