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

/magnus/back_end/NilpotentGroup/include/SGOfFPNGRep.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 SGOfFPNilpotentGroupRep class
00006 //
00007 // Principal Author: Eugene Paderin
00008 //
00009 // Status: Draft
00010 //
00011 // Description:
00012 //
00013 // Special Notes:
00014 //
00015 // Revision History:
00016 //
00017  
00018 #ifndef _SG_OF_FPNG_REP_H_
00019 #define _SG_OF_FPNG_REP_H_
00020 
00021 #include "SGOfNilpotentGroupRep.h"
00022 #include "NilpotentGroup.h"
00023 #include "SubgroupBasis.h"
00024 
00025 //=======================================================================
00026 //=============== class SGOfFPNilpotentGroupRep =======================
00027 //=======================================================================
00028 
00029 
00030 class SGOfFPNilpotentGroupRep : public SGOfNilpotentGroupRep {
00031 
00032 public:
00033 
00034   //---------------------------------------------------------------------
00035   //    Constructors / Initializers:
00036   //---------------------------------------------------------------------
00037 
00038   SGOfFPNilpotentGroupRep(const NilpotentGroup& ng, 
00039                             const VectorOf<Word>& gens);
00040   //Constructs a representation for subgroup of free nilpotent group
00041 
00042   virtual void initPreimage( ) const;    // logical const !
00043   // the initialization of thePreimageBasis
00044   // Slow
00045 
00046   virtual void initParent( ) const;   // logical const !
00047   // The initialization of theParentGroup.
00048   // Slow
00049 
00050   virtual void initBasis( ) const;     // logical const !
00051   // Finding the basis of the subgroup.
00052   // Slow
00053 
00054 
00055   //---------------------------------------------------------------------
00056   //  Accessors:
00057   //---------------------------------------------------------------------
00058 
00059 
00060   virtual const class NilpotentGroup& parentGroup() const {
00061     return theBasisSet.parentGroup();
00062   }
00063   // returns the parent group
00064 
00065   virtual const class VectorOf<Word>& generators() const {
00066     return theBasisSet.generators();
00067   }
00068   // returns the generators
00069 
00070 
00071   virtual const class MalcevSet& preimageBasis() const;
00072   // returns the basis of subgroup preimage
00073 
00074   bool preimageIsInitialized( ) const {
00075     return thePreimage.isMalcevBasis();
00076   }
00077   // returns true iff the preimage is initialized
00078 
00079   bool parentIsInitialized( ) const {
00080     return parentGroup().isInitialized();
00081   }
00082   
00083   bool basisIsInitialized( ) const {
00084     return theBasisSet.isFull();
00085   }
00086   // returns true iff the subgroup basis is computed
00087     
00088   VectorOf<PolyWord> basis() const;
00089   // returns the basis of the subgroup in terms of the group basis
00090   // Fast, requires the basis
00091 
00092   VectorOf<Chars> basisNames() const;
00093   // returns the names of basis words
00094   // Fast, requires the basis
00095 
00096 
00097   //---------------------------------------------------------------------
00098   // Methods dealing with subgroup properties:
00099   //---------------------------------------------------------------------
00100 
00101   virtual int theHirschNumber() const {
00102     return theBasisSet.theHirschNumber();
00103   }
00104   // returns the Hirsch number of the subgroup
00105   // fast, the basis must be initialized
00106 
00107   //int index() const;
00108   // Returns the index of this subgroup in its parent group
00109   // 0 if infinite
00110   // Inherited
00111 
00112   //bool isAFreeFactor() const;
00113   // Returns true iff this subgroup is a free factor of the parent group
00114 
00115   //bool isTrivial() const;
00116   // Returns true iff this subgroup is trivial
00117   //Inherited
00118 
00119   //bool isCentral() const;
00120   // Returns true iff this subgroup is central
00121   //Inherited
00122 
00123   //bool isNormal() const {
00124   //  return theBasisSet.isNormalClosure();
00125   //}
00126   // Returns true iff this subgroup is normal
00127   // Slow, the basis must be initialized
00128 
00129   //bool isAbelian() const;
00130   // Returns true iff this subgroup is abelian
00131   // Slow, does not require initialization
00132   //Inherited
00133 
00134   //int subgroupClass() const;
00135   // returns the class of subgroup
00136   //Inherited
00137 
00138   virtual int order() const;
00139   // returns the order of subgroup (0 means infinite).
00140   // Fast, requires initialization of the parent group and the basis
00141 
00142 
00143   //---------------------------------------------------------------------
00144   //  Methods producing related structures
00145   //---------------------------------------------------------------------
00146 
00147   //virtual SGOfNilpotentGroup centraliser() const = 0;
00148   // returns the centralizer of the subgroup
00149   
00150 
00151   //virtual SGOfNilpotentGroup normaliser() const = 0;
00152   // returns the normalizer of the subgroup
00153 
00154   //virtual SGOfNilpotentGroup isolator() const = 0;
00155   // returns the isolator of the subgroup
00156 
00157   virtual VectorOf<Word> normalClosureBasis() const;
00158   // returns the normal closure of the subgroup
00159   // Slow, does not require initialization
00160 
00161   //virtual PresentationForSNG makePresentation() const;
00162   // produces FP presentation of the subgroup
00163   // Slow, requires the preimage basis to be built
00164   // Inherited
00165 
00166   //---------------------------------------------------------------------
00167   //  Methods dealing with other subgroups
00168   //---------------------------------------------------------------------
00169 
00170   //VectorOf<Word> join(const class SGOfNilpotentGroup& SGR) const;
00171   // Returns the join of this subgroup and the argument.
00172   // no intialization is necessary
00173   // Inherited
00174 
00175   //VectorOf<Word> join(const VectorOf<Word>& V) const;
00176   // Returns the join of this subgroup and the argument.
00177   // no intialization is necessary
00178   // Inherited
00179 
00180   //virtual SGOfNilpotentGroup intersection(SGOfNilpotentGroup& SGR) const = 0;
00181   // Returns the intersection of this subgroup and the argument.
00182 
00183   //bool contains(const VectorOf<Word>& V) const;
00184   // Returns true iff this subgroup contains the subgroup generated by `V'.
00185   // Slow, requires initialization
00186   // Inherited
00187 
00188   //virtual bool conjugateTo(const SetOf<Word>& S) const = 0;
00189   // Returns true iff this subgroup and the argument are conjugate.
00190 
00191   //virtual bool conjugateTo(const SGOfNilpotentGroup& S) const = 0;
00192   // Returns true iff this subgroup and the argument are conjugate.
00193 
00194 
00195   //---------------------------------------------------------------------
00196   // Methods dealing with group elements:
00197   //---------------------------------------------------------------------
00198 
00199   //bool contains(const Word& w) const;
00200   // Returns true iff this subgroup contains `w'.
00201   // Slow, requires initialization
00202   // Inherited
00203 
00204   bool decompose(const PolyWord& w, PolyWord& decomp) const;
00205   // Finds decomposition of the subgroup element w
00206   // returns true iff w is an element of the subgroup
00207   // Slow, requires initialization
00208   // Input: w, in terms of the group basis
00209   // Output: decomp, in terms of the subgroup basis
00210 
00211   //virtual bool conjugateInSubgroup(const Word& w, Word& conjugator) const = 0;
00212   // Returns true iff some conjugate of `w' is in the subgroup.
00213   // If true, `conjugator' is set to the conjugator.
00214 
00215   //virtual int powerInSubgroup( const Word& w ) const = 0;
00216   // returns `the minimal power' or 0 if there are no powers of the
00217   // element w in H.
00218 
00219 
00220   //---------------------------------------------------------------------
00221   // I/O:
00222   //---------------------------------------------------------------------
00223  
00224   virtual void printBasis(ostream&) const;
00225 
00226   virtual ostream& writeIPC(ostream& s) const;
00227 
00228   virtual istream& readIPC(istream& s) const;  // Logical const!
00229 
00230   virtual Chars asDecomposition( const PolyWord& p ) const;
00231   // Produces string presentation of decomposed subgroup element
00232 
00233 
00234   //-------------------------------------------------------------------
00235   //    Representation methods
00236   //-------------------------------------------------------------------
00237         
00238 
00239   static const Type theSGOfFPNilpotentGroupType;
00240 
00241   static Type type( ) { return theSGOfFPNilpotentGroupType; }
00242 
00243   virtual Type actualType( ) const { return type(); }
00244 
00245 protected:
00246 
00247   virtual GenericRep* clone( ) const;
00248 
00249   //-------------------------------------------------------------------
00250   //    Data
00251   //-------------------------------------------------------------------
00252 
00253 
00254 private:
00255 
00256   MalcevSet thePreimage;
00257   bool preimageInitialized;
00258 
00259   SubgroupBasis theBasisSet;
00260   VectorOf<PolyWord> theBasis;
00261   VectorOf<Chars> theBasisNames;
00262 
00263 };
00264 
00265 
00266 #endif
00267 

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