\documentclass{article}
\usepackage{noweb}
\begin{document}
\title{The structure of Magnus}
\author{Nicolas Bourbaki}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\section{The global classes}
\subsection{global/BaseObjectOf.h}
<<BaseObjectOf.h>>=
#include "PureRep.h"
#include "ObjectOf.h"

<<template BaseObjectOf>>

@
\subsubsection{template BaseObjectOf}
<<template BaseObjectOf>>=
template<class Rep> class BaseObjectOf : private ObjectOf<Rep> {
public:
protected:
  ObjectOf<Rep>::look;
  ObjectOf<Rep>::change;
  ObjectOf<Rep>::enhance;
  ObjectOf<Rep>::acquireRep;
  BaseObjectOf( Rep* newrep ) : ObjectOf<Rep>( newrep) 
private:
  void force_derivation( ) 
};

@
\subsection{global/DerivedObjectOf.h}
\subsubsection{template DerivedObjectOf}
<<template DerivedObjectOf>>=
template <class Base, class Rep> class DerivedObjectOf : public Base {
public:
  const Rep* look( ) const 
  Rep* enhance( ) const 
  Rep* change( ) 
  DerivedObjectOf( Rep* newrep ) : Base( newrep ) 
  DerivedObjectOf( const Base& b ) : Base( b ) 
};

@
\subsection{global/ExtendedIPC.h}
<<ExtendedIPC.h>>=
#include "Integer.h"
#include "Rational.h"

inline ostream& operator < ( ostream& ostr, const Integer& n )
inline ostream& operator < ( ostream& ostr, const Rational& r )
inline istream& operator > ( istream& istr, Integer& n )
inline istream& operator > ( istream& istr, Rational& r )

@
\subsection{global/GenericObject.h}
<<GenericObject.h>>=
#include "PureRep.h"
#include "BaseObjectOf.h"
#include "Type.h"

<<struct GenericRep>>
<<class GenericObject>>

@
\subsubsection{struct GenericRep}
<<struct GenericRep>>=
struct GenericRep : public PureRep {
  static const Type theGenericObjectType;
  static Type type() 
  virtual Type actualType() const 
  PureRep* clone( ) const 
};

@
\subsubsection{class GenericObject}
<<class GenericObject>>=
class GenericObject : protected BaseObjectOf<GenericRep> {
public:
  GenericObject( ) : BaseObjectOf<GenericRep>( new GenericRep ) 
  static Type type() 
  Type actualType() const 
protected:
  GenericObject( GenericRep* newrep ) : BaseObjectOf<GenericRep>(newrep) 
};

@
\subsection{global/IPC.h}
<<IPC.h>>=
inline ostream& operator < ( ostream& ostr, int n )
inline ostream& operator < ( ostream& ostr, unsigned int n )
inline ostream& operator < ( ostream& ostr, short n )
inline ostream& operator < ( ostream& ostr, long n )
inline ostream& operator < ( ostream& ostr, bool b )
inline ostream& operator < ( ostream& ostr, char c )
inline ostream& operator < ( ostream& ostr, const char *s )
inline ostream& operator < ( ostream& ostr, const double d )

inline istream& operator > ( istream& istr, int& n )
inline istream& operator > ( istream& istr, unsigned int& n )
inline istream& operator > ( istream& istr, short& n )
inline istream& operator > ( istream& istr, long& n )
inline istream& operator > ( istream& istr, bool& b )
inline istream& operator > ( istream& istr, char& c )
inline istream& operator > ( istream& istr, char* s )
inline istream& operator > ( istream& istr, double d )
inline istream& operator > ( istream& istr, void* p )

@
\subsection{global/ObjectOf.h}
<<ObjectOf.h>>=
#include "RefCounter.h"

<<template ObjectOf>>

@
\subsubsection{template ObjectOf}
<<template ObjectOf>>=
template<class Rep> class ObjectOf {
public:
  ObjectOf( const ObjectOf& o ) 
 ~ObjectOf() 
  ObjectOf& operator = ( const ObjectOf& o )
protected:
  const Rep* look( ) const 
  Rep* enhance( ) const 
  Rep* change( ) 
  void acquireRep( const Rep* rep )
  ObjectOf( Rep* newrep ) 
private:
  Rep* theRep;
  void force_derivation( ) 
};

@
\subsection{global/PureRep.h}
<<PureRep.h>>=
#include "RefCounter.h"

<<struct PureRep>>

@
\subsubsection{struct PureRep}
<<struct PureRep>>=
struct PureRep : public RefCounter 
{
  public :
    virtual ~PureRep( ) 
    virtual PureRep* clone( ) const = 0;
};

@
\subsection{global/RefCounter.h}
\subsubsection{class RefCounter}
<<class RefCounter>>=
class RefCounter 
{
  public:
    typedef unsigned int refCounterType;
    RefCounter( ) : xrefs(0) 
    RefCounter( const RefCounter& rc ) : xrefs(0) 
    bool lastRef( ) const 
    bool sharedRef( ) const 
    void addRef( ) const 
    void delRef( ) const 
  private:
    refCounterType xrefs; 
    RefCounter& operator = ( const RefCounter& );
};

