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

/magnus/back_end/NilpotentGroup/include/SGOfNilpotentGroup.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 SGOfNilpotentGroup class
00006 //
00007 // Principal Author: Eugene Paderin
00008 //
00009 // Status: Draft
00010 //
00011 // Description:
00012 //
00013 // Special Notes:
00014 //
00015 //  * There are various ways to represent an element of the subgroup.
00016 //    See comments to the file "NilpotentGroup.h".
00017 //
00018 //    Another form of presentation is added: PolyWord in terms of the
00019 //    subgroup basis.
00020 //
00021 // Revision History:
00022 //
00023  
00024 #ifndef _SG_OF_NILPOTENT_GROUP_H_
00025 #define _SG_OF_NILPOTENT_GROUP_H_
00026 
00027 #include "SGOfNilpotentGroupRep.h"
00028 
00029 
00030 //=======================================================================
00031 //=================== class SGOfNilpotentGroup ==========================
00032 //=======================================================================
00033 
00034 
00035 class SGOfNilpotentGroup : public ObjectOf<SGOfNilpotentGroupRep> {
00036 
00037 public:
00038 
00039   //---------------------------------------------------------------------
00040   //   Constructors / Initializers:
00041   //---------------------------------------------------------------------
00042 
00043   SGOfNilpotentGroup(const NilpotentGroup& ng, const VectorOf<Word>& gens);
00044   // constructs the subgroup of nilpotent group ng
00045 
00046 
00047   void initPreimage( ) const {    // logical const !
00048     look()->initPreimage( );
00049   }
00050   // the initialization of the preimage
00051 
00052   void initParent( ) const {    // logical const !
00053     look()->initParent( );
00054   }
00055   // The initialization of the parent group
00056   
00057   void initBasis( ) const {    // logical const !
00058     look()->initBasis( );
00059   }
00060   // Finding the basis of the subgroup.
00061   // Performs initPreimage and initParent before initialization
00062   // After this, the subgroup is completely initialized
00063   
00064 
00065   //---------------------------------------------------------------------
00066   //  Accessors/modifiers:
00067   //---------------------------------------------------------------------
00068 
00069 
00070   const class NilpotentGroup& parentGroup() const {
00071     return look()->parentGroup();
00072   }
00073   // returns the parent group
00074 
00075 
00076   const class VectorOf<Word>& generators() const {
00077     return look()->generators();
00078   }
00079   // returns the generators
00080 
00081 
00082   const class MalcevSet& preimageBasis() const {
00083     return look()->preimageBasis();
00084   }
00085   // returns the basis of subgroup's full preimage
00086 
00087   bool preimageIsInitialized( ) const {
00088     return look()->preimageIsInitialized( );
00089   }
00090   // returns true iff the preimage is initialized
00091 
00092   bool parentIsInitialized( ) const {
00093     return look()->parentIsInitialized( );
00094   }
00095   // returns true iff the parent group is initialized
00096 
00097   bool basisIsInitialized( ) const {
00098     return look()->basisIsInitialized( );
00099   }
00100   // returns true iff the subgroup basis is computed
00101 
00102   static Type type( ) { return SGOfNilpotentGroupRep::type(); }
00103 
00104   Type actualType( ) const { return look()->actualType(); }
00105 
00106   VectorOf<PolyWord> basis() const {
00107     return look()->basis();
00108   }
00109   // returns the basis of the subgroup in terms of the group basis
00110   // Fast, requires the basis
00111 
00112   VectorOf<Chars> basisNames() const {
00113     return look()->basisNames();
00114   }
00115   // returns the names of basis words
00116   // Fast, requires the basis
00117 
00118   //---------------------------------------------------------------------
00119   // Methods dealing with subgroup properties:
00120   //---------------------------------------------------------------------
00121 
00122   int theHirschNumber() const {
00123     return look()->theHirschNumber();
00124   }
00125   // returns the Hirsch number of the subgroup
00126   // not implemented
00127 
00128   int index() const {
00129     return look()->index();
00130   }
00131   // Returns the index of this subgroup in its parent group
00132   // 0 if infinite
00133   // Slow, requires theParentGroup to be initialized
00134 
00135   //bool isAFreeFactor() const;
00136   // Returns true iff this subgroup is a free factor of the parent group
00137   // not implemented
00138 
00139   bool isTrivial() const {
00140     return look()->isTrivial();
00141   }
00142   // Returns true iff this subgroup is trivial
00143   // fast, but requires theParentGroup to be initialized
00144 
00145   bool isCentral() const {
00146     return look()->isCentral();
00147   }
00148   // Returns true iff this subgroup is central
00149   // **time consuming, requires theParentGroup to be initialized
00150 
00151   bool isNormal() const {
00152     return look()->isNormal();
00153   }
00154   // Returns true iff this subgroup is normal
00155   // **time consuming, requires thePreimage to be initialized
00156 
00157   bool isAbelian() const {
00158     return look()->isAbelian();
00159   }
00160   // Returns true iff this subgroup is abelian
00161   // **time consuming, requires theParentGroup to be initialized
00162 
00163   int subgroupClass() const {
00164     return look()->subgroupClass();
00165   }
00166   // returns the class of subgroup
00167   // **time consuming, requires theParentGroup to be initialized
00168 
00169   int order() const {
00170     return look()->order();
00171   }
00172   // returns the order of subgroup (0 means infinite).
00173   // Fast, requires initialization of the parent group and the basis
00174 
00175   //---------------------------------------------------------------------
00176   //  Methods producing related structures
00177   //---------------------------------------------------------------------
00178 
00179   //SGOfNilpotentGroup centraliser() const {
00180   // returns the centralizer of the subgroup
00181   
00182 
00183   //SGOfNilpotentGroup normaliser() const {
00184   // returns the normalizer of the subgroup
00185 
00186   //SGOfNilpotentGroup isolator() const {
00187   // returns the isolator of the subgroup
00188 
00189   VectorOf<Word> normalClosureBasis() const {
00190     return look()->normalClosureBasis();
00191   }
00192   // returns a basis of normal closure of the subgroup
00193   // words are in terms of the group generators
00194 
00195   VectorOf<Word> normalClosureGens() const {
00196     return look()->normalClosureGens();
00197   }
00198   // returns the generators of normal closure of the subgroup
00199   // words are in terms of the group generators
00200 
00201   PresentationForSNG makePresentation() const {
00202     return look()->makePresentation();
00203   }
00204   // produces FP presentation of the subgroup
00205   // requires the preimage basis to be built
00206 
00207   //---------------------------------------------------------------------
00208   //  Methods dealing with other subgroups
00209   //---------------------------------------------------------------------
00210 
00211   VectorOf<Word> join(const SGOfNilpotentGroup& SGR) const {
00212     return look()->join(SGR);
00213   }
00214   // Returns the join of this subgroup and the argument.
00215   // no intialization is necessary
00216 
00217   VectorOf<Word> join(const VectorOf<Word>& V) const {
00218     return look()->join(V);
00219   }
00220   // Returns the join of this subgroup and the argument.
00221   // no intialization is necessary
00222   // words are in terms of the group generators
00223 
00224   //SGOfNilpotentGroup intersection(SGOfNilpotentGroup& SGR) const {
00225   // Returns the intersection of this subgroup and the argument.
00226 
00227   bool contains(const VectorOf<Word>& V) const {
00228     return look()->contains(V);
00229   }
00230   // Returns true iff this subgroup contains the subgroup generated by `V'.
00231   // ** time consuming, requires theFullPreimage initialization
00232 
00233   bool contains(const SGOfNilpotentGroup& SG) const {
00234     return look()->contains(SG.generators());
00235   }
00236   // Returns true iff this subgroup contains `SG'.
00237   //@ep add validity check and explanation
00238   // ** time consuming, requires theFullPreimage initialization
00239 
00240   bool equalTo(const SGOfNilpotentGroup& SG) const {
00241     return contains(SG) && SG.contains(*this);
00242   }
00243   //Returns true iff this subgroup and SG are equal.
00244   //@ep add explanation
00245   // ** time consuming, requires theFullPreimage initialization
00246 
00247   //bool conjugateTo(const SetOf<Word>& S) const {
00248   // Returns true iff this subgroup and the argument are conjugate.
00249 
00250   //bool conjugateTo(const SGOfNilpotentGroup& S) const {
00251   // Returns true iff this subgroup and the argument are conjugate.
00252 
00253 
00254   //---------------------------------------------------------------------
00255   // Methods dealing with group elements:
00256   //---------------------------------------------------------------------
00257 
00258   bool contains(const Word& w) const {
00259     return look()->contains(w);
00260   }
00261   // Returns true iff this subgroup contains `w'.
00262   // Slow, requires theFullPreimage initialization
00263   // w is in terms of the group generators
00264 
00265   bool decompose(const PolyWord& w, PolyWord& decomp) const {
00266     return look()->decompose(w, decomp);
00267   }
00268   // Finds decomposition of the subgroup element w
00269   // returns true iff w is an element of the subgroup
00270   // Input: w, in terms of the group basis
00271   // Output: decomp, in terms of the subgroup basis
00272 
00273   //bool conjugateInSubgroup(const Word& w, Word& conjugator) const {
00274   // Returns true iff some conjugate of `w' is in the subgroup.
00275   // If true, `conjugator' is set to the conjugator.
00276 
00277   //int powerInSubgroup( const Word& w ) const {
00278   // returns `the minimal power' or 0 if there are no powers of the
00279   // element w in H.
00280 
00281 
00282   //---------------------------------------------------------------------
00283   // I/O:
00284   //---------------------------------------------------------------------
00285  
00286   void printBasis(ostream& s) const {
00287     look()->printBasis(s);
00288   }
00289 
00290   ostream& writeIPC(ostream& s) const {
00291     return look()->writeIPC(s);
00292   }
00293 
00294   istream& readIPC(istream& s) const {  // Logical const!
00295     return look()->readIPC(s);
00296   }
00297 
00298   Chars asDecomposition( const PolyWord& p ) const {
00299     return look()->asDecomposition(p);
00300   }
00301   // Produces string presentation of decomposed subgroup element
00302   // Input: word in terms of the subgroup basis
00303 
00304 
00305   //---------------------------------------------------------------------
00306   // Internal methods:
00307   //---------------------------------------------------------------------
00308 
00309 private:
00310 
00311   static SGOfNilpotentGroupRep* makeRep(const NilpotentGroup& ng,
00312                                         const VectorOf<Word>& gens);
00313   //Produces a representation depending on group's type
00314 
00315 
00316 };
00317 
00318 
00319 //======================================================================
00320 //======================= Global functions =============================
00321 //======================================================================
00322 
00323 inline ostream& operator < (ostream& s, const SGOfNilpotentGroup& g) {
00324   return g.writeIPC(s);
00325 }
00326 // IPC output
00327 
00328 
00329 inline istream& operator > (istream& s, const SGOfNilpotentGroup& g) {
00330   return g.readIPC(s);
00331 }
00332 // IPC intput
00333 
00334 
00335 #endif
00336 

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