1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// Copyright (C) 1995 The New York Group Theory Cooperative
// See magnus/doc/COPYRIGHT for the full notice.
// Contents: Definition of the Automorphism and AutomorphismRep class.
//
// Principal Authors: Eugene Paderin, Dmitry Pechkin
//
// Status: in progress
//
// Revision History:
//
// Special Notes:
//
// * The class is primarily designed and used for solving
// quadratic equations (in free groups).
//
// * The class methods need advanced consistency checking and
// more manipulation with Map properties.
//
#ifndef _AUTOMORPHISM_H_
#define _AUTOMORPHISM_H_
#include "Endomorphism.h"
#include "FreeGroup.h"
//---------------------- Automorphism ---------------------------//
class Automorphism : public Endomorphism {
public:
////////////////////////////////////////////////////////////////////
// //
// Constructors //
// //
////////////////////////////////////////////////////////////////////
Automorphism( const FGGroup& dom) : Endomorphism(dom) { makeIdentity(); }
// make trivial Automorphism on given group
Automorphism( const FGGroup& dom, const VectorOf<Word>& generatingImages )
: Endomorphism(dom,generatingImages) { }
// an Automorphism with explicit generatingImages
Automorphism(FGGroup& dom, Generator x, Word& w) : Endomorphism(dom)
{
makeIdentity();
setGeneratingImages(x,w);
}
// maps x to w, the others to themselves
Automorphism(FGGroup& dom, Word& w) : Endomorphism(dom)
{
for(int i=0; i< dom.numberOfGenerators(); i++) {
Word x = Generator(i+1);
setGeneratingImages(i, x.conjugateBy(w));
}
}
// An `inner' endomorphism, i.e., x -> x^w for all generators x.
Automorphism( const Map& m ) : Endomorphism(m) {}
// cast construtor: to cast an arbitrary map as an automorphism.
// NB. This rewraps the unchanged representation, hence is in general
// only useful for casting a map known to be an actual automorphism.
// copy constructor, operator=, and destructor supplied by compiler
////////////////////////////////////////////////////////////////////
// //
// Accessors / Modifiers //
// //
////////////////////////////////////////////////////////////////////
// inherited from the base class
// const FGGroup& domain( ) const;
// const FGGroup& range( ) const;
// const VectorOf<Word>& generatingImages( ) const;
// Word generatingImages( int i ) const;
// void setGeneratingImages( const VectorOf<Word>& gi );
// void setGeneratingImages( int i, const Word& e );
// void setDomain( const FGGroup& g );
// void setRange( const FGGroup& g );
// void makeIdentity()
// void reduceGenImages();
////////////////////////////////////////////////////////////////////
// //
// Mapping methods //
// //
////////////////////////////////////////////////////////////////////
// inherited from the base class
// friend CondParamLvalue<Map,Word,Generator>::operator Word ( ) const;
// friend Word& CondParamLvalue<Map,Word,Generator>::operator =( const Word& ) const;
// Word imageOf( const Word& w ) const;
// Word imageOf( const Generator& g ) const;
// CondParamLvalue<Map,Word,Generator> imageOf( const Generator& g );
// Word operator()( const Word& w ) const;
// Word operator()( const Generator& g ) const;
// CondParamLvalue<Map,Word,Generator> operator()( const Generator& g );
// computing images:
// Elt evalImage( const Word& w ) const;
// Elt postEvalImage( const Word& w ) const;
// operations on maps:
// Map& composeAfter( const Map& firstMap );
// Map operator | ( const Map& secondEndo )
Automorphism inverse() const {
#if SAFETY > 0
if( domain().actualType() != FreeGroup::type() )
error("Automorphism::inverse() supported for "
"automorphism of a free group only");
#endif
const VectorOf<Word>& images = look()->theGeneratingImages;
return Automorphism(domain(), ((const FreeGroup&)domain()).inverseAutomorphism(images) );
}
////////////////////////////////////////////////////////////////////
// //
// Mapping properties //
// //
////////////////////////////////////////////////////////////////////
// inherited from the base class:
// Trichotomy extendsToHom( ) const;
// Trichotomy isMono( ) const;
// Trichotomy isEpi( ) const;
// Trichotomy isIso( ) const;
// Trichotomy isTrivialMap( ) const; // @stc impl. tmp.
////////////////////////////////////////////////////////////////////
// //
// Debugging stuff //
// //
////////////////////////////////////////////////////////////////////
#ifdef DEBUG
//friend int main( );
bool consistent( ) {
const VectorOf<Word>& images = look()->theGeneratingImages;
return Endomorphism::consistent() &&
((const FreeGroup&)domain()).isAutomorphism(images);
}
#endif
};
#endif
|