@
\subsection{global/Trichotomy.h}
\subsubsection{class Trichotomy}
<<class Trichotomy>>=
class Trichotomy
{
  public:
    enum TrichotomyValue { DONTKNOW = -1, NO, YES };
    class dontknow 
    Trichotomy( bool b ) : theValue(convert(b)) 
    Trichotomy( int i ) : theValue(convert(i)) 
    Trichotomy( void* p ) : theValue(convert(p)) 
    Trichotomy( const dontknow& ) : theValue(DONTKNOW) 
    operator bool ( ) const
    operator int ( ) const
    inline friend bool operator == ( const Trichotomy& t, const Trichotomy& u )
    Trichotomy operator ! ( ) const
    bool defined( ) const 
    bool undefined( ) const 
    friend ostream& operator << ( ostream& ostr, const Trichotomy& t )
    friend ostream& operator < ( ostream& ostr, const Trichotomy& t )
    friend istream& operator > ( istream& istr, Trichotomy& t )
  private:
    static TrichotomyValue convert( bool b )
    static TrichotomyValue convert( void* p )
    TrichotomyValue theValue;
    inline bool operator != ( const Trichotomy& t, const Trichotomy& u )
    inline Trichotomy operator && ( const Trichotomy& t, const Trichotomy& u )
    inline Trichotomy operator || ( const Trichotomy& t, const Trichotomy& u )
    extern const Trichotomy YES, NO, DONTKNOW, yes, no, dontknow;

@
\section{The Apps classes}
\subsection{Apps/include/PresentationProblems.h}
<<PresentationProblems.h>>=
#include "FPGroup.h"
#include "FPGroupRep.h"
#include "KBMachine.h"
#include "RKBPackage.h"
#include "File.h"
#include "Subgroup.h"

<<class KernelOfHom>>
<<class ImageOfHom>>
<<class NewPresentation>>

@
\subsubsection{class KernelOfHom}
<<class KernelOfHom>>=
class KernelOfHom 
{
 public:
   KernelOfHom( const FPGroup& d, const FPGroup& r, 
                const KBMachine& k, const VectorOf<Word> v ) :
      domain( d ), range( r ), kb( k ), images( v ) 
   KernelOfHom( ) :
      domain(), range(), kb(), images() 
   FPGroup getKernelPresentation( );
 private: 
   FPGroup domain;
   FPGroup range;
   KBMachine kb;
   VectorOf<Word> images;

@
\subsubsection{class ImageOfHom}
<<class ImageOfHom>>=
class ImageOfHom 
{
  public:
    ImageOfHom( const FPGroup& d, const FPGroup& r, const VectorOf<Word> v ) :
      domain( d ), range( r ), images( v ) 
    ImageOfHom() :
      domain(), range(), images() 
    FPGroup getImageOfHomo( VectorOf<Word>& v );
 private: 
   FPGroup domain;
   FPGroup range;
   VectorOf<Word> images;
};

@
\subsubsection{class NewPresentation}
<<class NewPresentation>>=
class NewPresentation
{
  public:
    NewPresentation( const FPGroup& g, const KBMachine& k, 
                     const VectorOf<Word> v ) :
      G( g ), kb( k ), newBasis( v ) 
    NewPresentation( ) :
      G( ), kb( ), newBasis( ) 
    FPGroup getNewPresentation( );
  private:
    FPGroup G;
    KBMachine kb;
    VectorOf<Word> newBasis;
};

@
\section{The AProducts classes}
\subsection{AProducts/include/AmalgamatedProductParser.h}
<<AmalgamatedProductParser.h>>=
#include "PresentationParser.h"
#include "APofFreeGroups.h"
#include "APwithOneRelator.h"

<<class AmalgamatedProductParser>>

@
\subsubsection{class AmalgamatedProductParser}
<<class AmalgamatedProductParser>>=
class AmalgamatedProductParser : protected PresentationParser
{
  public:
    AmalgamatedProductParser(istream &istr) : PresentationParser(istr) 
    VectorOf<Word> parseAPRelator(const VectorOf<Chars>& names, 
                                  Chars& errMesg);
    VectorOf<Word> parseAPRelatorList(const VectorOf<Chars>& names,
                                      Chars& errMesg, int axRelators);
    void parseFactorsAndRelations(FreeGroup& f1, FreeGroup& f2,
                                  VectorOf<Word>& gens1, VectorOf<Word>& gens1,
                                  int maxRelators, Chars& errMesg);
    AmalgProductOfFreeGroupsRep* parseAPofFreeGroups( Chars& errMesg );
    APwithOneRelatorRep* parseAPwithOneRelator( Chars& errMesg );
};
\subsection{AProducts/include/AP-fixups.h}
<<AP-fixups.h>>=
#include "SGofFreeGroup.h"
#include "Associations.h"
#include "File.h"

<<struct RelatorConjugate>>
<<template swap>>
<<functions for SGofFreeGroup>>
<<template excludeFrom>>
<<template cyclicallyPermute>>
<<functions for FreeGroup>>
<<functions for Word>>
<<class DetailedReport>>

@
\subsubsection{struct RelatorConjugate}
<<struct RelatorConjugate>>=
struct RelatorConjugate 
{
  RelatorConjugate( ) : relator(), conjugator() 
  RelatorConjugate( const Word& r, const Word& c ) : 
    relator(r), conjugator(c) 
  bool operator==( const RelatorConjugate& t) const 
  Word relator, conjugator;
};
  inline ostream& operator<<( ostream& ostr, const RelatorConjugate& rc )
  inline istream& operator>>( istream& istr, RelatorConjugate& rc )
  inline ostream& operator<( ostream& ostr, const RelatorConjugate& rc )
  inline istream& operator>( istream& istr, RelatorConjugate& rc )
  typedef VectorOf<RelatorConjugate> ProductOfRelatorConjugates;
  ProductOfRelatorConjugates conjugateBy( 
    const ProductOfRelatorConjugates& product, const Word& conjugator );

@
\subsubsection{template swap}
<<template swap>>=
template <class T> inline void swap( T& a, T& b ) 
{
  T temp = a;
  a = b;
  b = temp;
}

@
\subsubsection{functions for SGofFreeGroup}
<<functions for SGofFreeGroup>>=
  inline ostream& operator << (ostream& o, const SGofFreeGroup& sg)

@
\subsubsection{template excludeFrom}
<<template excludeFrom>>=
template <class T> inline void excludeFrom(VectorOf<T>& v, int i)

@
\subsubsection{template cyclicallyPermute}
<<template cyclicallyPermute>>=
template< class T > VectorOf<T> cyclicallyPermute(const VectorOf<T>& v, int j)

@
\subsubsection{functions for FreeGroup}
<<functions for FreeGroup>>=
  void maximalRootInFreeGroup(const Word& w, Word& root, int& power);
  Trichotomy conjugacyProblem(const FreeGroup& G, const Word& u,
                              const Word& v, Word& conjugator );

@
\subsubsection{functions for Word}
<<functions for Word>>=
  VectorOf<int> exponentSum(const Word& w);
  Word cyclicallyReduce(const Word& w, Word& conjugator);
  Word compose(const VectorOf<Word>& v);
  inline int tailAgreementLength( const Word& u, const Word& v )
  int GCD2(int a, int b);
  Word cyclicallyShortenByRelators( 
    const Word& u, const SetOf<Word>& givenRelators,
    Word& conjugator, ProductOfRelatorConjugates& productOfRelatorConjugates);

@

\subsubsection{class DetailedReport}
<<class DetailedReport>>=
class DetailedReport
{
  public:
    DetailedReport( const FPGroup& group, const VectorOf<Word>& subgroup, 
                    const Chars fileName = File().getFileName() );
    DetailedReport( const FPGroup& group, 
                    const Chars fileName = File().getFileName() );
    ostream& file() 
    bool haveDetails( ) const;
    Chars getFileName( ) const;
    void printDehnTransformationDetails( const Word& w );
    void printTrivialWordDetails( const Word& w, 
                                  const ProductOfRelatorConjugates& deco, 
                                  const bool header );
    void printNonTrivialWordDetails( const Word& w, 
                                     const Chars& expl, 
                                     const bool header );
    void printTrivialGeneratorDetails( const Generator& g, 
                                       const ProductOfRelatorConjugates& deco, 
                                       const bool header );
    void printNonTrivialGeneratorDetails( const Generator& g, 
                                          const Chars& explanation, 
                                          const bool header );
    void printTrivialCommutatorDetails(const Chars& comm, 
                                       const ProductOfRelatorConjugates& deco, 
                                       const bool header );
    void printNonTrivialCommutatorDetails( const Chars& comm,
                                           const Chars& explanation, 
                                           const bool header );
    void printSubgroupElement( const Word& w, 
                               const ProductOfRelatorConjugates& deco, 
                               const bool header );
private:
  void printTrivialWordDecomposition( const ProductOfRelatorConjugates& deco );
  void printHeader( const bool header );
  void buildRelators( );
  bool bHaveDetails;
  File theFile;
  FPGroup G;
  VectorOf<Word> H; 
  bool builtRelators;
  AssociationsOf<Word, int> theRelators;
  AssociationsOf<Word, int> theSGenerators;
};

@
\subsection{AProducts/include/APofFreeGroups.h}
<<APofFreeGroups.h>>=
#include "FreeGroup.h"
#include "FPGroup.h"
#include "APofFreeGroupsRep.h"

<<class AmalgProductOfFreeGroups>>

@
\subsubsection{class AmalgProductOfFreeGroups}
<<class AmalgProductOfFreeGroups>>=
class AmalgProductOfFreeGroups : 
    public DerivedObjectOf<FPGroup,AmalgProductOfFreeGroupsRep> 
{
  public:
    AmalgProductOfFreeGroups() :
        DerivedObjectOf<FPGroup, AmalgProductOfFreeGroupsRep>(
          new AmalgProductOfFreeGroupsRep(FreeGroup(), FreeGroup(),
          VectorOf<Word>(), VectorOf<Word>() ) ) 
    AmalgProductOfFreeGroups(const FreeGroup& g1, const FreeGroup& g2,
          const VectorOf<Word>& gen1,
          const VectorOf<Word>& gen2  ) :
        DerivedObjectOf<FPGroup, AmalgProductOfFreeGroupsRep>(
          new AmalgProductOfFreeGroupsRep(g1, g2, gen1, gen2) ) 
    AmalgProductOfFreeGroups(const SGofFreeGroup& sg1, 
                             const SGofFreeGroup& sg2) :
        DerivedObjectOf<FPGroup, AmalgProductOfFreeGroupsRep>(
          new AmalgProductOfFreeGroupsRep(sg1, sg2) ) 
    AmalgProductOfFreeGroups( const Group& G ) :
        DerivedObjectOf<FPGroup,AmalgProductOfFreeGroupsRep>(G) 
    static Type type( )
    FreeGroup factor( const NumberOfFactor& t ) const;
    SGofFreeGroup subgroup( const NumberOfFactor& t ) const;
    Trichotomy isFree( ) const 
    VectorOf<Word> decompose(const Word& w) const 
    VectorOf<Word> reducedDecomposition(const Word& w) const 
    Word reducedFormOf(const Word& w) const 
    VectorOf<Word> normalDecomposition(const Word& w) const 
    Word normalFormOf(const Word& w) const 
    void cyclicDecomposition(const Word& w, VectorOf<Word>& result, 
                             Word& conjugator) const 
    void cyclicReduction(const Word& w, Word& result, Word& conjugator) const 
    int numberOfSubstitutions( const Word& w ) const 
    NumberOfFactor factorOfFormalWord(const Word& w) const 
    NumberOfFactor factorOfElement(const Word& w) const 
    Word localToGlobal(const LocalWord& w) const 
    LocalWord globalToLocal(const Word& w) const 
    Trichotomy isHyperbolic() const 
    void maximalRoot(const Word& w, Word& root, int& power) const 
    bool isProperPower(const Word& w) const 
    bool isProperPowerOfSecond(const Word& u, const Word& w, 
                               int& power) const 
    bool commute(const Word& u, const Word& w) const 
    bool isSubgroupAbelian(const VectorOf<Word>& subgroupWords) const 
    bool isSubgroupTrivial(const VectorOf<Word>& vec) const 
    bool isSubgroupCyclic(const VectorOf<Word>& vec) const 
    void printDecomposition(ostream& ostr, const VectorOf<Word> deco) const 
protected:
  AmalgProductOfFreeGroups( AmalgProductOfFreeGroupsRep* newrep ) :
  DerivedObjectOf<FPGroup,AmalgProductOfFreeGroupsRep>(newrep) 
private:
};

@
\subsection{AProducts/include/APofFreeGroupsRep.h}
<<APofFreeGroupsRep.h>>=
#include "FPGroupRep.h"
#include "FreeGroup.h"
#include "VectorPtr.h"
#include "SGofFreeGroup.h"
#include "AP-fixups.h"
#include "Automorphism.h"

enum NumberOfFactor { LEFT_FACTOR = 0, RIGHT_FACTOR = 1, 
                      PRODUCT, INTERSECTION };

<<struct LocalWord>>
<<struct AmalgProductOfFreeGroupsRep>>

@
\subsubsection{struct LocalWord}
<<struct LocalWord>>=
struct LocalWord
{
  LocalWord() : theWord(), theFactor(INTERSECTION) 
  LocalWord(const Word& w, const NumberOfFactor& fac) : 
     theWord(w), theFactor(fac) 
  operator Word() const 
  friend LocalWord operator * (const LocalWord& w1, const LocalWord& w2);
  LocalWord& operator *= (const LocalWord& w) 
  LocalWord inverse() const 
  LocalWord freelyReduce() const 
  Word theWord;
  NumberOfFactor theFactor;
};

@
\subsubsection{struct AmalgProductOfFreeGroupsRep}
<<struct AmalgProductOfFreeGroupsRep>>=
struct AmalgProductOfFreeGroupsRep : FPGroupRep 
{
  AmalgProductOfFreeGroupsRep(const FreeGroup& g1, const FreeGroup& g2,
                              const VectorOf<Word>& gen1, 
                              const VectorOf<Word>& gen2 );
  AmalgProductOfFreeGroupsRep(const SGofFreeGroup& sg1,
                              const SGofFreeGroup& sg2);
  PureRep* clone( ) const 
  static const Type theAmalgProductOfFreeGroupsType;
  static Type type( ) 
  Type actualType( ) const 
  int order( ) const;
  Trichotomy isTrivial( ) const;
  Trichotomy isFinite( ) const;
  Trichotomy isInfinite( ) const;
  Trichotomy isAbelian( ) const;
  Trichotomy isFree( ) const;
  Trichotomy isHyperbolic() const;
  void printOn(ostream&) const;
  GroupRep* readFrom(istream&, Chars&) const;
  void printRelators(ostream&) const;
  void printDecomposition(ostream& ostr, const VectorOf<Word>& deco) const;
  Elt eval( const Word& w ) const 
  Trichotomy wordProblem( const Word& w ) const 
  NumberOfFactor factorOfFormalWord(const Word& w) const;
  NumberOfFactor factorOfElement(const Word& w) const;
  VectorOf<Word> decompose(const Word& w) const;
  VectorOf<Word> reducedDecomposition(const Word& w) const;
  Word reducedFormOf(const Word& w) const 
  VectorOf<Word> normalDecomposition(const Word& w) const;
  Word normalFormOf(const Word& w) const 
  int lengthOf(const Word& w) const 
  int numberOfSubstitutions( const Word& w ) const;
  Word localToGlobal(const LocalWord& w) const 
  Word localToGlobal(const Word& theWord, NumberOfFactor theFactor) const;
  LocalWord globalToLocal(const Word& w) const;
  NumberOfFactor factorOfGenerator(const Generator& gen) const 
  LocalWord mapFromSubgroup(const LocalWord& w) const;
  Word mapFromSubgroup(const Word& w) const 
  bool isElementOfSubgroup(const LocalWord& w) const;
  LocalWord rightSchreierRepresentativeOf(const LocalWord& w) const;
  void makeSubgroupMapping(const VectorOf<Word>& gen1,
                           const VectorOf<Word>& gen2);
  void fixGeneratorsNames();
  virtual void maximalRoot(const Word& w, Word& root, int& power) const;
  bool isProperPower(const Word& w) const;
  bool isProperPowerOfSecond(const Word& u, const Word& w, int& power) const;
  bool commute(const Word& u, const Word& w) const;
  bool isSubgroupTrivial(const VectorOf<Word>& subgrp) const;
  bool isSubgroupCyclic(const VectorOf<Word>& subgrp) const;
  bool isSubgroupAbelian(const VectorOf<Word>& subgrp) const;
  void cyclicReduction(const Word& w, Word& result, Word& conjugator) const;
  void cyclicDecomposition(const Word& w, VectorOf<Word>& result, 
                           Word& conjugator) const;
  VectorPtrOf<FreeGroup> factor;            
  VectorPtrOf<SGofFreeGroup> assocSubgroup; 
  VectorPtrOf<Map> subgroupMapping;         
  VectorPtrOf<Automorphism> nielsenBasisToGensOfSubgroup; 
  int rankOfSubgroups;
  int numerationShift; 
};

@
\subsection{AProducts/include/APwithOneRelator.h}
<<APwithOneRelator.h>>=
#include "APofFreeGroups.h"
#include "APwithOneRelatorRep.h"

<<class APwithOneRelator>>

@
\subsubsection{class APwithOneRelator}
<<class APwithOneRelator>>=
class APwithOneRelator : 
    public DerivedObjectOf<AmalgProductOfFreeGroups,APwithOneRelatorRep> 
{
public:
  APwithOneRelator() :
    DerivedObjectOf<AmalgProductOfFreeGroups, 
               APwithOneRelatorRep>(new APwithOneRelatorRep( 0 )) 
  APwithOneRelator(const FreeGroup& g1, const FreeGroup& g2,
                   const Word& a, const Word& b ) :
    DerivedObjectOf<AmalgProductOfFreeGroups, 
               APwithOneRelatorRep>(new APwithOneRelatorRep(g1, g2, a, b))
  APwithOneRelator(const FreeGroup& g1, const FreeGroup& g2,
                    const VectorOf<Word>& gen1, const VectorOf<Word>& gen2) :
    DerivedObjectOf<AmalgProductOfFreeGroups, APwithOneRelatorRep>
               ( new APwithOneRelatorRep(g1, g2, gen1, gen2) ) 
  APwithOneRelator(const SGofFreeGroup& sg1, const SGofFreeGroup& sg2) :
    DerivedObjectOf<AmalgProductOfFreeGroups, APwithOneRelatorRep>
               ( new APwithOneRelatorRep(sg1, sg2) ) 
  APwithOneRelator( const Group& G ) :
    DerivedObjectOf<AmalgProductOfFreeGroups,APwithOneRelatorRep>(G) 
  static Type type( ) 
  Trichotomy conjugacyProblem(const Word& u, const Word& w, 
                              Word& conjugator) const 
  VectorOf<Word> centralizerOf(const Word& w) const 
protected:
  APwithOneRelator( APwithOneRelatorRep* newrep ) :
    DerivedObjectOf<AmalgProductOfFreeGroups,APwithOneRelatorRep>(newrep) 
private:
};

@
\subsection{AProducts/include/APwithOneRelatorRep.h}
<<APwithOneRelatorRep.h>>=
#include "APofFreeGroups.h"

<<struct APwithOneRelatorRep>>

@
\subsubsection{struct APwithOneRelatorRep}
<<struct APwithOneRelatorRep>>=
struct APwithOneRelatorRep : AmalgProductOfFreeGroupsRep 
{
  APwithOneRelatorRep(const int dummy) :
    AmalgProductOfFreeGroupsRep( FreeGroup(), FreeGroup(), 
                                 VectorOf<Word>(), VectorOf<Word>() ) 
    APwithOneRelatorRep(const FreeGroup& g1, const FreeGroup& g2,
                        const Word& gen1, const Word& gen2 );
    APwithOneRelatorRep(const FreeGroup& g1, const FreeGroup& g2,
                        const VectorOf<Word>& gen1, 
                        const VectorOf<Word>& gen2) :
      AmalgProductOfFreeGroupsRep( g1, g2, gen1, gen2 ) 
    APwithOneRelatorRep(const SGofFreeGroup& sg1, const SGofFreeGroup& sg2) :
      AmalgProductOfFreeGroupsRep( sg1, sg2 ) 
    Word assocWord(int i) const 
    PureRep* clone( ) const 
    static const Type theAPwithOneRelatorType;
    static Type type( ) 
    Type actualType( ) const 
    Trichotomy isHyperbolic() const;
    GroupRep* readFrom(istream&, Chars&) const;
    VectorOf<int> computeInvariants() const;
    void maximalRoot(const Word& w, Word& root, int& power) const;
    VectorOf<Word> centralizerOf(const Word& w) const;
    Trichotomy conjugacyProblem( const Word& u, const Word& v ) const 
    Trichotomy conjugacyProblem(const Word& u, const Word& v, 
                                Word& conjugator) const;
private:
  void maximalRoot_case1(const Word& w, Word& root, int& power) const;
  void maximalRoot_case2(const Word& w, Word& root, int& power) const;
  Word translateToAnotherPresentation(const Word& w, const Word& aConjInv, 
                                      const Word& bConjInv) const;
  Trichotomy conjugacyProblem_reduced(const Word& u, const Word& v, 
                                      Word& conjugator) const;
  Trichotomy conjugacyProblem_case1(const Word& u, const Word& v, 
                                    Word& conjugator) const;
  Trichotomy conjugacyProblem_case2(VectorOf<Word>& uDec, VectorOf<Word>& vDec,
                                    Word& conjugator) const;
};

@
\subsection{AProducts/include/HNNExtension.h}
<<HNNExtension.h>>=
#include "FPGroup.h"

<<class HNNExtensionRep>>
<<class HNNExtension>>

@
\subsubsection{class HNNExtensionRep}
<<class HNNExtensionRep>>=
class HNNExtensionRep : public FGGroupRep
{
public:
  HNNExtensionRep( const FPGroup& G );
  static const Type theHNNExtensionType;
  static Type type( ) 
  Type actualType( ) const 
  enum NumberOfSubgroup { A, B };
  enum Pinch { UP, DOWN };
  const FPGroup& getFPGroup() const 
  virtual const FGGroup& getBasisGroup( ) const = 0;
  Generator stableLetter( ) const 
  Trichotomy isTrivial( ) const; 
  Trichotomy isFinite( ) const; 
  Trichotomy isInfinite( ) const;
  Trichotomy isAbelian( ) const; 
  virtual Trichotomy isFree( ) const = 0; 
  bool isSubgroupTrivial( const VectorOf<Word>& vec ) const;
  bool isSubgroupAbelian( const VectorOf<Word>& vec ) const;
  Trichotomy areEqual( const Elt& e1, const Elt& e2 ) const 
  Elt eval( const Word& w ) const 
  int lengthOf( const Word& w ) const 
  Word reducedFormOf( const Word& w ) const 
  Word normalFormOf( const Word& w ) const 
  Word cyclicallyReducedFormOf( const Word& w, Word conjugator ) const 
  VectorOf<Word> decompositionOf( const Word& w ) const;
  VectorOf<Word> reducedDecompositionOf( const Word& w ) const;
  VectorOf<Word> normalDecompositionOf( const Word& w ) const;
  VectorOf<Word> cyclicallyReducedDecompositionOf( const Word& w, 
                                                   Word& conjugator ) const;
  static Word compose( const VectorOf<Word>& V );
  Trichotomy wordProblem( const Word& w ) const; 
  virtual Trichotomy  maximalRoot( const Word& w, Word& maxRoot, 
                                   int& maxPower ) const = 0;
  void printOn( ostream& ) const;
  void printDecomposition( ostream& ostr, const VectorOf<Word>& deco) const 
  void write( ostream& ostr ) const;
  void read( istream& istr );
protected:
  FPGroup theFPGroup; 
  virtual Word mappingFromSubgroup( NumberOfSubgroup S, 
                                    const Word& w ) const = 0;
  virtual Word getGeneratorOfSubgroup( const NumberOfSubgroup subgrp, 
                                       int gen ) const = 0;
  virtual int getNumberOfGeneratorsInSubgroup( const NumberOfSubgroup subgrp )
                                        const = 0;
  virtual bool subgroupContains( const NumberOfSubgroup subgrp, const Word& w)
                                         const  = 0;
  virtual Word rightRepresentative( const NumberOfSubgroup subgrp,  
                                    const Word& w ) const = 0;
private:
  int powerOfStableGen( int component, const VectorOf<Word>& deco ) const;
  bool suspectPinch(int component, const VectorOf<Word>& decomposition) const;
  Pinch formPinch( int component, const VectorOf<Word>& deco ) const;
};

@
\subsubsection{class HNNExtension}
<<class HNNExtension>>=
class HNNExtension : public DerivedObjectOf<FGGroup,HNNExtensionRep>
{
public:
  typedef HNNExtensionRep::NumberOfSubgroup NumberOfSubgroup;
  const FPGroup& getFPGroup() const 
  const FGGroup& getBasisGroup( ) const 
  Generator stableLetter( ) const 
  Trichotomy isFree( ) const 
  bool isSubgroupTrivial( const VectorOf<Word>& vec ) const 
  bool isSubgroupAbelian( const VectorOf<Word>& vec ) const 
  int lengthOf( const Word& w ) const 
  Word reducedFormOf( const Word& w ) const 
  Word normalFormOf( const Word& w ) const 
  Word cyclicallyReducedFormOf( const Word& w, Word conjugator ) const
  VectorOf<Word> decompositionOf( const Word& w ) const 
  VectorOf<Word> reducedDecompositionOf( const Word& w ) const 
  VectorOf<Word> normalDecompositionOf( const Word& w ) const 
  VectorOf<Word> cyclicallyReducedDecompositionOf( const Word& w, 
                                                   Word& conjugator) const 
  static Word compose( const VectorOf<Word>& V ) ;
  virtual Trichotomy  maximalRoot( const Word& w, Word& maxRoot, 
                                   int& maxPower ) const 
  void printDecomposition( ostream& ostr, const VectorOf<Word> deco ) const 
  friend ostream& operator < ( ostream& ostr, const HNNExtension& G )
  friend istream& operator > ( istream& istr, HNNExtension& G )
protected:
  HNNExtension( HNNExtensionRep *newrep ) :
    DerivedObjectOf<FGGroup,HNNExtensionRep> ( newrep ) 
private:
  HNNExtension( ); 
};

@
\subsection{AProducts/include/HNNExtOfFreeGroup.h}
<<HNNExtOfFreeGroup.h>>=
#include "HNNExtension.h"
#include "FreeGroup.h"
#include "SGofFreeGroup.h"
#include "VectorPtr.h"
#include "Automorphism.h"
#include "AP-fixups.h"

<<class HNNExtOfFreeGroupRep>>
<<class HNNExtOfFreeGroup>>

@
\subsubsection{class HNNExtOfFreeGroupRep}
<<class HNNExtOfFreeGroupRep>>=
class HNNExtOfFreeGroupRep: public HNNExtensionRep 
{
public:
  HNNExtOfFreeGroupRep( const FreeGroup& F, const Chars& nameOfStableLetter,
                        const SGofFreeGroup& subgroupA,
                        const SGofFreeGroup& subgroupB );
  PureRep* clone( ) const 
  static const Type theHNNExtOfFreeGroupType;
  static Type type( ) 
  Type actualType( ) const 
  const FGGroup& getBasisGroup( ) const 
  virtual int order( ) const 
  Trichotomy isFree( ) const;
  Trichotomy isProperPower( const Word& w ) const;
  Trichotomy maximalRoot( const Word& w, Word& maxRoot, int& maxPower ) const;
  Trichotomy conjugacyProblem( const Word& w, const Word& u ) const 
  Trichotomy conjugacyProblem( const Word& w, const Word& u, 
                               Word& conjugator ) const;
  bool isProperPowerOfSecond( const Word& w, const Word& u, int& k ) const;
  GroupRep* readFrom( istream& istr, Chars& errMesg ) const;
  void write( ostream& ostr ) const;
  void read( istream& istr );
protected:
  void makeSubgroupsMappings();
  void makeReducedCyclicPresentation( ) const;
  Word mappingFromSubgroup( const NumberOfSubgroup S, const Word& w ) const;
  Trichotomy conjugacyProblem_reduced( const Word& u, const Word& v, 
                                       Word& conjugator ) const;
  Trichotomy conjugateInSubgroups( NumberOfSubgroup S, const Word& u, 
                                   const Word& v, Word& conjugator, 
                                   bool oneIteration ) const;
  Trichotomy conjugacyProblem_case1( const Word& u, const Word& v, 
                                     Word& conjugator ) const;
  Trichotomy conjugacyProblem_case2(VectorOf<Word>& uDec, 
                                    VectorOf<Word>& vDec, 
                                    Word& conjugator ) const;
  Word getGeneratorOfSubgroup(const NumberOfSubgroup S, const int gen) const 
  int getNumberOfGeneratorsInSubgroup( const NumberOfSubgroup S ) const 
  bool subgroupContains( const NumberOfSubgroup S, const Word& w ) const 
  Word rightRepresentative( const NumberOfSubgroup S, const Word& w ) const 

<<struct SpecialHNNExtOfFreeGroup>>
<<class MaximalRootProblem>>

