Regina Calculation Engine
|
Represents a homomorphism between groups which are described via finite presentations. More...
#include <algebra/homgrouppresentation.h>
Public Member Functions | |
HomGroupPresentation (const GroupPresentation &domain, const GroupPresentation &range, const std::vector< GroupExpression > &map) | |
Creates a new homomorphism from the given data. More... | |
HomGroupPresentation (const GroupPresentation &domain, const GroupPresentation &range, const std::vector< GroupExpression > &map, const std::vector< GroupExpression > &inv) | |
Creates a declared isomorphism from the given data. More... | |
HomGroupPresentation (const GroupPresentation &groupForIdentity) | |
Creates a new identity homomorphism for the given group. More... | |
HomGroupPresentation (const HomGroupPresentation &cloneMe) | |
Creates a clone of the given group presentation. More... | |
~HomGroupPresentation () | |
Destroys the group homomorphism. More... | |
const GroupPresentation & | domain () const |
The domain of the map. More... | |
const GroupPresentation & | range () const |
The range of the map. More... | |
bool | knowsInverse () const |
Returns whether or not this is a declared isomorphism. More... | |
GroupExpression | evaluate (const GroupExpression &arg) const |
Evaluate the homomorphism at an element of the domain. More... | |
GroupExpression | evaluate (unsigned long i) const |
Evaluate the homomorphism at a generator of the domain. More... | |
GroupExpression | invEvaluate (const GroupExpression &arg) const |
Evaluate the isomorphisms's inverse at an element of the range. More... | |
GroupExpression | invEvaluate (unsigned long i) const |
Evaluate the isomorphism at a generator of the range. More... | |
bool | intelligentSimplify () |
Simultaneously simplifies: More... | |
bool | intelligentNielsen () |
Simplifies the domain and range using only Nielsen moves, keeping track of the resulting map in the progress. More... | |
bool | smallCancellation () |
Simplifies the domain and range using only small cancellation theory. More... | |
std::unique_ptr< HomGroupPresentation > | composeWith (const HomGroupPresentation &input) const |
Composes this homomorphism with the given input homomorphism. More... | |
bool | invert () |
Inverts the homomorphism. More... | |
bool | verify () const |
Verifies the map is a valid homomorphism. More... | |
bool | verifyIsomorphism () const |
Attempts to verify that a declared isomorphism is, indeed, an isomorphism. More... | |
std::unique_ptr< HomMarkedAbelianGroup > | markedAbelianisation () const |
Computes the induced map on the abelianizations of the domain and range. More... | |
void | writeTextShort (std::ostream &out) const |
Writes a short text representation of this object to the given output stream. More... | |
void | writeTextLong (std::ostream &out) const |
Writes a detailed text representation of this object to the given output stream. More... | |
std::string | str () const |
Returns a short text representation of this object. More... | |
std::string | utf8 () const |
Returns a short text representation of this object using unicode characters. More... | |
std::string | detail () const |
Returns a detailed text representation of this object. More... | |
Represents a homomorphism between groups which are described via finite presentations.
Some homomorphisms may be declared isomorphisms. This means that the user (or some other function in Regina) has proven that this is an isomorphism and has explicitly provided the inverse map. To provide the inverse map, you should call the four-argument constructor HomGroupPresentation(const GroupPresentation&, const GroupPresentation&, const std::vector<GroupExpression>&, const std::vector<GroupExpression>&).
You can test for a declared isomorphism by calling knowsInverse(). Even if a homomorphism is not a declared isomorphism, it might still be an isomorphism; this just means that no inverse map was explicitly provided.
|
inline |
Creates a new homomorphism from the given data.
domain | the domain of the homomorphism. |
range | the range of the homomorphism. |
map | a vector of length g, where g is the number of generators of the domain, and where this homomorphism sends the ith generator of the domain to the element map[i] of the range. |
|
inline |
Creates a declared isomorphism from the given data.
Here you must provide both a map from the domain to range, and the inverse map from the range to domain.
domain | the domain of the homomorphism. |
range | the range of the homomorphism. |
map | a vector of length g, where g is the number of generators of the domain, and where this homomorphism sends the ith generator of the domain to the element map[i] of the range. |
inv | a vector of length k where k is the number of generators of the range, and where the inverse homomorphism sends the ith generator of the range to the element inv[i] of the domain. |
regina::HomGroupPresentation::HomGroupPresentation | ( | const GroupPresentation & | groupForIdentity | ) |
Creates a new identity homomorphism for the given group.
This will be a declared isomorphism (see the HomGroupPresentation class notes for details).
groupForIdentity | both the range and domain of the new identity homomorphism. |
|
inline |
Creates a clone of the given group presentation.
cloneMe | the presentation to clone. |
|
inline |
Destroys the group homomorphism.
std::unique_ptr<HomGroupPresentation> regina::HomGroupPresentation::composeWith | ( | const HomGroupPresentation & | input | ) | const |
Composes this homomorphism with the given input homomorphism.
Evaluating the composition on some group element x is the same as evaluating this(input(x))
. In other words, in this composition, input is evaluated first and then the output of that is evaluated by this homomorphism.
If both of the given homomorphisms are declared isomorphisms, then the return value will be a declared isomoprhism also.
input | the homomorphism to compose with this. |
|
inherited |
Returns a detailed text representation of this object.
This text may span many lines, and should provide the user with all the information they could want. It should be human-readable, should not contain extremely long lines (which cause problems for users reading the output in a terminal), and should end with a final newline. There are no restrictions on the underlying character set.
|
inline |
The domain of the map.
GroupExpression regina::HomGroupPresentation::evaluate | ( | const GroupExpression & | arg | ) | const |
Evaluate the homomorphism at an element of the domain.
arg | an element of the domain. |
|
inline |
Evaluate the homomorphism at a generator of the domain.
i | the index of a generator in the domain. |
bool regina::HomGroupPresentation::intelligentNielsen | ( | ) |
Simplifies the domain and range using only Nielsen moves, keeping track of the resulting map in the progress.
true
if and only if either presentation was changed. bool regina::HomGroupPresentation::intelligentSimplify | ( | ) |
Simultaneously simplifies:
Uses the underlying GroupPresentation::intelligentSimplify(). See that routine for details.
true
if the presentations or map have changed. bool regina::HomGroupPresentation::invert | ( | ) |
Inverts the homomorphism.
This is only possible if the homomorphism is in fact a declared isomorphism (which means that the inverse map is already stored internally). See the HomGroupPresentation class notes for further details on declared isomorphisms.
If this is not a declared isomorphism then this routine will do nothing and simply return false
.
This operation is (very) fast constant time.
true
if and only if the inversion operation was successful (i.e., if this is a declared isomorphism). GroupExpression regina::HomGroupPresentation::invEvaluate | ( | const GroupExpression & | arg | ) | const |
Evaluate the isomorphisms's inverse at an element of the range.
arg | an element of the range. |
|
inline |
Evaluate the isomorphism at a generator of the range.
i | the index of a generator in the range. |
|
inline |
Returns whether or not this is a declared isomorphism.
A declared isomorphism is a isomorphism for which the user has explicitly provided the inverse map. See the HomGroupPresentation class notes for details.
true
if and only if this is a declared isomorphism, i.e, the inverse map was explicitly provided. std::unique_ptr< HomMarkedAbelianGroup > regina::HomGroupPresentation::markedAbelianisation | ( | ) | const |
Computes the induced map on the abelianizations of the domain and range.
|
inline |
The range of the map.
bool regina::HomGroupPresentation::smallCancellation | ( | ) |
Simplifies the domain and range using only small cancellation theory.
true
if and only if either presentation was changed.
|
inherited |
Returns a short text representation of this object.
This text should be human-readable, should fit on a single line, and should not end with a newline. Where possible, it should use plain ASCII characters.
__str__()
.
|
inherited |
Returns a short text representation of this object using unicode characters.
Like str(), this text should be human-readable, should fit on a single line, and should not end with a newline. In addition, it may use unicode characters to make the output more pleasant to read. This string will be encoded in UTF-8.
bool regina::HomGroupPresentation::verify | ( | ) | const |
Verifies the map is a valid homomorphism.
Specifically, this routine runs through all the relators in the domain, evaluates the homomorphism on the relators and checks that they simplify to 1 in the range.
This routine does not guarantee a conclusive result (since the word problem is, in general, undecidable). If this routine returns true
then this proves that the homomorphism is indeed valid. If this routine returns false
, then the result is inconclusive (i.e., it might still be valid but Regina was not able to prove this).
This routine is intended for sanity checking only: any homomorphism that you construct in Regina should always be valid in this sense.
true
if Regina is able to verify that this is a homomorphism, or false
if the result is inconclusive. bool regina::HomGroupPresentation::verifyIsomorphism | ( | ) | const |
Attempts to verify that a declared isomorphism is, indeed, an isomorphism.
This routine works by attempting to verify that f^-1(f(x))x^-1
simplifes to 1 for all generators x in the domain, and likewise for the range.
This routine does not guarantee a conclusive result. If this routine returns true
then this proves that this is indeed an isomorphism. If this routine returns false
then the result is inconclusive (i.e., it might still be an isomorphism but Regina was not able to prove this).
You probably only want to run this on good presentations for small cancellation theory - an automorphism of a poorly-presented group likely will not be noticed.
This routine is intended for sanity checking only: any homomorphism that you construct as a declared isomorphism should always be an isomorphism.
true
if it is verified that this is an isomorphism, or false
if the result is inconclusive. void regina::HomGroupPresentation::writeTextLong | ( | std::ostream & | out | ) | const |
Writes a detailed text representation of this object to the given output stream.
out | the output stream to which to write. |
void regina::HomGroupPresentation::writeTextShort | ( | std::ostream & | out | ) | const |
Writes a short text representation of this object to the given output stream.
out | the output stream to which to write. |