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

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

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