  friend class MaximalRootProblem;
  FreeGroup theBasisFreeGroup;
  VectorPtrOf<SGofFreeGroup> theSubgroups; 
  VectorOf< VectorOf<Word> > mapNielsenGensToSubgroupGens;
  SpecialHNNExtOfFreeGroup reducedPresentation;
};

<<class HNNExtOfFreeGroup>>

@
\subsubsection{struct SpecialHNNExtOfFreeGroup}
<<struct SpecialHNNExtOfFreeGroup>>=
struct SpecialHNNExtOfFreeGroup 
{
public:
  SpecialHNNExtOfFreeGroup() : 
    H(0), toOriginalPresentation( FreeGroup(0), VectorOf<Word>(0) ) 
  SpecialHNNExtOfFreeGroup( const Automorphism& mapToOriginalPresentation,
                            const FreeGroup& basisFreeGroup,
                            const Chars& nameOfStableLetter,
                            const SGofFreeGroup& A,
                            const SGofFreeGroup& B,
                            bool  areAmalgSubgroupsConjugateSeparated,
                            const VectorOf<Word>& rootsOfSubgroupsGens,
                            const VectorOf<int>&  powersOfSubgroupsGens );
  SpecialHNNExtOfFreeGroup( const SpecialHNNExtOfFreeGroup& S );
  ~SpecialHNNExtOfFreeGroup() 
  SpecialHNNExtOfFreeGroup& operator = ( const SpecialHNNExtOfFreeGroup& S );
  bool doneInit( ) const 
  const HNNExtOfFreeGroupRep& presentation() const;
  Automorphism         toOriginalPresentation;
  bool                 areAmalgSubgroupsConjugateSeparated;
  VectorOf<Word>       theRootsOfSubgroupsGens;
  VectorOf<int>        thePowersOfSubgroupsGens;   
private:
  HNNExtOfFreeGroupRep *H;
};

@
\subsubsection{class MaximalRootProblem}
<<class MaximalRootProblem>>=    
class MaximalRootProblem 
{
public:
  MaximalRootProblem( const Word& w );
  Trichotomy answer() const 
  Word root() const 
  int power() const 
  void solve( const SpecialHNNExtOfFreeGroup& group );
private:
    void length0( const Word& w );
    void lengthN( const VectorOf<Word> wDeco );
    void setAnswer( const Word& root, int power );
    SpecialHNNExtOfFreeGroup theGroup;
    Word theWord;
    Word theRoot;
    int  thePower;
    Trichotomy theAnswer;
    bool isSolved;
    Word stableLetter;
};
  
@
\subsubsection{class HNNExtOfFreeGroup}
<<class HNNExtOfFreeGroup>>=
class HNNExtOfFreeGroup  
  : public DerivedObjectOf< HNNExtension, HNNExtOfFreeGroupRep>
{
public:
  HNNExtOfFreeGroup( const FreeGroup& F, 
                     const Chars& nameOfStableLetter,
                     const SGofFreeGroup& subgroupA,
                     const SGofFreeGroup& subgroupB ) :
    DerivedObjectOf< HNNExtension, 
                     HNNExtOfFreeGroupRep>(
                       new HNNExtOfFreeGroupRep(F, nameOfStableLetter, 
                                                subgroupA, subgroupB )) 
  Trichotomy isProperPower( const Word& w ) const 
  Trichotomy conjugacyProblem( const Word& w, const Word& u, 
                               Word& conjugator ) const 
  bool isProperPowerOfSecond( const Word& w, const Word& u, int& k ) const 
  friend ostream& operator < ( ostream& ostr, const HNNExtOfFreeGroup& G )
  friend istream& operator > ( istream& istr, HNNExtOfFreeGroup& G )
protected:
  HNNExtOfFreeGroup( HNNExtOfFreeGroupRep *newrep ) :
    DerivedObjectOf<HNNExtension, HNNExtOfFreeGroupRep> ( newrep ) 
};

@
\subsection{AProducts/include/HNNExtOfORGroup.h}
<<HNNExtOfORGroup.h>>=
#include "Set.h"
#include "Vector.h"
#include "VectorPtr.h"
#include "OneRelatorGroup.h"
#include "SubgroupOfOneRelatorGroup.h"
#include "OneRelatorGroupWithTorsion.h"

<<class HNNExtOfORGroupGeneric>>
<<class HNNExtOfORGroup>>
<<class HNNExtOfORGroupWithTorsion>>
<<class HNNDoubleCoset>>

@
\subsubsection{class HNNExtOfORGroupGeneric}
<<class HNNExtOfORGroupGeneric>>=
class HNNExtOfORGroupGeneric
{
public:
  enum NumberOfSubgroup { A = 0, B = 1 };
  enum Pinch { UP, DOWN };
  HNNExtOfORGroupGeneric( const OneRelatorGroup& G, const Chars& stableGenName,
                          const ORGSubgroup& A, const ORGSubgroup& B);
  HNNExtOfORGroupGeneric( const HNNExtOfORGroupGeneric& H );
  virtual ~HNNExtOfORGroupGeneric( );
  HNNExtOfORGroupGeneric& operator=( const HNNExtOfORGroupGeneric& H );
  virtual const ORGSubgroup& subgroup(NumberOfSubgroup i) const 
  const OneRelatorGroup& basisGroup( ) const 
  FPGroup getPresentation( ) const;
  Chars nameOfStableGenerator( ) const 
  virtual Trichotomy wordProblem( const Word& w ) const = 0;
  int lengthOf( const Word& w ) const;
  int lengthOf( const VectorOf<Word>& deco ) const;
  VectorOf<Word> decompositionOf( const Word& w ) const;
  VectorOf<Word> reducedDecompositionOf( const Word& w ) const;
  VectorOf<Word> normalDecompositionOf( const Word& w ) const;
  VectorOf<Word> cyclicallyReducedDecompositionOf( const Word& w, 
                                                   Word& conj ) const;
  Word mappingFromSubgroup( NumberOfSubgroup subgrp, const Word& w ) const;
  ProductOfRelatorConjugates mappingDecompositionOf( 
    const NumberOfSubgroup& S, const Word& w, const Word& wInSBasis, 
    const Word& tail ) const;
  Generator stableLetter( ) const 
  virtual bool operator == ( const HNNExtOfORGroupGeneric& G ) const;
  friend inline ostream& operator << ( ostream& ostr, 
                                       const HNNExtOfORGroupGeneric& H ) 
protected:
<<struct PinchStruct>>
  void printOn( ostream& ostr ) const;
  void printDecomposition( ostream& ostr, const VectorOf<Word>& deco ) const;
  virtual void debugPrint( ostream& ostr ) const;
  virtual void write( ostream& ostr ) const;
  virtual void read( istream& istr );
  int powerOfStableGen(int component, const VectorOf<Word>& deco ) const;
  bool suspectPinch(int component, const VectorOf<Word>& deco ) const;
  bool abelianizationTest( const PinchStruct& pinch, 
                           const VectorOf<int>& powersOfGens,
                           const VectorOf<bool>& subgroupGens ) const;
  PinchStruct formPinch(int component, const VectorOf<Word>& deco) const;
  int unusedGenerators( const Word& test, VectorOf<Word>& toNewGens,
                        VectorOf<Word>& toOldGens ) const;
  void init( const HNNExtOfORGroupGeneric& H );
  OneRelatorGroup *theBasisGroup;
  Chars theNameOfStableGenerator;
  ORGSubgroup *subgroups[2];
};

@
\subsubsection{struct PinchStruct}
<<struct PinchStruct>>=
struct PinchStruct 
{
    Pinch type;
    int number;
    Word word;
};

@
\subsubsection{class HNNExtOfORGroup}
<<class HNNExtOfORGroup>>=
class HNNExtOfORGroup : public HNNExtOfORGroupGeneric
{
public:
  HNNExtOfORGroup( const OneRelatorGroup& G,
                   const Chars& stableGenName,
                   const SubgroupOfOneRelatorGroup& A,
                   const SubgroupOfOneRelatorGroup& B);
  Trichotomy wordProblem( const Word& test ) const;
  Trichotomy wordProblem( const Word& test, bool keepDetails,
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
  VectorOf<Word> reducedDecompositionOf( const Word& w, bool keepDetails,
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
private:
protected:
  int unusedGenerators( const Word& test, VectorOf<Word>& toNewGens,
                        VectorOf<Word>& toOldGens ) const;
};

@
\subsubsection{class HNNExtOfORGroupWithTorsion}
<<class HNNExtOfORGroupWithTorsion>>=
class HNNExtOfORGroupWithTorsion : public HNNExtOfORGroupGeneric
{
public:
  HNNExtOfORGroupWithTorsion( const OneRelatorGroupWithTorsion& G,
                              const Chars& stableGenName,
                              const SubgroupOfORGroupWithTorsion& A,
                              const SubgroupOfORGroupWithTorsion& B );
  Trichotomy wordProblem( const Word& test ) const;
  Trichotomy conjugacyProblem( const Word& u, const Word& v, 
                               Word& conjugator ) const;
  Trichotomy maximalRoot( const Word& w, Word& root, int& power ) const;
private:
protected:
  Trichotomy conjugacyProblem_cyclicallyReduced( const VectorOf<Word>& uDeco, 
    const VectorOf<Word>& vDeco, Word& conjugator ) const;

<<class MaximalRootProblem>>

};

@
\subsubsection{class MaximalRootProblem}
<<class MaximalRootProblem>>=
class MaximalRootProblem
{
public:
    MaximalRootProblem( const Word& w );
    void solve( const HNNExtOfORGroupWithTorsion& group );
    Word root( ) const 
    int power( ) const 
    Trichotomy answer( ) const 
  private:
    bool lexCheckOfStableLetters( const VectorOf<Word>& wDeco, 
                                  const int rootLen ) const;
    void lengthN( const HNNExtOfORGroupWithTorsion& H, 
                  const VectorOf<Word>& wDeco );
    void setAnswer( const Word& maxRoot, const int maxPower );
    void adjustRoot( );
    const Word theWord;
    Trichotomy theAnswer;
    Word theRoot;
    int thePower;
    bool isSolved;
};

@
\subsubsection{class HNNDoubleCoset}
<<class HNNDoubleCoset>>=
class HNNDoubleCoset
{
public:
  HNNDoubleCoset( const SubgroupOfORGroupWithTorsion& Sa,
                  const SubgroupOfORGroupWithTorsion& Sbw );
  Trichotomy solve( const Word& f, Word& a, const Word& g, Word& b ) const;
private:
  Trichotomy oneRelatorWithTorsionSolution( 
    const Word& f, Word& a, const Word& g, Word& b ) const;
  Word minimalSpecialForm( const Word& w, 
                           const SubgroupOfORGroupWithTorsion S ) const;
  SubgroupOfORGroupWithTorsion A;
  SubgroupOfORGroupWithTorsion B;
};

@
\subsection{AProducts/include/HNNParser.h}
<<HNNParser.h>>=
#include "PresentationParser.h"
#include "HNNExtOfFreeGroup.h"

<<class HNNExtensionParser>>

@
\subsubsection{class HNNExtensionParser}
<<class HNNExtensionParser>>=
class HNNExtensionParser : public PresentationParser 
{
public:  
  HNNExtensionParser( istream& istr ) : PresentationParser(istr) 
  HNNExtOfFreeGroupRep* parseHNNExtensionOfFreeGroup( Chars& );
protected:
  void parseHNNRelator( const VectorOf<Chars>& names, Word& left, Word& right, 
                        Chars& errMesg);
  VectorOf<Word> parseHNNRelatorsList( const VectorOf<Chars>& names,
                                       Chars& errMesg, int maxRelators );
  void parseBasisFreeGroupAndRelations( FreeGroup& F, Chars& stableGenName, 
                                        VectorOf<Word>& A, VectorOf<Word>& B, 
                                        int maxRelators, Chars& errMesg );

};

@
\subsection{AProducts/include/MagnusBreakdown.h}
<<MagnusBreakdown.h>>=
#include "OneRelatorGroup.h"
#include "HNNExtOfORGroup.h"
#include "AbelianWord.h"
#include "Map.h"
#include "SuperGen.h"
#include "Range.h"
#include "Automorphism.h"

<<class MagnusBreakdown>>

@
\subsubsection{class MagnusBreakdown}
<<class MagnusBreakdown>>=
class MagnusBreakdown
{
public:
  MagnusBreakdown( const OneRelatorGroup& G );
  OneRelatorGroup getORGroup() const 
  HNNExtOfORGroup getHNNPresentation() const;
  int numberOfUsedGenerators() const 
  Generator stableGenerator() const 
  bool hasAccompGenerator() const 
  Generator accompGenerator() const;
  ListOf<Generator> getGeneratorsWithZeroExpSum() const 
  ListOf<Generator> getGeneratorsWithNonzeroExpSum() const 
  ListOf<Generator> getDefaultBreakdownGenerators() const;
  int getExponentSumOf( const Generator& g ) const 
  Word rewriteWordInOldGenerators( const Word& w ) const; 
  Word rewriteWordInNewGenerators( const Word& w ) const;
  Automorphism embeddingOfORGroups( ) const 
  Map toHNNPresentation( ) const 
  Map toORGroup( ) const 
  int numberOfOldGenerators( ) const 
  int numberOfNewGenerators( ) const 
  VectorOf<Range> getSubscriptsTable() const 
  Generator adjoinSubscript(const Generator& oldGen, int subscript) const;
  Generator extractSubscript(const Generator& newGen, int& subscript) const;
  Trichotomy hasHNNPresentation() const 
  bool findHNNPresentation();
  bool findHNNPresentation( const Generator& stableGen );
  bool findHNNPresentation( const Generator& stableGen, 
                            const Generator& accompGen );
  void printOn( ostream& ostr ) const;
  MagnusBreakdown *readFrom( istream& istr ) const;
  void debugPrint( ostream& ostr ) const;
protected:
  void makeHNNPresentation( );
  bool chooseStableGenerator( );
  void makeSubscriptsTable( );
  void makeEmbedding();
  void makeTranslationTables();
  OneRelatorGroup       theORGroup;
  int                   theNumberOfOldGenerators;
  ListOf<Generator>     theGeneratorsWithZeroExpSum;
  ListOf<Generator>     theGeneratorsWithNonzeroExpSum;
  VectorOf<int>         exponentsOfOldGenerators;
  OneRelatorGroup       theLargerORGroup;
  HNNExtOfORGroup       theHNNPresentation;
  bool                  haveHNNPresentation;
  Automorphism          theEmbeddingOfORGroups;
  Map                   mapToHNN;
  Map                   mapToORGroup;
  SuperGen              stable, accomp;
  Generator             stableNewGen;
  int                   theNumberOfNewGenerators;
  VectorOf<Chars>       theNamesOfNewGenerators;
  VectorOf<Range>       subscriptsOfGenerator;
  VectorOf<int>         toNewGens;
  VectorOf<int>         toOldGens;

};

ProductOfRelatorConjugates liftUpProduct( 
  const ProductOfRelatorConjugates& mProduct, 
  const MagnusBreakdown& M, const OneRelatorGroup& G 
);

@
\subsection{AProducts/include/OneRelatorGroup.h}
<<OneRelatorGroup.h>>=
#include "Word.h"
#include "Chars.h"
#include "Vector.h"
#include "FPGroup.h"
#include "AP-fixups.h"

<<class OneRelatorGroupRep>>
<<class OneRelatorGroup>>
<<class EnumeratorOfConsequences>>

@
\subsubsection{class OneRelatorGroupRep}
<<class OneRelatorGroupRep>>=
class OneRelatorGroupRep : public FGGroupRep
{
public:
  OneRelatorGroupRep( int ngens, const Word& relator );
  OneRelatorGroupRep( const VectorOf<Chars>& gennames, const Word& relator ); 
  OneRelatorGroupRep( const FPGroup& G );
  PureRep* clone( ) const 
  static const Type theOneRelatorGroupType;
  static Type type( ) 
  Type actualType( ) const 
  int order( ) const;
  Trichotomy isTrivial( ) const; 
  Trichotomy isFinite( ) const; 
  Trichotomy isInfinite( ) const;
  Trichotomy isAbelian( ) const; 
  Trichotomy isFree( ) const;
  Trichotomy wordProblem( const Word& w, bool keepDetails,
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
  Trichotomy wordProblem( const Word& w ) const;
  Trichotomy areEqual( const Elt& e1, const Elt& e2 ) const 
  Elt eval( const Word& w ) const 
  Trichotomy conjugacyProblem( const Word& u, const Word& w ) const 
  GroupRep* readFrom( istream& istr, Chars& errMesg ) const;
  void printOn( ostream& ostr ) const;
  bool operator == ( const OneRelatorGroupRep& G ) const 
  bool operator != ( const OneRelatorGroupRep& G ) const 
  void write( ostream& ostr ) const;
  void read( istream& istr );
  Word theRelator;  
};

@
\subsubsection{class OneRelatorGroup}
<<class OneRelatorGroup>>=
class OneRelatorGroup 
  : public DerivedObjectOf< FGGroup, OneRelatorGroupRep >
{
public:
  OneRelatorGroup( int ngens, const Word& relator ) :
    DerivedObjectOf<FGGroup, OneRelatorGroupRep>( 
        new OneRelatorGroupRep( ngens, relator ) ) 
  OneRelatorGroup( const VectorOf<Chars>& gennames, const Word& relator ) :
    DerivedObjectOf<FGGroup, OneRelatorGroupRep>( 
        new OneRelatorGroupRep( gennames, relator ) ) 
  OneRelatorGroup( const FPGroup& G ) :
    DerivedObjectOf<FGGroup, OneRelatorGroupRep>( 
        new OneRelatorGroupRep( G ) ) 
  Word relator( ) const 
  Trichotomy wordProblem( const Word& w ) const
  Trichotomy wordProblem( const Word& w, bool keepDetails, 
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const
  friend ostream& operator < ( ostream& ostr, const OneRelatorGroup& G )
  friend istream& operator > ( istream& istr, OneRelatorGroup& G )
protected:
  OneRelatorGroup( OneRelatorGroupRep *newrep ) :
    DerivedObjectOf<FGGroup, OneRelatorGroupRep> ( newrep ) 
};

@
\subsubsection{class EnumeratorOfConsequences}
<<class EnumeratorOfConsequences>>=
class EnumeratorOfConsequences 
{
public:
  EnumeratorOfConsequences( const OneRelatorGroup& G );
  Word word() const;
  ProductOfRelatorConjugates tuple() const;
  void reset();
  bool done() const;
  void advance();
  friend ostream& operator < ( ostream& ostr, 
                               const EnumeratorOfConsequences& ce )
  friend istream& operator > ( istream& istr, EnumeratorOfConsequences& ce )
private:
  void generate( ) const;
  Integer theCurrentWordNumber;
  Integer theLastComputedWordNumber;
  Word theCurrentWord;
  ProductOfRelatorConjugates theCurrentProduct;
  Word theRelator;
  FreeGroup theGroup;
};

@
\subsection{AProducts/include/OneRelatorGroupWithTorsion.h}
<<OneRelatorGroupWithTorsion.h>>=
#include "OneRelatorGroup.h"

<<class OneRelatorGroupWithTorsionRep>>
<<class OneRelatorGroupWithTorsion>>

@
\subsubsection{class OneRelatorGroupWithTorsionRep}
<<class OneRelatorGroupWithTorsionRep>>=
class OneRelatorGroupWithTorsionRep : public OneRelatorGroupRep
{
public:
  OneRelatorGroupWithTorsionRep( int ngens, const Word& relator );
  OneRelatorGroupWithTorsionRep( const VectorOf<Chars>& gennames, 
                                  const Word& relator ); 
  OneRelatorGroupWithTorsionRep( const FPGroup& G );
  PureRep* clone( ) const 
  static const Type theOneRelatorGroupWithTorsionType;
  static Type type( ) 
  Type actualType( ) const 
  Trichotomy isFreeProduct( ) const;
  bool isProperMagnusSubgroup( const VectorOf<Generator>& gens ) const;
  bool doesMagnusSubgroupContainElt( const VectorOf<Generator>& subgroup, 
    const Word& w, Word& wInSubgroupBasis ) const;
  bool isPowerOfEltInMagnusSubgroup( const VectorOf<Generator>& subgroup, 
    const Word& w, Word& subgroupElt, int& powerOfElt ) const;
  Trichotomy wordProblem( const Word& w, 
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
  Trichotomy wordProblem( const Word& w ) const;
  Trichotomy conjugacyProblem( const Word& u, const Word& v, Word& conjugator )
    const;
  Trichotomy conjugacyProblem( const Word& u, const Word& w ) const 
  Trichotomy maximalRoot( const Word& w, Word& maxRoot, int& maxPower ) const;
  int powerOfElt(const Word& w, Word& st, Word& x, 
                 ProductOfRelatorConjugates& productOfRelatorConjugates) const;
  VectorOf<Word> centralizerOfElt( const Word& w ) const;
  GroupRep* readFrom( istream& istr, Chars& errMesg ) const;

};

@
\subsubsection{class OneRelatorGroupWithTorsion}
<<class OneRelatorGroupWithTorsion>>=
class OneRelatorGroupWithTorsion 
  : public DerivedObjectOf<OneRelatorGroup,OneRelatorGroupWithTorsionRep>
{
public:
  OneRelatorGroupWithTorsion( int ngens, const Word& relator ) 
    : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
        new OneRelatorGroupWithTorsionRep( ngens, relator ) ) 
  OneRelatorGroupWithTorsion( const VectorOf<Chars>& gennames, 
                              const Word& relator )
    : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
        new OneRelatorGroupWithTorsionRep( gennames, relator ) ) 
  OneRelatorGroupWithTorsion( const FPGroup& G )
    : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>( 
        new OneRelatorGroupWithTorsionRep( G ) ) 
  bool isProperMagnusSubgroup( const VectorOf<Generator>& subgroup ) const
  bool doesMagnusSubgroupContainElt( const VectorOf<Generator>& subgroup, 
    const Word& w, Word& wInSubgroupBasis ) const
  bool isPowerOfEltInMagnusSubgroup( const VectorOf<Generator>& subgroup, 
    const Word& w, Word& subgroupElt, int& powerOfElt ) const
  Trichotomy wordProblem( const Word& w, 
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const 
  Trichotomy conjugacyProblem( const Word& u, const Word& v, Word& conjugator)
    const
  Trichotomy maximalRoot( const Word& w, Word& maxRoot, int& maxPower ) const 
  int powerOfElt(const Word& w, Word& st, Word& x, 
                 ProductOfRelatorConjugates& productOfRelatorConjugates ) const
  VectorOf<Word> centralizerOfElt( const Word& w ) const 
protected:
  OneRelatorGroupWithTorsion( OneRelatorGroupWithTorsionRep *newrep ) 
    : DerivedObjectOf<OneRelatorGroup, OneRelatorGroupWithTorsionRep>(newrep)

};

@
\subsection{AProducts/include/ORProblems.h}
<<ORProblems.h>>=
#include "FPGroup.h"

<<class ORProblems>>

@
\subsubsection{class ORProblems}
<<class ORProblems>>=
class ORProblems 
{
public:
  ORProblems( int numOfGens, const Word& relator ) 
    : numberOfGenerators( numOfGens ), 
      theRelator( relator ) 
  bool isTrivial( ) const;
  bool isAbelian( ) const;
  bool isFinite( ) const;
  bool isFree( ) const;
  int order( ) const;
private:
  int numberOfGenerators;
  Word theRelator;
};

@
\subsection{AProducts/include/Range.h}
\subsubsection{struct Range}
<<struct Range>>=
struct Range 
{
  int low, high;
  bool Default;
  Range() : low(0), high(0), Default(true) 
  Range( int lo, int hi ) : low(lo), high(hi), Default(false) 
  bool operator == ( Range r ) const 
};
  void operator < ( ostream& ostr, const Range& g );
  void operator > ( istream& istr, Range& g );
  ostream& operator << ( ostream& ostr, const Range& g );
  istream& operator >> ( istream& istr, Range& g );

@
\subsection{AProducts/include/ShortenByRelators2.h}
<<ShortenByRelators2.h>>=
#include "SymmetricRelators.h"
#include "QuickAssociations.h"
#include "AP-fixups.h"

<<class ShortenByRelators2>>

@
\subsubsection{class ShortenByRelators2}
<<class ShortenByRelators2>>=
class ShortenByRelators2 
{
public:
  ShortenByRelators2 ( const SetOf<Word>& relators );
  Word getShortenWord( const Word& w ) const;  
  Word expressWordInConjugatesOfRelators( const Word& w, 
    ProductOfRelatorConjugates& productOfRelatorConjugates ) const;
private:
  virtual int compare( const Word& w1, const Word& w2 ) const;
  QuickAssociationsOf< Word, int > relatorsPieces;
  VectorOf<Word> theRelators;
  VectorOf<int> relatorsLengths;
  int base;
};

@
\subsection{AProducts/include/SubgroupOfOneRelatorGroup.h}
<<SubgroupOfOneRelatorGroup.h>>=
#include "OneRelatorGroup.h"
#include "OneRelatorGroupWithTorsion.h"

<<class ORGSubgroup>>
<<class SubgroupOfOneRelatorGroup>>
<<class SubgroupOfORGroupWithTorsion>>

@
\subsubsection{class ORGSubgroup}
<<class ORGSubgroup>>=
class ORGSubgroup 
{
public:
  ORGSubgroup( const VectorOf<Word>& gens );
  virtual ~ORGSubgroup( ) 
  virtual ORGSubgroup *copy( ) const = 0;
  virtual const OneRelatorGroup& parentGroup( ) const = 0;
  const VectorOf<Word>& generators() const 
  bool isMagnusSubgroup( ) const;
  virtual bool contains( const Word& w ) const = 0;
  virtual Word rewriteFromGroupToSubgroupGenerators(const Word& w) const = 0 ;
  Word rewriteFromSubgroupToGroupGenerators( const Word& w ) const;
  bool lexicallyContains( const Word& w ) const;
  bool lexicallyContains( const Word& w, Word& wInBasis ) const;
  virtual bool operator == ( const ORGSubgroup& S ) const 
  friend ostream& operator << ( ostream& ostr, const ORGSubgroup& S ) 
  friend ostream& operator < ( ostream& ostr, const ORGSubgroup& S ) 
  friend istream& operator > ( istream& istr, ORGSubgroup& S ) 
protected:
  virtual void write( ostream& ostr ) const;
  virtual void read( istream& istr );
private:
  virtual void printOn( ostream& ostr ) const;
  VectorOf<Word> theGenerators;
};

@
\subsubsection{class SubgroupOfOneRelatorGroup}
<<class SubgroupOfOneRelatorGroup>>=
class SubgroupOfOneRelatorGroup : public ORGSubgroup
{
public:
  SubgroupOfOneRelatorGroup( const OneRelatorGroup& G,
                             const VectorOf<Word>& gens );
  ORGSubgroup *copy( ) const 
  const OneRelatorGroup& parentGroup() const 
  bool contains( const Word& w ) const;
  bool contains( const Word& w, bool keepDetails ) const;
  Word rewriteFromGroupToSubgroupGenerators( const Word& w ) const;
  ProductOfRelatorConjugates getIdentityProductDecomposition( const Word& w ) 
    const;
  SubgroupOfOneRelatorGroup join( const SubgroupOfOneRelatorGroup& sg ) const;
  bool operator == ( const SubgroupOfOneRelatorGroup& S ) const 
private:
  void write( ostream& ostr ) const;
  void read( istream& istr ); 
private:
  OneRelatorGroup theParentGroup;

<<struct ContainmentProblemData>>

  ContainmentProblemData containsResult;
  void setContainmentProblemData( const Word& w, bool in_subgroup, 
          const Word& wInBasis, bool keepDetails, 
          const ProductOfRelatorConjugates& product ) const;
  bool subgroupsDecomposition(const Word& w, 
          const SubgroupOfOneRelatorGroup& T,
          const SubgroupOfOneRelatorGroup& A,
          Word& t_part, Word& a_part,
          const bool keepDetails, 
          ProductOfRelatorConjugates& prodDeco ) const;
  bool pureContainmentProblem( const Word& u, bool keepDetails = false ) const;
  class MagnusBreakdown buildMagnusBreakdown( const Word& w, 
    SetOf<Generator>& subGens ) const;
};

@
\subsubsection{struct ContainmentProblemData}
<<struct ContainmentProblemData>>=
struct ContainmentProblemData 
{
  Word wordInParentGroupGenerators;
  bool inSubgroup;
  Word wordInSubgroupGenerators;
  ProductOfRelatorConjugates idProductDeco;
  bool keepDetails;
  ContainmentProblemData() 
    : wordInParentGroupGenerators( ), inSubgroup( true ),
      wordInSubgroupGenerators( ), idProductDeco( ),
      keepDetails( false ) 
  ContainmentProblemData( const Word& w, bool f, const Word& u, 
      bool keep_details, const ProductOfRelatorConjugates& prodDeco ) 
      : wordInParentGroupGenerators(w), inSubgroup(f),
        wordInSubgroupGenerators(u), idProductDeco( prodDeco ),
       keepDetails( keep_details ) 
  };
  
@
\subsubsection{class SubgroupOfORGroupWithTorsion}
<<class SubgroupOfORGroupWithTorsion>>=
class SubgroupOfORGroupWithTorsion : public ORGSubgroup
{
public:
  SubgroupOfORGroupWithTorsion( const OneRelatorGroupWithTorsion& G,
                                const VectorOf<Word>& gens );
  ORGSubgroup *copy( ) const 
  const OneRelatorGroup& parentGroup() const 
  bool contains( const Word& w ) const;
  Word rewriteFromGroupToSubgroupGenerators( const Word& w ) const;
  bool operator == ( const SubgroupOfORGroupWithTorsion& S ) const 
private:
  void write( ostream& ostr ) const;
  void read( istream& istr );
  bool contains( const Word& w, Word& wInBasis ) const;
  OneRelatorGroupWithTorsion theParentGroup;
};

@
\subsection{AProducts/include/SuperGen.h}
<<SuperGen.h>>=
#include "Generator.h"

<<class SuperGen>>

@
\subsubsection{class SuperGen}
<<class SuperGen>>=
class SuperGen 
{
public:
  SuperGen() : gen(1), exp(0) 
  SuperGen( const Generator& g, int exponent = 1 ) : gen(g), exp(exponent) 
  Generator generator() const 
  int exponent() const 
  bool operator == ( const SuperGen& g ) const 
private:
  Generator gen;
  int exp;
};

  void operator < ( ostream& ostr, const SuperGen& g );
  void operator > ( istream& istr, SuperGen& g );
  ostream& operator << ( ostream& ostr, const SuperGen& g );
  istream& operator >> ( istream& istr, SuperGen& g );

@
\subsection{AProducts/include/Whitehead.h}
<<Whitehead.h>>=
#include "Set.h"
#include "List.h"
#include "Word.h"
#include "Automorphism.h"

typedef enum { WA_INVERSE, WA_PERMUTATION, WA_LEFT_MULT, WA_RIGHT_MULT } 
        WhiteheadAutoType;

<<class ElementaryWhiteheadAuto>>
<<class WhiteheadAuto>>

  inline bool operator==(const WhiteheadAuto& u, const WhiteheadAuto& w) 
  inline Word operator | (Word& w, ElementaryWhiteheadAuto& ewa) 
  inline Word operator | (const Word& w, const WhiteheadAuto& wa) 
  inline WhiteheadAuto operator | (const WhiteheadAuto& wa1, 
                                   const WhiteheadAuto& wa2)
  inline WhiteheadAuto& operator |= ( WhiteheadAuto& wa1, 
                                      const WhiteheadAuto& wa2)
  inline ostream& operator << ( ostream& ostr, const WhiteheadAuto& wa ) 
  WhiteheadAuto whiteheadDecomposition( const VectorOf<Word>& vec );

@
\subsubsection{class ElementaryWhiteheadAuto}
<<class ElementaryWhiteheadAuto>>=
class ElementaryWhiteheadAuto 
{
public:
  ElementaryWhiteheadAuto( const Generator& x );
  ElementaryWhiteheadAuto( const Generator& x, const Generator& y, 
                           const WhiteheadAutoType& wat );
  Generator x( ) const;
  Generator y( ) const;
  Word imageOf( const Word& w ) const;
  ElementaryWhiteheadAuto inverse( ) const;
  WhiteheadAutoType type( ) const 
  void printOn( ostream& ostr ) const;
  void printOn( ostream& ostr, const VectorOf<Chars>& names ) const;
private:
  void printGenerator( ostream& ostr, const Generator& g ) const;
  void printGenerator( ostream& ostr, const Generator& g,
                       const VectorOf<Chars>& names ) const;
  WhiteheadAutoType theType;
  Generator g1, g2;
};

inline ostream& operator << ( ostream& ostr, 
                              const ElementaryWhiteheadAuto& aut )
inline bool operator == ( const ElementaryWhiteheadAuto& u, 
                          const ElementaryWhiteheadAuto& w )
inline bool operator != ( const ElementaryWhiteheadAuto& u, 
                          const ElementaryWhiteheadAuto& w )

@
\subsubsection{class WhiteheadAuto}
<<class WhiteheadAuto>>=
class WhiteheadAuto 
{
public:
  WhiteheadAuto() 
  WhiteheadAuto(const ElementaryWhiteheadAuto& a) : autoList(a) 
  WhiteheadAuto(const ListOf<ElementaryWhiteheadAuto>& list) 
    : autoList(list) 
  ListOf<ElementaryWhiteheadAuto> getAutoList() const 
  WhiteheadAuto inverse() const;
  Word imageOf(const Word& w) const;
  Automorphism makeAutomorphism(const FGGroup& G) const;
  void printOn( ostream& ostr ) const;
private:
  ListOf<ElementaryWhiteheadAuto> autoList;
};

@
\section{The Elt classes}
\subsection{Elt/include/AbelianWord.h}
<<AbelianWord.h>>=
#include "Integer.h"
#include "Vector.h"
#include "PureRep.h"
#include "Word.h"

<<class AbelianWordRep>>
<<class AbelianWord>>

@
\subsubsection{class AbelianWordRep}
<<class AbelianWordRep>>=
class AbelianWordRep : public PureRep
{
public:
  AbelianWordRep( ) 
  AbelianWordRep( int numOfGens, const Word& w );
  AbelianWordRep( const VectorOf<Integer>& v ) : thePowers( v ) 
  bool operator == ( const AbelianWordRep& w ) const;
  Integer operator [] ( int i ) const;
  Integer& operator [] ( int i );
  AbelianWordRep* operator * ( const AbelianWordRep& aw ) const;
  int numberOfGenerators( ) const 
  VectorOf<Integer> getPowers( ) const 
  Word getWord( ) const;
  Integer fullLength( ) const;
  AbelianWordRep inverse( ) const;
  bool isTrivial( ) const;
  void printOn( ostream& ) const;
  void write( ostream& ostr ) const;
  void read( istream& istr );
  AbelianWordRep* clone( ) const 
private:
  VectorOf<Integer> thePowers;
};

@
\subsubsection{class AbelianWord}
<<class AbelianWord>>=
class AbelianWord : public ObjectOf<AbelianWordRep>
{
public:
  AbelianWord( )
    : ObjectOf<AbelianWordRep>( new AbelianWordRep( ) ) 
  AbelianWord( int numOfGens, const Word& w )
    : ObjectOf<AbelianWordRep>( new AbelianWordRep(numOfGens,w) ) 
  AbelianWord( const VectorOf<Integer>& v )
    : ObjectOf<AbelianWordRep>( new AbelianWordRep(v) ) 
  bool operator == ( const AbelianWord& w ) const 
  int operator != ( const AbelianWord& w ) const 
  Integer operator [] ( int i ) const 
  Integer& operator [] ( int i ) 
  AbelianWord operator * ( const AbelianWord& w ) const 
  int numberOfGenerators( ) const 
  VectorOf<Integer> getPowers( ) const 
  Word getWord( ) const 
  Integer fullLength( ) const 
  AbelianWord inverse( ) const 
  bool isTrivial( ) const 
  friend ostream& operator << ( ostream& ostr, const AbelianWord& w )
  friend ostream& operator < ( ostream& ostr, const AbelianWord& w )
  friend istream& operator > ( istream& istr, AbelianWord& w )
protected:
  AbelianWord( AbelianWordRep* newrep ) 
    : ObjectOf<AbelianWordRep>(newrep) 
};

@
\subsection{Elt/include/Elt.h}
<<Elt.h>>=
#include "EltRep.h"
#include "Integer.h"
#include "Rational.h"

<<class Elt>>

@
\subsubsection{class Elt}
<<class Elt>>=
class Elt : public GenericObject 
{
public:
  Elt( ) : GenericObject( new EltIdentityRep ) 
  int operator == ( const Elt& e ) const 
  int operator != ( const Elt& e ) const 
  static Type type( ) 
  Type actualType( ) const 
  int hash( ) const 
  Elt operator * ( const Elt& e ) const 
  Elt operator *= ( const Elt& e ) 
  Elt raiseToPower( Integer power ) const;
  Elt inverse() const 
  friend Elt inverse( const Elt& e ) 
  Elt conjugateBy( const Elt& e ) const 
  friend Elt commutator( const Elt&, const Elt& );
  friend ostream& operator << ( ostream&, const Elt& );
  void debugPrint( ostream& o ) const; 
  friend ostream& operator < ( ostream& ostr, const Elt& e )
  friend istream& operator > ( istream& istr, Elt& e )
protected:
  const EltRep* look( ) const 
  EltRep* enhance( ) const 
  EltRep* change( ) 
  Elt( EltRep* p ) : GenericObject(p) 

};

@
\subsection{Elt/include/EltRep.h}
<<EltRep.h>>=
#include "GenericObject.h"
#include "Type.h"
 
<<struct EltRep>>
<<struct EltIdentityRep>>

@
\subsubsection{struct EltRep}
<<struct EltRep>>=
struct EltRep : GenericRep 
{
  virtual ~EltRep( ) 
  static const Type theEltType;
  static Type type( ) 
  virtual Type actualType( ) const 
  PureRep* clone( ) const = 0;
  virtual Bool operator == ( const EltRep& ) const = 0;
  virtual int hash( ) const = 0;
  virtual EltRep* operator * ( const EltRep& ) const = 0;
  virtual EltRep* inverse( ) const = 0;
  virtual EltRep* conjugateBy( const EltRep* ep ) const 
  virtual EltRep* commutatorWith( const EltRep* ep ) const 
  virtual void printOn(ostream&) const;
  virtual void debugPrint(ostream&) const;
  virtual void write( ostream& ostr ) const 
  virtual void  read( istream& istr ) 
private:
  EltRep& operator = ( const EltRep& ); 
};

@
\subsubsection{struct EltIdentityRep}
<<struct EltIdentityRep>>=
struct EltIdentityRep : EltRep 
{
  PureRep* clone( ) const 
  static const Type theEltIdentityType;
  static Type type( ) 
  Type actualType( ) const 
  virtual Bool operator == ( const EltRep& ) const 
  virtual int hash( ) const 
  virtual EltRep* operator * ( const EltRep& e ) const
  virtual EltRep* inverse( ) const 

};

@
\subsection{Elt/include/Generator.h}
<<Generator.h>>=

<<class Generator>>


inline Generator inv( Generator g ) 
inline int operator == (Generator g, Generator h) 
inline int operator != (Generator g, Generator h) 
inline int operator < (Generator g, Generator h) 
inline int operator <= (Generator g, Generator h) 
inline int operator > (Generator g, Generator h) 
inline int operator >= (Generator g, Generator h) 
inline ostream& operator << ( ostream& ostr, Generator g ) 
inline int power(Generator g) 
inline int abs(Generator g) 
inline int shortLexIndex(Generator g) 
\subsubsection{class Generator}
<<class Generator>>=
class Generator 
{
public:
  Generator( ) : genrep(0) 
  Generator( int i ) : genrep(i) 
  inline friend int ord( Generator g ) 
  int hash() const 
  friend ostream& operator < ( ostream& ostr, const Generator& g )
  friend istream& operator > ( istream& istr, Generator& g )
private:
  int genrep;
};

@
\subsection{Elt/include/NormalRandomWord.h}
<<NormalRandomWord.h>>=
#include "Word.h"
#include "RandomNumbers.h"

<<class NormalRandomWord>>

@
\subsubsection{class NormalRandomWord}
<<class NormalRandomWord>>=
class NormalRandomWord 
{
public:
  NormalRandomWord(int numberOfGenerators, int meanLength, int lengthStddev,
                   int lengthSeed, int generatorSeed)
    : numGens(numberOfGenerators), mean(meanLength), stddev(lengthStddev),
              G(generatorSeed), L(lengthSeed) 
  Word word( );
  friend ostream& operator < ( ostream& ostr, const NormalRandomWord& nRW )
  friend istream& operator > ( istream& istr, NormalRandomWord& nRW )
private:
  int numGens, mean, stddev;
  UniformRandom G;
  NormalRandom L;
};

@
\subsection{Elt/include/WordData.h}
<<WordData.h>>=
#include "Generator.h"
#include "List.h"
#include "Vector.h"

<<class WordData>>

@
\subsubsection{class WordData}
<<class WordData>>=
class WordData 
{
public:
  typedef int GeneratorType;
  typedef GeneratorType* GeneratorPtrType; 
  typedef const GeneratorType* cGeneratorPtrType;
  WordData( const WordData& wd ) :
    len(wd.len), wrd(new GeneratorType[wd.len]) 
  ~WordData( ) 
  WordData( int le ) 
  WordData( const Generator& x ) : len(1), wrd(new GeneratorType[1]) 
  WordData( const Generator& x, const Generator& y ) :
    len(2), wrd(new GeneratorType[2]) 
  WordData( const VectorOf<Generator>& v ) 
  WordData( const ListOf<Generator>& l ) 
  WordData( const GeneratorType *p, int le ) 
  int length( ) const 
  GeneratorType& ref(int i) 
  GeneratorType val(int i) const 
  GeneratorPtrType first( ) 
  cGeneratorPtrType cFirst( ) const 
  GeneratorPtrType last( ) 
  cGeneratorPtrType cLast( ) const 
private:
  int len;
  static const int MAXLENGTH = 2000000000; 
  GeneratorType* wrd;
  friend class WordRep;
};

@
\subsection{Elt/include/Word.h}
<<Word.h>>=
#include "Elt.h"
#include "WordRep.h"
#include "Generator.h"
#include "Vector.h"
#include "List.h"
#include "Chars.h"
#include "DerivedObjectOf.h"
#include "Set.h"

<<class Genref>>
<<class Word>>

inline Generator Word::operator [] ( int i ) const 
inline Genref Word::operator [] ( int i ) 
istream& operator>>( istream& istr, Word& );
int maximalRoot(const Word& w);
SetOf<Word>& closeUnderInverses(SetOf<Word>& S);
SetOf<Word>& closeUnderCyclicPermutations(SetOf<Word>& S);
inline SetOf<Word>& symmetrise(SetOf<Word>& S) 
int cancellationLambda( const SetOf<Word>& ss );
Trichotomy hasMetricSmallCancellation(const SetOf<Word>& S, const int lambda);

@
\subsubsection{class Word}
<<class Word>>=
class Word : public DerivedObjectOf<Elt,WordRep> 
{
public:  
  Word( ) : DerivedObjectOf<Elt,WordRep>(new WordRep(0)) 
  Word( const VectorOf<Generator>& v ) :
    DerivedObjectOf<Elt,WordRep>(new WordRep(v)) 
  Word( const ListOf<Generator>& l ) :
    DerivedObjectOf<Elt,WordRep>(new WordRep(l)) 
  Word( const Generator& g ) : 
    DerivedObjectOf<Elt,WordRep>( new WordRep(g) ) 
  Word( const Elt& e ) : DerivedObjectOf<Elt,WordRep>( e ) 
  static Type type( ) 
  int length( ) const 
  Generator operator [] ( int i ) const;
  Genref operator [] ( int i );
  Bool operator < ( const Word& ) const;
  Word nextInShortLex(int numberOfGens) const;
  Word nextFreelyReduced(int numberOfGens) const;
  Word nextCyclicallyReduced(int numberOfGens) const;
  Word subword(const int i, const int j) const;
  Word initialSegment(const int i) const 
  Word terminalSegment(const int i) const 
  Word findAgreement(const Word&) const;
  int agreementLength( const Word& ) const;
  Word shortenByRelator(const Word&) const;
  int numberOfOccurrences(const Generator& g) const;
  int exponentSum(const Generator& g) const;
  bool allExponentSumsZero( ) const;
  bool isProperPower( ) const;
  Generator maxOccurringGenerator( ) const;
  Word replaceGeneratorWithWord(const Generator&, const Word&) const;
  Elt replaceGenerators( const VectorOf<Elt>& eltvec ) const;
  Word replaceGenerators( const VectorOf<Word>& eltvec ) const;
  Word replaceSubword(const int i, const int j, const Word& w) const;
  Word freelyReduce( ) const;
  Word cyclicallyReduce(void) const;
  Word cyclicallyPermute(const int j) const;
  Word inverse( ) const 
  Word operator * ( const Word& w ) const 
  Word operator * ( const Generator& x ) 
  inline friend Word operator * ( const Generator& x, const Word& w ) 
  inline friend Word operator * ( const Generator& x, const Generator& y ) 
  Word operator *= ( const Word& w ) 
  Word operator *= ( const Generator& x ) 
  static Word wordByLexRank( int numGens, int lexRank );
  static Word wordByLexRank( VectorOf<int> vi )

<<class EmptyWord>>
<<class ProductJunctor>>

private:
  typedef WordData::GeneratorPtrType GeneratorPtrType;  
  typedef WordData::cGeneratorPtrType cGeneratorPtrType;
  typedef WordData::GeneratorType GeneratorType;
  friend class Genref;
  Word( int len ) : DerivedObjectOf<Elt,WordRep>( new WordRep(len) ) 
  Word( const GeneratorType* p, int len ) :
    DerivedObjectOf<Elt,WordRep>( new WordRep(p, len) )  
  Word( EltRep* rep ) : DerivedObjectOf<Elt,WordRep>((WordRep*)rep) 

};

@
\subsubsection{class EmptyWord}
<<class EmptyWord>>=
class EmptyWord 
{
  Chars emptyWord;
public:
  EmptyWord( const Chars& ew ) : emptyWord(ew) 
  operator Chars( ) const 
};

@ 
\subsubsection{class ProductJunctor}
<<class ProductJunctor>>=
class ProductJunctor 
{
  Chars junctor;
public:
  ProductJunctor( const Chars& j ) : junctor(j) 
  operator Chars( ) const 
};

@
\subsubsection{class Genref}
<<class Genref>>=
class Genref 
{
public:
  Generator operator = ( const Generator& g ) 
  int operator == ( const Generator& g ) 
  operator Generator( ) 
private:
  friend class Word; 
  Genref( Word& w, int i ) : wref(w), index(i) 
  Word& wref;
  int index;
  Genref( const Genref& g ) : wref(g.wref), index(g.index) 
  Genref operator = ( const Genref& g ) 
};

@
\subsection{Elt/include/WordRep.h}
<<WordRep.h>>=
#include "EltRep.h"
#include "WordData.h"

<<struct WordRep>>

@
\subsubsection{struct WordRep}
<<struct WordRep>>=
struct WordRep : EltRep, WordData 
{
  WordRep( int len ) : WordData(len) 
  WordRep( const Generator& x ) : WordData(x) 
  WordRep( const Generator& x, const Generator& y ) : WordData(x, y) 
  WordRep( const VectorOf<Generator>& v ) : WordData(v) 
  WordRep( const ListOf<Generator>& l ) : WordData(l) 
  WordRep( const GeneratorType *p, int len ) : WordData(p, len) 
  PureRep* clone( ) const 
  static const Type theWordType;
  static Type type( ) 
  Type actualType( ) const 
  Bool operator == ( const EltRep& ) const;
  int hash() const;
  EltRep* operator * ( const EltRep& a ) const;
  EltRep* inverse() const;
  EltRep* rightMultBy( const Generator& x ) const;
  EltRep* leftMultBy( const Generator& x ) const;
  EltRep* conjugateBy( const EltRep* ep ) const;
  EltRep* commutatorWith( const EltRep* ep ) const;
  void printOn(ostream&) const;
  void debugPrint(ostream&) const;
  void write( ostream& ostr ) const
  void read( istream& istr )
};

@
\section{The Enumerators classes}
\subsection{Enumerators/include/AutoEnumerator.h}
<<AutoEnumerator.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "SMList.h"
#include "SMListIterator.h"
#include "RandomAutoInFree.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "fastProblems.h"
#include "OutMessages.h"

<<class AutEnumeratorARCer2>>
<<class AutoEnumeratorProblem>>
<<class FiniteAutoEnumeratorProblem>>
<<class IsMapInListARCer>>
<<class IsMapInList>>

@
\subsubsection{class AutEnumeratorARCer2}
<<class AutEnumeratorARCer2>>=
class AutEnumeratorARCer2 : public EnumeratorARCer
{
public:
  AutEnumeratorARCer2( ComputationManager& boss, SMListData& d ) 
    : EnumeratorARCer( boss, d ), randAuto( 0 ),  current( 0 ) 
  ~AutEnumeratorARCer2( ) 
  void setArguments( FreeGroup group, int avgNumbers, int n);
  void enumerate( );
  void writeResults( ostream& );
  void readResults( istream& );
  bool isAbelian, isFinite;
private:
  int current;
  RandomAutoInFree* randAuto;
  int number;
};

@
\subsubsection{class AutoEnumeratorProblem}
<<class AutoEnumeratorProblem>>=
class AutoEnumeratorProblem : public EnumeratorProblem< Map >
{
public:
  AutoEnumeratorProblem(SMFPGroup& );
  void viewStructure(ostream& ostr) const;  
  void takeControl( ); 
  Chars getDataFileName() const 
  void start( ) 
  void terminate( ) 
  void resume( ) 
private:
  SMFPGroup& theGroup;
  AutEnumeratorARCer2 arcer;
};

@
\subsubsection{class FiniteAutoEnumeratorProblem}
<<class FiniteAutoEnumeratorProblem>>=
class FiniteAutoEnumeratorProblem : public EnumeratorProblem< Map >
{
public:
  FiniteAutoEnumeratorProblem(SMFPGroup& );
  void viewStructure(ostream& ostr) const;  
  void takeControl( ); 
  Chars getDataFileName() const 
  void start( ) 
  void terminate( ) 
  void resume( ) 
private:
  SMFPGroup& theGroup;
  AutEnumeratorARCer2 arcer;
};

@
\subsubsection{class IsMapInListARCer}
<<class IsMapInListARCer>>=
class IsMapInListARCer : public ARCer
{
public:
  IsMapInListARCer( ComputationManager& boss ) 
    : ARCer( boss ), result(0) 
  ~IsMapInListARCer( ) 
  void setArguments( const SMList<Map>&, const Map&);
  bool isInList();
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Map>* theIterator;
  Map theMap;
  bool result;
};

@
\subsubsection{class IsMapInList}
<<class IsMapInList>>=
class IsMapInList  : public Supervisor
{
public:
 IsMapInList( SMList<Map>&, const class SMMap& );
  void viewStructure(ostream& ostr) const;  
  void takeControl( ); 
  void start( ) 
  void terminate( ) 
private:
  const class SMMap& theMap;
  SMList<Map>& theList;
  IsMapInListARCer arcer;
};

@
\subsection{Enumerators/include/FreeListProblems.h}
<<FreeListProblems.h>>=
#include "Supervisor.h"
#include "SMList.h"
#include "File.h"
#include "FPGroup.h"
#include "OutMessages.h"
#include "SMListIterator.h"
#include "ListProblems.h"

<<class SMListProperPowerInFreeARCer>>
<<class SMListExtractProperPowerInFree>>
<<class SMListCommutatorsInFreeARCer>>
<<class SMListExtractCommutatorsInFree>>
<<class SGListExtractOfRankARCer>>
<<class SGListExtractOfRank>>
<<class SGListExtractNormalARCer>>
<<class SGListExtractNormal>>
<<class SGListExtractMalnormalARCer>>
<<class SGListExtractMalnormal>>
<<class MapListExtractIAautoARCer>>
<<class MapListExtractIAauto>>
<<class MapListExtractInnerARCer>>
<<class MapListExtractInner>>

@
\subsubsection{class SMListProperPowerInFreeARCer}
<<class SMListProperPowerInFreeARCer>>=
class SMListProperPowerInFreeARCer : public ARCer
{
public:
  SMListProperPowerInFreeARCer( ComputationManager& boss ) 
    : ARCer( boss ),
      theIterator( NULL ) 
  void setArguments( const SMList<Word>& );
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i) 
private:
  SMListIterator<Word>* theIterator;
  FPGroup theGroup;
  SMListData theData;
};

@
\subsubsection{class SMListExtractProperPowerInFree}
<<class SMListExtractProperPowerInFree>>=
class SMListExtractProperPowerInFree  : public SMListSupervisor
{
public:
  SMListExtractProperPowerInFree( SMList<Word>& );
  ~SMListExtractProperPowerInFree() 
  void viewStructure(ostream& ostr) const;  
  void takeControl( );
  void start( ); 
  void terminate( ) 
private:
  SMList<Word>& theList;            
  SMListProperPowerInFreeARCer arcer;
};

@
\subsubsection{class SMListCommutatorsInFreeARCer}
<<class SMListCommutatorsInFreeARCer>>=
class SMListCommutatorsInFreeARCer : public ARCer
{
public:
  SMListCommutatorsInFreeARCer( ComputationManager& boss ) 
    : ARCer( boss ),
      theIterator( NULL ) 
  void setArguments( const SMList<Word>& );
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i) 
private:
  SMListIterator<Word>* theIterator;
  FreeGroup theGroup;
  SMListData theData;
};

@
\subsubsection{class SMListExtractCommutatorsInFree}
<<class SMListExtractCommutatorsInFree>>=
class SMListExtractCommutatorsInFree  : public SMListSupervisor
{
public:
  SMListExtractCommutatorsInFree( SMList<Word>& );
  ~SMListExtractCommutatorsInFree() 
  void viewStructure(ostream& ostr) const; 
  void takeControl( ); 
  void start( ); 
  void terminate( ) 
private:
  SMList<Word>& theList;            
  SMListCommutatorsInFreeARCer arcer;
};

@
\subsubsection{class SGListExtractOfRankARCer}
<<class SGListExtractOfRankARCer>>=
class SGListExtractOfRankARCer : public ARCer
{
public:
  SGListExtractOfRankARCer( ComputationManager& boss ) 
    : ARCer( boss ),
    minRank( 1 ), 
    maxRank( 0 ) 
  ~SGListExtractOfRankARCer( ) 
  void setArguments( const SMList<Subgroup>&);
  const SMListData& getData() const 
  void setMinimalRank(int  min ) 
  void setMaximalRank(int  max ) 
  int indexInFreeGroup( const VectorOf<Word>& s )const;
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Subgroup>* theIterator;
  SMListData theData;
  const SMFPGroup* theGroup;
  int minRank; 
  int maxRank;
};

@
\subsubsection{class SGListExtractOfRank}
<<class SGListExtractOfRank>>=
class SGListExtractOfRank  : public Supervisor
{
public:
 SGListExtractOfRank( SMList<Subgroup>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );  
  void start( );        
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SGListExtractOfRankARCer arcer;
};

@
\subsubsection{class SGListExtractNormalARCer}
<<class SGListExtractNormalARCer>>=
class SGListExtractNormalARCer : public ARCer
{
public:
  SGListExtractNormalARCer( ComputationManager& boss ) 
    : ARCer( boss ) 
  ~SGListExtractNormalARCer( ) 
  void setArguments( const SMList<Subgroup>&);
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Subgroup>* theIterator;
  SMListData theData;
  FreeGroup theGroup;
};

@
\subsubsection{class SGListExtractNormal}
<<class SGListExtractNormal>>=
class SGListExtractNormal  : public Supervisor
{
public:
  SGListExtractNormal( SMList<Subgroup>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );  
  void start( );        
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SGListExtractNormalARCer arcer;
};

@
\subsubsection{class SGListExtractMalnormalARCer}
<<class SGListExtractMalnormalARCer>>=
class SGListExtractMalnormalARCer : public ARCer
{
public:
  SGListExtractMalnormalARCer( ComputationManager& boss ) 
    : ARCer( boss ) 
  ~SGListExtractMalnormalARCer( ) 
  void setArguments( const SMList<Subgroup>&);
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Subgroup>* theIterator;
  SMListData theData;
  FreeGroup theGroup;
};

@
\subsubsection{class SGListExtractMalnormal}
<<class SGListExtractMalnormal>>=
class SGListExtractMalnormal  : public Supervisor
{
public:
  SGListExtractMalnormal( SMList<Subgroup>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( ); 
  void start( );       
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SGListExtractMalnormalARCer arcer;
};

@
\subsubsection{class MapListExtractIAautoARCer}
<<class MapListExtractIAautoARCer>>=
class MapListExtractIAautoARCer : public ARCer
{
public:
  MapListExtractIAautoARCer( ComputationManager& boss ) 
    : ARCer( boss ) 
  ~MapListExtractIAautoARCer( ) 
  void setArguments( const SMList<Map>&);
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Map>* theIterator;
  SMListData theData;
  FreeGroup theGroup;
};

@
\subsubsection{class MapListExtractIAauto}
<<class MapListExtractIAauto>>=
class MapListExtractIAauto  : public Supervisor
{
public:
  MapListExtractIAauto( SMList<Map>& );
  void viewStructure(ostream& ostr) const;
  void takeControl( );    
  void start( );          
  void terminate( ) 
private:
  SMList<Map>& theList;
  bool started;
  MapListExtractIAautoARCer arcer;
};

@
\subsubsection{class MapListExtractInnerARCer}
<<class MapListExtractInnerARCer>>=
class MapListExtractInnerARCer : public ARCer
{
public:
  MapListExtractInnerARCer( ComputationManager& boss ) 
    : ARCer( boss ) 
  ~MapListExtractInnerARCer( ) 
  void setArguments( const SMList<Map>&);
  const SMListData& getData() const 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Map>* theIterator;
  SMListData theData;
  FreeGroup theGroup;
};

@
\subsubsection{class MapListExtractInner}
<<class MapListExtractInner>>=
class MapListExtractInner  : public Supervisor
{
public:
  MapListExtractInner( SMList<Map>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( ); 
  void start( );       
  void terminate( ) 
private:
  SMList<Map>& theList;
  bool started;
  MapListExtractInnerARCer arcer;
};

@
\subsection{Enumerators/include/HomEnumerators.h}
<<HomEnumerators.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "WordEnumerator.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "RandomNumbers.h"
#include "OutMessages.h"

<<class HomEnumeratorARCer1>>
<<class RandHomEnumeratorProblem>>
<<class HomEnumeratorARCer2>>
<<class TotalHomEnumeratorProblem>>

@
\subsubsection{class HomEnumeratorARCer1}
<<class HomEnumeratorARCer1>>=
class HomEnumeratorARCer1 : public EnumeratorARCer
{
public:
  HomEnumeratorARCer1( ComputationManager& boss , SMListData& d , GIC& gic ) 
    : EnumeratorARCer( boss , d ), rangeGIC( gic ), current( 0 ), number( 0 ),
      avgLength( 0 ), lengthPicker(2112), genPicker(1812) 
  void setArguments( FPGroup g , FPGroup h , int avgNumbers , int n );
  void setParams( int k , int n ) 
  Map getMap();
  bool extendToHom( Map& );
  void enumerate( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  int  current;
  int avgLength;
  int number;
  NormalRandom lengthPicker;
  UniformRandom genPicker;
  GIC& rangeGIC;
  FPGroup G;
  FPGroup H;
};

@
\subsubsection{class RandHomEnumeratorProblem}
<<class RandHomEnumeratorProblem>>=
class RandHomEnumeratorProblem : public EnumeratorProblem< Map >
{
public:
  RandHomEnumeratorProblem( SMFPGroup& , SMFPGroup& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );    
  Chars getDataFileName() const 
  void start( );
  void terminate( ) 
  void resume( ) 
private:
  SMFPGroup& G;
  SMFPGroup& H;
  HomEnumeratorARCer1 arcer;
  bool init;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
};

@
\subsubsection{class HomEnumeratorARCer2}
<<class HomEnumeratorARCer2>>=
class HomEnumeratorARCer2 : public EnumeratorARCer
{
public:
  HomEnumeratorARCer2( ComputationManager& boss , SMListData& d , GIC& gic ) 
    : EnumeratorARCer( boss , d ), rangeGIC( gic ), current( 0 ),
      number( 0 ), we( FreeGroup() ) 
  void setArguments( FPGroup G , FPGroup H , int n );
  void setParam( int k )
  Map nextMap();
  bool extendToHom( Map& );
  void enumerate( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  WordEnumerator we;
  int number;
  int current;
  FPGroup G;
  FPGroup H;
  class GIC& rangeGIC;
};

@
\subsubsection{class TotalHomEnumeratorProblem}
<<class TotalHomEnumeratorProblem>>=
class TotalHomEnumeratorProblem : public EnumeratorProblem< Map >
{
public:
  TotalHomEnumeratorProblem( SMFPGroup& , SMFPGroup& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );    
  Chars getDataFileName() const 
  void start( );
  void terminate( ) 
  void resume( ) 
private:
  SMFPGroup& G;
  SMFPGroup& H;
  HomEnumeratorARCer2 arcer;
  bool init;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
};

@
\subsection{Enumerators/include/ListProblems.h}
<<ListProblems.h>>=
#include "Supervisor.h"
#include "fastProblems.h"
#include "SMList.h"
#include "SMListIterator.h"

<<class SMListSupervisor>>
<<template <class T> class SMListJoinARCer>>
<<template <class T> class SMListJoin>>
<<template <class T> class MakeSMListOf>>

@
\subsubsection{class SMListSupervisor}
<<class SMListSupervisor>>=
class SMListSupervisor :  public Supervisor
{
 public:
  SMListSupervisor( SMList<Word>& l ) : Supervisor( true ), theList( l ) 
  SMList<Word>& getList() 
 protected:
  SMList<Word>& theList;
};

@
\subsubsection{template <class T> class SMListJoinARCer}
<<template <class T> class SMListJoinARCer>>=
template <class T> class SMListJoinARCer : public ARCer
{
public:
  SMListJoinARCer( ComputationManager& boss ) 
    : ARCer( boss ), l2Data( NULL ), l1Data( NULL ) 
  ~SMListJoinARCer( ) 
  void setArguments( const SMList<T>&, const SMList<T>& );
  const SMListData getJoinData() const 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListData* l1Data;
  SMListData* l2Data;
  SMListData joinData;
};

@
\subsubsection{template <class T> class SMListJoin}
<<template <class T> class SMListJoin>>=
template <class T> class SMListJoin  : public Supervisor
{
public:
  SMListJoin( SMList<T>&, SMList<T>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );     
  void start( ) 
  void terminate( ) 
private:
  SMList<T>& list1;
  SMList<T>& list2;
  bool started;
  SMListJoinARCer<T> arcer;
};

@
\subsubsection{template <class T> class MakeSMListOf}
<<template <class T> class MakeSMListOf>>=
template <class T> class MakeSMListOf : public FastComputation
{
public:
  MakeSMListOf( EnumeratorProblem<T>& e): enumerator( e ) 
  void takeControl( );  
protected:
  EnumeratorProblem<T>& enumerator;
};

@
\subsection{Enumerators/include/ORConsequencesEnumerator.h}
<<ORConsequencesEnumerator.h>>=
#include "OneRelatorGroup.h"
#include "Supervisor.h"
#include "SMSubgroup.h"
#include "SMEnumerator.h"
#include "File.h"

<<class ORConsequencesEnumeratorARCer>>
<<class ORConsequencesEnumerator>>

@
\subsubsection{class ORConsequencesEnumeratorARCer}
<<class ORConsequencesEnumeratorARCer>>=
class ORConsequencesEnumeratorARCer : public EnumeratorARCer
{
public:
  ORConsequencesEnumeratorARCer( ComputationManager& boss,SMListData& d,
         const OneRelatorGroup& g ) 
    : EnumeratorARCer( boss, d ), theEnumerator( g ), theGroup( g ),
      counter( 1 ),  numberOfAll( 100 )
  Chars getFileName() const 
  void setNumberOfAll( int n ) 
  void writeResults( ostream& );
  void readResults( istream& );
protected:
  void enumerate();
private:
  EnumeratorOfConsequences theEnumerator;
  OneRelatorGroup theGroup;
  File file;
  int counter;
  int numberOfAll;
};

@
\subsubsection{class ORConsequencesEnumerator}
<<class ORConsequencesEnumerator>>=
class ORConsequencesEnumerator : public  EnumeratorProblem< Word >
{
public:
  ORConsequencesEnumerator( SMFPGroup&);
  void viewStructure(ostream& ostr) const;  
  class SMFPGroup& getGroup() const 
  void takeControl( );    
  void start( ) 
  void terminate( ) 
  void resume() 
private:
  SMFPGroup& theSMFPGroup;
  ORConsequencesEnumeratorARCer arcer;
  bool started;
};

@
\subsection{Enumerators/include/REnumerator.h}
<<REnumerator.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "OutMessages.h"
#include "RandomNumbers.h"

<<class NCEnumerateTotalARCer>>
<<class NCEnumerateRandomARCer>>
<<class NCRelatorEnumerator>>

@
\subsubsection{class NCEnumerateTotalARCer}
<<class NCEnumerateTotalARCer>>=
class NCEnumerateTotalARCer : public EnumeratorARCer
{
public:
  NCEnumerateTotalARCer( ComputationManager& boss, SMListData& d,
       const FPGroup& group ) 
    : EnumeratorARCer( boss, d ), theGroup(group), numberOfAll(100),
      counter(0) 
  void setTotalNumber(int n) 
  void writeResults( ostream& ostr ) 
  void readResults( istream& istr) 
protected:
  void enumerate();
private:
  FPGroup theGroup;
  int numberOfAll;
  Word currentWord;
  int counter;
};

@
\subsubsection{class NCEnumerateRandomARCer}
<<class NCEnumerateRandomARCer>>=
class NCEnumerateRandomARCer : public EnumeratorARCer
{
public:
  NCEnumerateRandomARCer( ComputationManager& boss, SMListData& d,
        const FPGroup& group ) 
    : EnumeratorARCer( boss, d ), theGroup(group), numberOfAll(100),
    maxConjLength(100), typeIsUniform( true ),  numberOfFactors( 10 ),
    counter(0) 
  void setTotalNumber(int n) 
  void setConjL(int n) 
  void setNumOfFactors(int n) 
  void setTypeUniform() 
  void setTypeNormal() 
  void writeResults( ostream& o ) 
  void readResults( istream& i ) 
protected:
  Word getRelConj();
  void enumerate();
private:
  FPGroup theGroup;
  int numberOfAll;
  int maxConjLength;
  bool typeIsUniform;
  int counter;
  int numberOfFactors;
  UniformRandom ur; 
  NormalRandom nr; 
};

@
\subsubsection{class NCRelatorEnumerator}
<<class NCRelatorEnumerator>>=
class NCRelatorEnumerator : public EnumeratorProblem< Word >
{
public:
  NCRelatorEnumerator(SMFPGroup& );
  void viewStructure(ostream& ostr) const;
  void takeControl( ); 
  void start( ) ;      
  void terminate( ) 
  void resume( );      
private:
  SMFPGroup& theGroup;
  EnumeratorARCer* arcer;
};

@
\subsection{Enumerators/include/SGREnumerator.h}
<<SGREnumerator.h>>=
#include "Supervisor.h"
#include "SMSubgroup.h"
#include "SMEnumerator.h"
#include "File.h"

<<class SGRelatorEnumeratorARCer>>
<<class SGRelatorEnumerator>>

@
\subsubsection{class SGRelatorEnumeratorARCer}
<<class SGRelatorEnumeratorARCer>>=
class SGRelatorEnumeratorARCer : public EnumeratorARCer
{
public:
  SGRelatorEnumeratorARCer( ComputationManager& boss, SMListData& d ) 
    : EnumeratorARCer( boss, d ), firstStart(true),  counter( 1 ),
      numberOfAll( 100 )
  void setArguments( const class SMFPGroup* group,
         const class SMSubgroup* subgroup );
  void setNumberOfAll( int n ) 
  bool ORisTrivial(const Word&  theTestWord);
  void writeResults( ostream& );
  void readResults( istream& );
  Chars getFileName() const 
protected:
  void enumerate();
private:
  const class SMSubgroup* theSMSubgroup;
  const class SMFPGroup* theGroup;
  Word possibleRelator;
  bool firstStart;
  int counter;
  int numberOfAll;
  File file;
};

@
\subsubsection{class SGRelatorEnumerator}
<<class SGRelatorEnumerator>>=
class SGRelatorEnumerator : public  EnumeratorProblem< NoType >
{
public:
  SGRelatorEnumerator( SMSubgroup&);
  void viewStructure(ostream& ostr) const;
  class SMSubgroup& getSubgroup() const 
  void takeControl( );  
  void start( ) 
  void terminate( ) 
  void resume() 
private:
  SMSubgroup& theSMSubgroup;
  SGRelatorEnumeratorARCer arcer;
  class GIC& theGIC;
  bool started;
  bool firstStart;  
  bool resumed;
  bool useORwordProblem;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
};

@
\subsection{Enumerators/include/SMListIterator.h}
<<SMListIterator.h>>=
#include "SMList.h"
#include "Word.h"
#include "SMEnumerator.h"

<<template <class T> class SMListIterator>>
<<class WriteEnumeratorElement>>
<<class EnumWriteWord>>
<<class EnumWriteMap>>
<<class EnumWriteVectorOfWords>>
<<class EnumWriteSetOfWords>>
<<class EnumWriteChars>>

@
\subsubsection{template <class T> class SMListIterator}
<<template <class T> class SMListIterator>>=
template <class T> class SMListIterator 
{
public:
  SMListIterator(const SMList<T>& );
  ~SMListIterator() 
  bool EOL() const 
  void reset(); 
  bool nextCell();
  const T& getData(); 
  int getNumberOfElements()const 
private:
  void deleteCurrentData();
  void parseData();
  Chars currentLine;
  T* currentData;
  FPGroup theGroup;
  int numberOfCurrent;
  SMListData theData;
  bool eol_reached;
};

@
\subsubsection{class WriteEnumeratorElement}
<<class WriteEnumeratorElement>>=
class WriteEnumeratorElement
{
 public:
  WriteEnumeratorElement() 
  virtual void print(ostream& ostr) const = 0;
  inline friend ostream& operator << ( ostream& o, 
                                       const WriteEnumeratorElement& we ) 
protected:
private:
  WriteEnumeratorElement(const WriteEnumeratorElement&);
};

@
\subsubsection{class EnumWriteWord}
<<class EnumWriteWord>>=
class EnumWriteWord : public WriteEnumeratorElement
{
public:
  EnumWriteWord( const Word& w, const FPGroup& g) :  theW( w ), theG( g ) 
  void print( ostream& o ) const;
private:
  Word theW;
  FPGroup theG;
};

@
\subsubsection{class EnumWriteMap}
<<class EnumWriteMap>>=
class EnumWriteMap : public WriteEnumeratorElement
{
public:
  EnumWriteMap( const Map& m ) : theM( m ) 
  void print( ostream& o ) const;
private:
  Map theM;
};

@
\subsubsection{class EnumWriteVectorOfWords}
<<class EnumWriteVectorOfWords>>=
class EnumWriteVectorOfWords : public WriteEnumeratorElement
{
public:
  EnumWriteVectorOfWords( const VectorOf<Word>& v, const FPGroup& g ) 
    : theV( v ), theG( g ) 
  void print( ostream& o ) const;
private:
  VectorOf<Word> theV;
  FPGroup theG;
};

@  
\subsubsection{class EnumWriteSetOfWords}
<<class EnumWriteSetOfWords>>=
class EnumWriteSetOfWords : public WriteEnumeratorElement
{
public:
  EnumWriteSetOfWords( const SetOf<Word>& s, const FPGroup& g ) 
    : theS( s ), theG( g ) 
  void print( ostream& o ) const;
private:
  SetOf<Word> theS;
  FPGroup theG;
};

@
\subsubsection{class EnumWriteChars}
<<class EnumWriteChars>>=
class EnumWriteChars : public WriteEnumeratorElement
{
public:
  EnumWriteChars( const Chars& c ) : theC( c )
  void print( ostream& o ) const;
private:
  Chars theC;
};

@
\subsection{Enumerators/include/SMListSubgroupProblems.h}
<<SMListSubgroupProblems.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "SMList.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "OutMessages.h"
#include "RandomNumbers.h"
#include "ListProblems.h"
#include "SMListIterator.h"

<<class SMListSGTrivialARCer>>
<<class SMListSGTrivialComputation>>
<<class SMListExtractTrivialSubgroups>>
<<class SMListSGAbelianARCer>>
<<class SMListSGAbelianComputation>>
<<class SMListExtractAbelianSubgroups>>
<<class SMListSGCentralARCer>>
<<class SMListSGCentralComputation>>
<<class SMListExtractCentralSubgroups>>

@
\subsubsection{class SMListSGTrivialARCer}
<<class SMListSGTrivialARCer>>=
class SMListSGTrivialARCer : public ARCer
{
public:
  SMListSGTrivialARCer( ComputationManager& boss );
  void setArguments( SMList<Subgroup>*);
  void runComputation( );
  void writeResults( ostream& o) 
  void readResults( istream& i) 
  Chars getFileOfNonTrivial() const 
  const SMListData& getTrivialData() const 
private:
  SMListIterator<Subgroup>* theIterator;
  const class SMFPGroup* theGroup;
  class SMList<Subgroup>* theList;
  int tCounter;
  int ntCounter;
  File fileOfNonTrivial;
  SMListData trivialData;
};

@
\subsubsection{class SMListSGTrivialComputation}
<<class SMListSGTrivialComputation>>=
class SMListSGTrivialComputation  : public ComputationManager
{
public:
  SMListSGTrivialComputation( class SMListExtractTrivialSubgroups& );
  ~SMListSGTrivialComputation(); 
  Chars getFileOfNonTrivial() const 
  const SMListData& getTrivialData() const 
  void takeControl( );    
  void start( ) 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SMListSGTrivialARCer arcer;
};

@
\subsubsection{class SMListExtractTrivialSubgroups}
<<class SMListExtractTrivialSubgroups>>=
class SMListExtractTrivialSubgroups  : public Supervisor
{
public:
  SMListExtractTrivialSubgroups( SMList<Subgroup>& );
  ~SMListExtractTrivialSubgroups() 
  void viewStructure(ostream& ostr) const;
  void takeControl( );  
  SMList<Subgroup>& getList() 
  void start( ); 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  MirrorSubordinate abelianInvariants;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
  MirrorSubordinate normalClosure;
  Subordinate<SMListExtractTrivialSubgroups,
              SMListSGTrivialComputation> checker;
};

@
\subsubsection{class SMListSGAbelianARCer}
<<class SMListSGAbelianARCer>>=
class SMListSGAbelianARCer : public ARCer
{
public:
  SMListSGAbelianARCer( ComputationManager& boss );
  void setArguments( SMList<Subgroup>*);
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i ) 
  Chars getFileOfNonAbelian() const 
  const SMListData& getAbelianData() const 
private:
  SMListIterator<Subgroup>* theIterator;
  const class SMFPGroup* theGroup;
  class SMList<Subgroup>* theList;
  File fileOfNonAbelian;
  SMListData abelianData;
  int tCounter;
  int ntCounter;
};

@
\subsubsection{class SMListSGAbelianComputation}
<<class SMListSGAbelianComputation>>=
class SMListSGAbelianComputation  : public ComputationManager
{
public:
  SMListSGAbelianComputation( class SMListExtractAbelianSubgroups& );
  ~SMListSGAbelianComputation(); 
  Chars getFileOfNonAbelian() const 
  const SMListData& getAbelianData() const 
  void takeControl( );  
  void start( ) 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SMListSGAbelianARCer arcer;
};

@
\subsubsection{class SMListExtractAbelianSubgroups}
<<class SMListExtractAbelianSubgroups>>=
class SMListExtractAbelianSubgroups  : public Supervisor
{
public:
  SMListExtractAbelianSubgroups( SMList<Subgroup>& );
  ~SMListExtractAbelianSubgroups() 
  void viewStructure(ostream& ostr) const;
  void takeControl( );   
  SMList<Subgroup>& getList() 
  void start( ); 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  MirrorSubordinate abelianInvariants;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
  MirrorSubordinate normalClosure;
  Subordinate<SMListExtractAbelianSubgroups,
              SMListSGAbelianComputation> checker;
};

@
\subsubsection{class SMListSGCentralARCer}
<<class SMListSGCentralARCer>>=
class SMListSGCentralARCer : public ARCer
{
public:
  SMListSGCentralARCer( ComputationManager& boss );
  void setArguments( SMList<Subgroup>*);
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i ) 
  Chars getFileOfNonCentral() const 
  const SMListData& getCentralData() const 
private:
  SMListIterator<Subgroup>* theIterator;
  const class SMFPGroup* theGroup;
  class SMList<Subgroup>* theList;
  File fileOfNonCentral;
  SMListData centralData;
  int tCounter;
  int ntCounter;
};

@
\subsubsection{class SMListSGCentralComputation}
<<class SMListSGCentralComputation>>=
class SMListSGCentralComputation  : public ComputationManager
{
public:
  SMListSGCentralComputation( class SMListExtractCentralSubgroups& );
  ~SMListSGCentralComputation(); 
  Chars getFileOfNonCentral() const 
  const SMListData& getCentralData() const 
  void takeControl( );  
  void start( ) 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SMListSGCentralARCer arcer;
};

@
\subsubsection{class SMListExtractCentralSubgroups}
<<class SMListExtractCentralSubgroups>>=
class SMListExtractCentralSubgroups  : public Supervisor
{
public:
  SMListExtractCentralSubgroups( SMList<Subgroup>& );
  ~SMListExtractCentralSubgroups() 
  void viewStructure(ostream& ostr) const; 
  void takeControl( );  
  SMList<Subgroup>& getList() 
  void start( ); 
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  MirrorSubordinate abelianInvariants;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
  MirrorSubordinate normalClosure;
  Subordinate<SMListExtractCentralSubgroups,
              SMListSGCentralComputation> checker;
};

@
\subsection{Enumerators/include/SMListWordProblem.h}
<<SMListWordProblem.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "SMList.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "OutMessages.h"
#include "RandomNumbers.h"
#include "ListProblems.h"
#include "SMListIterator.h"

<<class SMListGeneticWPArcer>>
<<class SMListGeneticWPCM>>
<<class SMListWPCheckARCer>>
<<class SMListWPCheckComputation>>
<<class SMListWPPrinResultArcer>>
<<class SMListExtractTrivialWords>>
<<class SMListWordIsCentralARCer>>
<<class SMListWordIsCentralComputation>>
<<class SMListExtractCentralWords>>

@
\subsubsection{class SMListGeneticWPArcer}
<<class SMListGeneticWPArcer>>=
class SMListGeneticWPArcer : public ARCer
{
public:
  SMListGeneticWPArcer( ComputationManager& );
  ~SMListGeneticWPArcer( ) 
  void setArguments( SMList<Word>* );
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Word>* theIterator;
  SMList<Word>* theList;
};

@
\subsubsection{class SMListGeneticWPCM}
<<class SMListGeneticWPCM>>=
class SMListGeneticWPCM : public ComputationManager
{
public:
  SMListGeneticWPCM( class SMListSupervisor& sms );
  void takeControl( ); 
  void start( );       
  void terminate( );   
private:
  SMListGeneticWPArcer arcer;
};

@
\subsubsection{class SMListWPCheckARCer}
<<class SMListWPCheckARCer>>=
class SMListWPCheckARCer : public ARCer
{
public:
  SMListWPCheckARCer( ComputationManager& boss ) 
    : ARCer( boss ), theIterator( NULL ), theGroup( NULL ) 
  void setArguments( SMList<Word>*, const SMFPGroup*  );
  void runComputation( );
  void writeResults( ostream& ) 
  void readResults( istream& ) 
private:
  SMListIterator<Word>* theIterator;
  const class SMFPGroup* theGroup;
  class SMList<Word>* theList;
};

@
\subsubsection{class SMListWPCheckComputation}
<<class SMListWPCheckComputation>>=
class SMListWPCheckComputation  : public ComputationManager
{
public:
  SMListWPCheckComputation( SMListSupervisor& );
  ~SMListWPCheckComputation(); 
  void takeControl( );  
  void start( ) 
  void terminate( ) 
private:
  SMList<Word>& theList;
  bool started;
  SMListWPCheckARCer arcer;
};

@
\subsubsection{class SMListWPPrinResultArcer}
<<class SMListWPPrinResultArcer>>=
class SMListWPPrinResultArcer : public ARCer
{
public:
  SMListWPPrinResultArcer( ComputationManager& b) :
    ARCer( b ), theList( NULL ) 
  ~SMListWPPrinResultArcer( ) 
  void setArguments( SMList<Word>* );
  Chars getFileOfNonTrivial() const 
  const SMListData& getTrivialData() const 
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i ) 
private:
  SMList<Word>* theList;
  File fileOfNonTrivial;
  SMListData trivialData;
};

@
\subsubsection{class SMListExtractTrivialWords}
<<class SMListExtractTrivialWords>>=
class SMListExtractTrivialWords  : public SMListSupervisor
{
public:
  SMListExtractTrivialWords( SMList<Word>& );
  ~SMListExtractTrivialWords() 
  void viewStructure(ostream& ostr) const; 
  void takeControl( );   
  bool finished( );
  void start( ); 
  void terminate( ) 
private:
  MirrorSubordinate abelianInvariants;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
  MirrorSubordinate normalClosure;
  Subordinate<SMListExtractTrivialWords, SMListGeneticWPCM> genetic;
  Subordinate<SMListExtractTrivialWords, SMListWPCheckComputation> checker;
  SMListWPPrinResultArcer arcer;
};

@
\subsubsection{class SMListWordIsCentralARCer}
<<class SMListWordIsCentralARCer>>=
class SMListWordIsCentralARCer : public ARCer
{
public:
  SMListWordIsCentralARCer( ComputationManager& boss );
  void setArguments( SMList<Word>*);
  void runComputation( );
  void writeResults( ostream& o ) 
  void readResults( istream& i ) 
  Chars getFileOfNonCentral() const 
  const SMListData& getCentralData() const 
private:
  SMListIterator<Word>* theIterator;
  const class SMFPGroup* theGroup;
  class SMList<Word>* theList;
  File fileOfNonCentral;
  SMListData centralData;
  int tCounter;
  int ntCounter;
};

@
\subsubsection{class SMListWordIsCentralComputation}
<<class SMListWordIsCentralComputation>>=
class SMListWordIsCentralComputation  : public ComputationManager
{
public:
  SMListWordIsCentralComputation( class SMListExtractCentralWords& );
  ~SMListWordIsCentralComputation(); 
  Chars getFileOfNonCentral() const 
  const SMListData& getCentralData() const 
  void takeControl( ); 
  void start( ) 
  void terminate( ) 
private:
  SMList<Word>& theList;
  bool started;
  SMListWordIsCentralARCer arcer;
};

@
\subsubsection{class SMListExtractCentralWords}
<<class SMListExtractCentralWords>>=
class SMListExtractCentralWords  : public Supervisor
{
public:
  SMListExtractCentralWords( SMList<Word>& );
  ~SMListExtractCentralWords() 
  void viewStructure(ostream& ostr) const;
  void takeControl( );    
  SMList<Word>& getList() 
  void start( ); 
  void terminate( ) 
private:
  SMList<Word>& theList;
  MirrorSubordinate abelianInvariants;
  MirrorSubordinate kbSupervisor;
  MirrorSubordinate agSupervisor;
  MirrorSubordinate normalClosure;
  Subordinate<SMListExtractCentralWords,
              SMListWordIsCentralComputation> checker;
};

@
\subsection{Enumerators/include/SubgroupEnumerator.h}
<<SubgroupEnumerator.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "SMList.h"
#include "Subgroup.h"
#include "SMFPGroup.h"
#include "OutMessages.h"
#include "RandomNumbers.h"
#include "SMListIterator.h" 

<<class SGEnumeratorARCer>>
<<class SGEnumeratorProblem>>
<<class IsSubgroupInListARCer>>
<<class IsSubgroupInList>>
<<class SGListExtractOfIndexARCer>>
<<class SGListExtractOfIndex>>

@
\subsubsection{class SGEnumeratorARCer}
<<class SGEnumeratorARCer>>=
class SGEnumeratorARCer : public EnumeratorARCer
{
public:
  SGEnumeratorARCer( ComputationManager& boss,SMListData& d, SMFPGroup& g ) 
    : EnumeratorARCer( boss, d ), group(g), numberOfAll(100),
    enumerateAll( true ), isNormalRandom( false ), numberOfGenerators(1),
    maxLength(100),  counter(0) 
  void setEnumerateAll() 
  void setEnumerateRandom() 
  void setNormalRandom() 
  void setUniformRandom() 
  void setTotalNumber(int n) 
  void setMaxLength(int n) 
  void setNumberOfGens( int n) 
  void writeResults( ostream& ostr ) 
  void readResults( istream& istr) 
protected:
  void enumerate();
private:
  void enumerateAllSubgroups( );
  Word getRandomWord() ;
  SMFPGroup& group;
  FreeGroup theGroup;
  bool enumerateAll;
  bool isNormalRandom;
  int numberOfGenerators;
  int numberOfAll;
  int maxLength;
  int counter;
  UniformRandom ur; 
  NormalRandom nr; 
};

@
\subsubsection{class SGEnumeratorProblem}
<<class SGEnumeratorProblem>>=
class SGEnumeratorProblem : public EnumeratorProblem< Subgroup >
{
public:
  SGEnumeratorProblem(SMFPGroup& );
  void viewStructure(ostream& ostr) const;  
  void takeControl( );   
  void start( ) ;        
  void terminate( ) 
  void resume( );        
private:
  SMFPGroup& theGroup;
  SGEnumeratorARCer arcer;
};

@
\subsubsection{class IsSubgroupInListARCer}
<<class IsSubgroupInListARCer>>=
class IsSubgroupInListARCer : public ARCer
{
public:
  IsSubgroupInListARCer( ComputationManager& boss ) 
  : ARCer( boss ), result(0) 
  ~IsSubgroupInListARCer( ) 
  void setArguments( const SMList<Subgroup>&, const VectorOf<Word>&);
  bool isInList();
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Subgroup>* theIterator;
  VectorOf<Word> theSubgroup;
  bool result;
};

@
\subsubsection{class IsSubgroupInList}
<<class IsSubgroupInList>>=
class IsSubgroupInList  : public Supervisor
{
public:
  IsSubgroupInList( SMList<Subgroup>&, const class SMSubgroup& );
  void viewStructure(ostream& ostr) const;
  void takeControl( );   
  void start( ) 
  void terminate( ) 
private:
  const class SMSubgroup& theSubgroup;
  SMList<Subgroup>& theList;
  IsSubgroupInListARCer arcer;
};

@
\subsubsection{class SGListExtractOfIndexARCer}
<<class SGListExtractOfIndexARCer>>=
class SGListExtractOfIndexARCer : public ARCer
{
public:
  SGListExtractOfIndexARCer( ComputationManager& boss ) 
    : ARCer( boss ), minIndex( 1 ),  maxIndex( 0 ) 
  ~SGListExtractOfIndexARCer( ) 
  void setArguments( const SMList<Subgroup>&);
  const SMListData& getData() const 
  void setMinimalIndex(int  min ) 
  void setMaximalIndex(int  max ) 
  int indexInFreeGroup( const VectorOf<Word>& s )const;
  int indexInFPGroup( const VectorOf<Word>& s )const; 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Subgroup>* theIterator;
  SMListData theData;
  const SMFPGroup* theGroup;
  int minIndex; 
  int maxIndex;
};

@
\subsubsection{class SGListExtractOfIndex}
<<class SGListExtractOfIndex>>=
class SGListExtractOfIndex  : public Supervisor
{
public:
  SGListExtractOfIndex( SMList<Subgroup>& );
  void viewStructure(ostream& ostr) const;
  void takeControl( ); 
  void start( );       
  void terminate( ) 
private:
  SMList<Subgroup>& theList;
  bool started;
  SGListExtractOfIndexARCer arcer;
};

@
\subsection{Enumerators/include/WEnumerator.h}
<<WEnumerator.h>>=
#include "Supervisor.h"
#include "SMEnumerator.h"
#include "SMList.h"
#include "File.h"
#include "Word.h"
#include "SMFPGroup.h"
#include "OutMessages.h"
#include "RandomNumbers.h"
#include "ListProblems.h"
#include "SMListIterator.h"

<<class WordEnumeratorARCer>>
<<class WordEnumeratorProblem>>
<<class IsWordInListARCer>>
<<class IsWordInList>>
<<class WordsOfLengthARCer>>
<<class WordsOfLength>>

@
\subsubsection{class WordEnumeratorARCer}
<<class WordEnumeratorARCer>>=
class WordEnumeratorARCer : public EnumeratorARCer
{
public:
  WordEnumeratorARCer( ComputationManager& boss, SMListData& d, SMFPGroup& g ) 
    : EnumeratorARCer( boss, d ), group(g), numberOfAll(100),
    enumerateAll( true ), isNormalRandom( false ), numberOfsampleGenerators(1),
    maxLength(100), counter(0) 
  void setEnumerateAll() 
  void setEnumerateRandom() 
  void setNormalRandom() 
  void setUniformRandom() 
  void setTotalNumber(int n) 
  void setMaxLength(int n) 
  void setSample(Word w) 
  void writeResults( ostream& ostr ) 
  void readResults( istream& istr) 
protected:
  void enumerate();
private:
  void enumerateAllWords( );
  Word getRandomWord() ;
  SMFPGroup& group;
  FreeGroup theGroup;
  bool enumerateAll;
  bool isNormalRandom;
  int numberOfsampleGenerators;
  int numberOfAll;
  int maxLength;
  int counter;
  Word theSample;
  UniformRandom ur; 
  NormalRandom nr; 
};

@
\subsubsection{class WordEnumeratorProblem}
<<class WordEnumeratorProblem>>=
class WordEnumeratorProblem : public EnumeratorProblem< Word >
{
public:
  WordEnumeratorProblem(SMFPGroup& );
  void viewStructure(ostream& ostr) const;
  void takeControl( );  
  void start( ) ;       
  void terminate( ) 
  void resume( );       
private:
  SMFPGroup& theGroup;
  WordEnumeratorARCer arcer;
};

@
\subsubsection{class IsWordInListARCer}
<<class IsWordInListARCer>>=
class IsWordInListARCer : public ARCer
{
public:
  IsWordInListARCer( ComputationManager& boss ) : ARCer( boss ), result(0) 
  ~IsWordInListARCer( ) 
  void setArguments( const SMList<Word>&, const Word&);
  bool isInList();
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Word>* theIterator;
  Word theWord;
  bool result;
};

@
\subsubsection{class IsWordInList}
<<class IsWordInList>>=
class IsWordInList  : public Supervisor
{
public:
  IsWordInList( SMList<Word>&, const class SMWord& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );  
  void start( ) 
  void terminate( ) 
private:
  const class SMWord& theWord;
  SMList<Word>& theList;
  IsWordInListARCer arcer;
};

@
\subsubsection{class WordsOfLengthARCer}
<<class WordsOfLengthARCer>>=
class WordsOfLengthARCer : public ARCer
{
public:
  WordsOfLengthARCer( ComputationManager& boss ) 
    : ARCer( boss ),  minLength( 1 ), maxLength( 30000 ) 
  ~WordsOfLengthARCer( ) 
  void setArguments( const SMList<Word>&);
  const SMListData& getData() const 
  void setMinimalLength(int  min ) 
  void setMaximalLength(int  max ) 
  void runComputation( );
  void writeResults( ostream& );
  void readResults( istream& );
private:
  SMListIterator<Word>* theIterator;
  int minLength;
  int maxLength;
  SMListData theData;
  FPGroup theGroup;
};

@
\subsubsection{class WordsOfLength}
<<class WordsOfLength>>=
class WordsOfLength  : public Supervisor
{
public:
  WordsOfLength( SMList<Word>& );
  void viewStructure(ostream& ostr) const; 
  void takeControl( );     
  void start( ); 
  void terminate( ) 
private:
  SMList<Word>& theList;
  bool started;
  WordsOfLengthARCer arcer;
};

@
\section{The Equations classes}
\subsection{Equations/include/DGESolver.h}
<<DGESolver.h>>=
#include "FreeGroup.h"

<<class DGESolver>>

@
\subsubsection{class DGESolver}
<<class DGESolver>>=
class DGESolver
{
public:
  DGESolver( FreeGroup F, VectorOf<Chars> vNames, Word eq );
  ~DGESolver( );
  bool getSolution( const Word& u, Map& solution );
private:
  void defineRange( int curVar );
  bool pickNextValue( int curVar );
  bool findInverseOf( Word u, int p, int q, int& first, int& last );
  struct VarInfo 
  FreeGroup theGroup;
  VectorOf<Chars> varNames;
  int numOfVars, numOfConsts;
  Word equation, w;
  int wLen, eqLen;
  VarInfo *varInfo;    
  VarInfo *invVarInfo; 
  VectorOf<int> buffer;
  VectorOf<int> invVarPos; 
};

@
\subsection{Equations/include/NielsenTransformations.h}
<<NielsenTransformations.h>>=
#include "Set.h"
#include "List.h"
#include "Word.h"
#include "Automorphism.h"

<<class ElementaryRegularAuto>>
<<class RegularAuto>>
<<class ElementarySingularEndo>>
<<class SingularEndo>>

inline bool operator!=(const ElementaryRegularAuto& u, 
                       const ElementaryRegularAuto& w) 
inline Word operator | (Word& w, ElementaryRegularAuto& era) 
inline Word operator | (const Word& w, const RegularAuto& ra)
inline RegularAuto operator | (const RegularAuto& ra1, const RegularAuto& ra2)
inline Word operator | (const Word& w, const ElementarySingularEndo& ese) 
inline Word operator | (const Word& w, const SingularEndo& se) 
inline ostream& operator <<(ostream& o, const ElementaryRegularAuto& era) 
inline ostream& operator <<(ostream& o, const RegularAuto& ra) 
inline ostream& operator <<(ostream& o, const ElementarySingularEndo& era) 
inline ostream& operator <<(ostream& o, const SingularEndo& ra) 

@
\subsubsection{class ElementaryRegularAuto}
<<class ElementaryRegularAuto>>=
class ElementaryRegularAuto
{
  Generator g, g1, g2;
public:
  ElementaryRegularAuto(const Generator& x, const Generator& y)
    : g(x), g1(x), g2(y) 
  Generator x() const 
  Generator y() const 
  inline friend bool operator==(const ElementaryRegularAuto& u, 
        const ElementaryRegularAuto& w) 
  ElementaryRegularAuto inv() const 
  Word imageOf(const Word& w) const 
  Word operator()(const Word& w) const
};

@
\subsubsection{class RegularAuto}
<<class RegularAuto>>=
class RegularAuto
{
  ListOf<ElementaryRegularAuto> autoList;
public:
  RegularAuto() 
  RegularAuto(const ElementaryRegularAuto& a) : autoList(a) 
  RegularAuto(const ListOf<ElementaryRegularAuto>& list) : autoList(list) 
  ListOf<ElementaryRegularAuto> getAutoList() const 
  RegularAuto inv() const 
  Word imageOf(const Word& w) const 
  inline friend bool operator==(const RegularAuto& u, const RegularAuto& w)
  Automorphism makeAutomorphism(const FGGroup& G) const 
};

@
\subsubsection{class ElementarySingularEndo}
<<class ElementarySingularEndo>>=
class ElementarySingularEndo
{
public:
  Generator g;
  ElementarySingularEndo(const Generator& G) : g(abs(ord(G))) 
  Generator gen() const 
  Word imageOf(const Word& w) const 
  inline friend bool operator==(const ElementarySingularEndo& u, 
        const ElementarySingularEndo& w) 
};

@
\subsubsection{class SingularEndo}
<<class SingularEndo>>=
class SingularEndo
{
  SetOf<Generator> genSet;
public:
  SingularEndo() 
  SingularEndo(const ElementarySingularEndo& ese) : genSet(ese.gen()) 
  SingularEndo(const SetOf<Generator>& set) : genSet(set) 
  SetOf<Generator> generators() const 
  bool isSpecializationOf(const SingularEndo& second) const 
  friend SingularEndo operator | (const SingularEndo& se1, 
          const SingularEndo& se2) 
  Word imageOf(const Word& w) const 
  Endomorphism makeEndomorphism(const FGGroup& G) const 
  inline friend bool operator==(const SingularEndo& u, const SingularEndo& w) 
};

@
\subsection{Equations/include/QEqnSolutions.h}
<<QEqnSolutions.h>>=
#include "Word.h"
#include "Vector.h"
#include "Queue.h"
#include "VectorPtr.h"
#include "QuickAssociations.h"
#include "NielsenTransformations.h"

<<class QEqnSolutionsInFreeGroup>>
<<template <class T> VectorPtrOf<T> makeVectorPtrOf>>

Chars  checkEquation(const FreeGroup& G, const Word& equation, int numOfVar);

@
\subsubsection{class QEqnSolutionsInFreeGroup}
<<class QEqnSolutionsInFreeGroup>>=
class QEqnSolutionsInFreeGroup
{
public:
  QEqnSolutionsInFreeGroup(const FreeGroup& G, const Word& equation, 
                           int numOfVar);
  void startComputation();
  void continueComputation();
  void disableBuildingRegStab() 
  void enableBuildingRegStab() 
  void disableBuildingSolutions() 
  void enableBuildingSolutions() 
  bool isComputationDone() const 
  bool isComputationStarted() const 
  bool haveNewSolution() const 
  bool nextSolution() 
  bool haveNewStabGenerator() const 
  bool nextStabGenerator() 
  bool isBuildingSolutionsEnabled() const 
  bool isBuildingRegStabEnabled() const 
  Endomorphism getSolution() 
  Automorphism getStabGenerator() 
  Word surfaceForm() 
  Automorphism toSurfaceForm() 
  FreeGroup group() const 
  Word equation() const 
  int numberOfVariables() const 
  int numberOfGenerators() const 
  int numberOfConstants() const 
  int rank() const 
  VectorPtrOf<Endomorphism> basicSolutions() const 
  VectorPtrOf<Automorphism> regStabGenerators() const 
  Automorphism prefixMap() const 
  struct EquationStatus; 
  EquationStatus getProcessStatus() const 
  Endomorphism eliminator() const 
  friend ostream& operator << ( ostream&, const QEqnSolutionsInFreeGroup& );

<<struct EquationStatus>>

private:
  Bool isVariable(const Generator& g) const 
  bool isConstant(const Generator& g) const 
  void buildNewVerticesAndLoopsFrom(const Word& vertex);
  RegularAuto buildPath(const Word& from, const Word& to);
  RegularAuto buildPathTo(const Word& to);
  void registerEdge(const Word& source, const ElementaryRegularAuto& edge, 
        const Word& target);
  void buildSolutionsOfOneVertex(const Word& w);
  VectorOf<int> checkProperties(const Word& w);
  ListOf<SingularEndo> buildSingulars(const Word& w, 
                                      const VectorOf<int>& varProperties);
  void appendNewSolution(ListOf<SingularEndo>& solutions, 
       const SingularEndo& newSolution);
  int rankOfBasicSolution(const Endomorphism& solution) const;
  void processOneLoop(const Edge& edge);
  void computeSurfaceForm();
  Word extractSquare(Word& w, int firstLocation, int secondLocation);
  Word extractPinch(Word& w, int firstLocation,  int secondLocation);
  Word extractCommutator(Word& w, int xFirstLocation,  int xSecondLocation, 
       int yFirstLocation);
  int getLocationOfArbitraryVariable(const Word& w, int start, int stop) const;
  int getPairOfVariable(Word& w, int& firstLocation, int& secondLocation, 
      bool oppositeOrder) const;
  Word bringToCanonicForm(Word& squares, Word& commutators, Word constants, 
        Word& pinches);
  Word theEquation;  
  int theNumberOfGenerators;
  int theNumberOfVariables;
  FreeGroup theGroup; 
  VectorPtrOf<Automorphism> theRegStabGenerators;
  VectorPtrOf<Endomorphism> theBasicSolutions;
  int theRank;
  Word theSurfaceForm; 
  Automorphism toSurface; 
  bool computationIsStarted;
  bool computationIsDone;
  int solution; 
  int generator; 
  Endomorphism theEliminator;

<<struct Edge>>

  Automorphism startPath;
  Automorphism invStartPath;
  Word root;
  QuickAssociationsOf<Word, ElementaryRegularAuto> maxSubTree;
  QueueOf<Word> newVertices; 
  QueueOf<Edge> loops; 
  Endomorphism removeVarEndo;
  SetOf<Endomorphism> setOfBasicSolutions; 
  enum { MUST_BE_MAPPED_TO_ITSELF,
   MUST_BE_MAPPED_TO_1,
   CAN_BE_MAPPED_TO_1
  };
  int tempRank;
  SetOf<Automorphism> regStabSet;
  bool surfaceFormIsComputed;
  EquationStatus status;
};

@
\subsubsection{struct EquationStatus}
<<struct EquationStatus>>=
struct EquationStatus
{
  EquationStatus() : enableBuildingSolutions(true), 
    enableBuildingRegStab(true), verticesToPass(0), verticesPassed(0), 
    loopsToPass(0), loopsPassed(0), totalLengthOfLoops(0) 
    bool enableBuildingSolutions;
    bool enableBuildingRegStab;
    int verticesToPass;
    int verticesPassed;
    int loopsToPass;
    int loopsPassed;
    long totalLengthOfLoops;
};

\subsubsection{struct Edge}
<<struct Edge>>=
struct Edge 
{
  Word vertex;
  ElementaryRegularAuto edge;
  Edge() : edge(1,2) 
  Edge(const Word& w, const ElementaryRegularAuto& e) : vertex(w), edge(e) 
  friend inline bool operator ==(const Edge& x, const Edge& y) 
  friend ostream& operator <<( ostream& o, const Edge& E);
  int hash() const 
};

@
\subsubsection{template <class T> VectorPtrOf<T> makeVectorPtrOf}
<<template <class T> VectorPtrOf<T> makeVectorPtrOf>>=
template <class T> VectorPtrOf<T> makeVectorPtrOf(const SetOf<T>& S)

@
\subsection{Equations/include/Queue.h}
<<Queue.h>>=
#include "ObjectOf.h"
#include "List.h"

<<template < class T > class QueueOf>>

@
\subsubsection{template < class T > class QueueOf}
<<template < class T > class QueueOf>>=
template < class T > class QueueOf : public ListOf<T> 
{
public:
  QueueOf( ) : ListOf<T>() 
  QueueOf( const T& t ) : ListOf<T>(t) 
  void push( const T& t );
  T pop( ) 
  void popAll( ) 
  Bool isEmpty( ) const 
  Bool isntEmpty( ) const 
};

@
\subsection{Equations/include/SolutionsEnum.h}
<<SolutionsEnum.h>>=
#include "QEqnSolutions.h"
#include "TupleEnumerator.h"
#include "RandomNumbers.h"

<<class QEqnSolutionsEnumerator>>
const int randomSolutionsThreshold = 500;
<<class GeneratorOfRandomSolutions>>

@
\subsubsection{class QEqnSolutionsEnumerator}
<<class QEqnSolutionsEnumerator>>=
class QEqnSolutionsEnumerator
{
public:
  QEqnSolutionsEnumerator(const QEqnSolutionsInFreeGroup& equation);
  Endomorphism getSolution() const 
  bool nextSolution();
  bool done() const 
  void reset();
private:
  bool areBasicSolutionsParametrized();
  Word theEquation;     
  int theNumberOfGenerators;
  int theNumberOfVariables;
  FreeGroup theGroup; 
  VectorPtrOf<Automorphism> theRegStabGenerators;
  VectorPtrOf<Automorphism> theRegStabInvGenerators;
  VectorPtrOf<Endomorphism> theBasicSolutions;
  Automorphism prefixAuto; 
  bool allSolutionsAreEnumerated;
  Trichotomy numberOfSolutionsIsFinite;
  Endomorphism solution;
  Automorphism stabAuto;
  int currentBasicSolution;
  Endomorphism specEndo;
  EnumeratorOfWordTuples tuplesEnumerator;
  VectorOf<bool> invGensComputed;
};

@
\subsubsection{class GeneratorOfRandomSolutions}
<<class GeneratorOfRandomSolutions>>=
class GeneratorOfRandomSolutions 
{
public:
  GeneratorOfRandomSolutions( const FreeGroup& group, const Word& equation, 
            int numberOfVariables );
  void setBasicSolutions( const VectorPtrOf<Endomorphism>& newBasicSolutions )
  void setRegStabGenerators( const VectorPtrOf<Automorphism>& newGenerators )
  void setThreshold( int newThreshold ) 
  bool hasSolutions() const;
  bool generateSolution();
  Endomorphism getSolution() const 
  int getThreshold( ) const 
  int getCurrentThreshold( ) const 
  const VectorPtrOf<Endomorphism>& getBasicSolutions( ) const 
  const VectorPtrOf<Automorphism>& getRegStabGenerators(  ) const 
protected:
  void generateSomeSolution();
private:
  FreeGroup theGroup;
  int numOfVar;
  int numOfGen;
  VectorPtrOf<Endomorphism> basicSolutions;
  VectorPtrOf<Automorphism> regStabGenerators;
  VectorPtrOf<Automorphism> regStabGeneratorsInv;
  SetOf<Endomorphism> solutionSet;
  Endomorphism solution;
  int threshold;
  UniformRandom rnd;
  Endomorphism variablesEliminator;
};
  
@
\subsection{Equations/include/TupleEnumerator.h}
<<TupleEnumerator.h>>=
#include "Vector.h"
#include "Word.h"

<<class EnumeratorOfWordTuples>>
<<class CantorEnumeration>>

@
\subsubsection{class EnumeratorOfWordTuples}
<<class EnumeratorOfWordTuples>>=
class EnumeratorOfWordTuples
{
public:
  EnumeratorOfWordTuples(VectorOf<int> numOfGens) :
    tupleSize(numOfGens.length()), tuple(numOfGens.length()),
    maxWord(numOfGens.length()), numberOfGens(numOfGens),
    fixedWord(0) 
  EnumeratorOfWordTuples(int size, int numOfGens) :
    tupleSize(size), tuple(size), maxWord(size),
    numberOfGens(size), fixedWord(0)
  void reset() 
  void next();
  VectorOf<Word> value() const 
private:
  int tupleSize;
  VectorOf<Word> tuple;
  VectorOf<Word> maxWord;
  VectorOf<int>  numberOfGens;
  int fixedWord;
};

@
\subsubsection{class CantorEnumeration}
<<class CantorEnumeration>>=
class CantorEnumeration 
{
public:
  static Integer encodePair( const Integer& x, const Integer& y);
  static void decodePair( const Integer& n, Integer& x, Integer& y );
  static Integer encodeTuple( const VectorOf<Integer>& tuple );
  static VectorOf<Integer> decodeTuple( const Integer& number );
};

@
\subsection{Equations/include/VectorPtr.h}
<<VectorPtr.h>>=
#include "RefCounter.h"
#include "ObjectOf.h"

<<template < class T > class VectorItemRef>>
<<template <class T> struct VectorPtrRep>>
<<template <class T> class VectorPtrOf>>
<<template < class T > class VectorItemRef>>

@
\subsubsection{template < class T > class VectorItemRef}
<<template < class T > class VectorItemRef>>=
template < class T > class VectorItemRef;

@
\subsubsection{template <class T> struct VectorPtrRep}
<<template <class T> struct VectorPtrRep>>=
template <class T> struct VectorPtrRep : public RefCounter 
{
public :
  VectorPtrRep( const VectorPtrRep& vr ) 
  VectorPtrRep( int l ) 
  VectorPtrRep( int l, bool e ) 
  ~VectorPtrRep( ) 
  VectorPtrRep* clone( ) 
  int length() const 
  bool isValid(int i) const 
  void set(int i, const T& t) 
  T& ref(int i) 
  T val(int i) const 
  VectorItemRef<T> operator [] ( int i ) 
  void append( const T& t ) 
  void prepend( const T& t ) 
  void shrink( int start, int newlen ) 
private :
  VectorPtrRep& operator = ( const VectorPtrRep& );
  bool fastExpansion; 
  unsigned int first; 
  unsigned int last;  
  unsigned int len;   
  T** vec;
};

@
\subsubsection{template <class T> class VectorPtrOf}
<<template <class T> class VectorPtrOf>>=
template <class T> class VectorPtrOf : public ObjectOf< VectorPtrRep<T> > 
{
  typedef VectorPtrRep< T > Rep;
  typedef ObjectOf< Rep > Base;
public:
  VectorPtrOf( int len = 0 ) : Base( new Rep(len) ) 
  VectorPtrOf( int len, bool e ) : Base( new Rep(len,e) ) 
  VectorPtrOf( int len, const VectorPtrOf& v ) : Base( new Rep(len) ) 
  VectorPtrOf( int len, bool e, const VectorPtrOf& v ) : Base( new Rep(len,e))
  bool operator == ( const VectorPtrOf& v ) const
  bool operator != ( const VectorPtrOf& v ) const 
  T operator [] ( int i ) const 
  VectorItemRef<T> operator [] ( int i ) 
  T val( int i ) const 
  T& ref( int i ) 
  bool isValid( int i ) const   
  int length( ) const 
  int hash() const 
  int indexOf( const T& t ) const 
  void append( const T& t ) 
  void prepend( const T& t ) 
  void shrink( int newLength ) 
  void shrink( int start, int newLength )
  inline friend ostream& operator << ( ostream& o, const VectorPtrOf& v ) 
private:
};

@
\subsubsection{template < class T > class VectorItemRef}
<<template < class T > class VectorItemRef>>=
template < class T > class VectorItemRef 
{
public:
  T& operator = ( const T& t ) 
  bool operator == ( const T& t ) 
  operator T( ) 
private:
  friend class VectorPtrRep<T>; 
  VectorItemRef( T* p) : elPoint(p) 
  VectorItemRef( T** addr, T* p) : elPoint(0), elAddr(addr) 
  T* elPoint;
  T** elAddr;
private:
  VectorItemRef& operator = ( const VectorItemRef& ref );
public: 
  VectorItemRef( const VectorItemRef& ref )
};

@
\subsection{Equations/include/VertexInfo.h}
<<VertexInfo.h>>=
#include "Word.h"
#include "NielsenTransformations.h"

<<struct VertexInfo>>

@
\subsubsection{struct VertexInfo}
<<struct VertexInfo>>=
struct VertexInfo 
{
  VertexInfo(const Word& w, int i, const SingularEndo& se) :
    word(w), lastVar(i), eliminator(se) 
  friend inline bool operator==(const VertexInfo& x, const VertexInfo& y) 
  friend inline ostream& operator<<(ostream& o, const VertexInfo& x) 
  Word word;
  int lastVar;
  SingularEndo eliminator;
};

@
\section{The FSA classes}
\subsection{FSA/include/DFSA.h}
<<DFSA.h>>=
#include "FSA.h"
#include "DFSARep.h"

<<class DFSA>>
<<class GroupDFSA>>

@
\subsubsection{class DFSA}
<<class DFSA>>=
class DFSA : public FSA {
typedef DFSARep::State State;
public:
  DFSA( ) : FSA( new DFSARep() ) 

  DFSA(const VectorOf<Chars> & genNames) : FSA( new DFSARep("",genNames) ) 

  DFSA(Chars name,const VectorOf<Chars> & genNames) 
     : FSA( new DFSARep(name,genNames) ) 

  DFSA( const VectorOf<Chars> & genNames, int numOfStates) 
     : FSA( new DFSARep("",genNames, numOfStates,1) ) 

  DFSA( const Chars & Name, const VectorOf<Chars> & genNames, int numOfStates) 
     : FSA( new DFSARep(Name, genNames, numOfStates,1) ) 

  DFSA( const VectorOf<Chars> & genNames, int numOfStates, int numOfStrings) 
     : FSA( new DFSARep("", genNames, numOfStates, numOfStrings ) ) 

  DFSA( const Chars & Name, const VectorOf<Chars> & genNames, int numOfStates, int numOfStrings) 
     : FSA( new DFSARep(Name, genNames, numOfStates, numOfStrings ) ) 

  State target(State s,Generator g) const 
  int getNumStates() const 

protected:
  DFSA( DFSARep * rep ) : FSA((FSARep *)rep) 
  const DFSARep *look() const 
  DFSARep *change() 
};

@
\subsubsection{class GroupDFSA}
<<class GroupDFSA>>=
class Gro