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

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

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