Represents a homomorphism of finitely generated abelian groups.
One initializes such a homomorphism by providing:
- two finitely generated abelian groups, which act as domain and range;
- a matrix describing the linear map between the free abelian groups in the centres of the respective chain complexes that were used to define the domain and range. If the abelian groups are computed via homology with coefficients, the range coefficients must be a quotient of the domain coefficients.
So for example, if the domain was initialized by the chain complex Z^a –A–> Z^b –B–> Z^c
with mod p coefficients, and the range was initialized by Z^d –D–> Z^e –E–> Z^f
with mod q coefficients, then the matrix needs to be an e-by-b matrix. Furthermore, you only obtain a well-defined homomorphism if this matrix extends to a cycle map, which this class assumes but which the user can confirm with isCycleMap(). Moreover, q should divide p: this allows for q > 0 and p = 0, which means the domain has Z coefficients and the range has mod q coefficients.
- Todo:
- Optimise (long-term): preImageOf in CC and SNF coordinates. This routine would return a generating list of elements in the preimage, thought of as an affine subspace. Or maybe just one element together with the kernel inclusion. IMO smarter to be a list because that way there's a more pleasant way to make it empty. Or we could have a variety of routines among these themes. Store some minimal data for efficient computations of preImage, eventually replacing the internals of inverseHom() with a more flexible set of tools. Also add an isInImage() in various coordinates.
- Todo:
- Optimise (long-term): writeTextShort() have completely different set of descriptors if an endomorphism domain = range (not so important at the moment though). New descriptors would include things like automorphism, projection, differential, finite order, etc.
- Todo:
- Optimise (long-term): Add map factorization, so that every homomorphism can be split as a composite of a projection followed by an inclusion. Add kernelInclusion(), coKerMap(), etc. Add a liftMap() call, i.e., a procedure to find a lift of a map if one exists.
- Author:
- Ryan Budney
Constructs a homomorphism from two marked abelian groups and a matrix that indicates where the generators are sent.
The roles of the two groups and the matrix are described in detail in the NHomMarkedAbelianGroup class overview.
The matrix must be given in the chain-complex coordinates. Specifically, if the domain was defined via the chain complex Z^a –N1–> Z^b –M1–> Z^c
and the range was defined via Z^d –N2–> Z^e –M2–> Z^f
, then mat is an e-by-b matrix that describes a homomorphism from Z^b to Z^e.
In order for this to make sense as a homomorphism of the groups represented by the domain and range respectively, one requires img(mat*N1) to be a subset of img(N2). Similarly, ker(M1) must be sent into ker(M2). These facts are not checked, but are assumed as preconditions of this constructor.
- Precondition:
- The matrix mat has the required dimensions e-by-b, gives img(mat*N1) as a subset of img(N2), and sends ker(M1) into ker(M2), as explained in the detailed notes above.
- Parameters:
-
dom | the domain group. |
ran | the range group. |
mat | the matrix that describes the homomorphism from dom to ran. |
Returns the inverse to an NHomMarkedAbelianGroup.
If this homomorphism is not invertible, this routine returns the zero homomorphism.
If you are computing with mod-p coefficients, this routine will further require that this invertible map preserves the UCT splitting of the group, i.e., it gives an isomorphism of the tensor product parts and the TOR parts. At present this suffices since we're only using this to construct maps between homology groups in different coordinate systems.
- Returns:
- the inverse homomorphism, or the zero homomorphism if this is not invertible.
Determines whether this and the given homomorphism together form a chain map.
Given two NHomMarkedAbelianGroups, you have two diagrams:
Z^a –N1–> Z^b –M1–> Z^c Z^g –N3–> Z^h –M3–> Z^i
^ ^
|this.matrix |other.matrix
Z^d –N2–> Z^e –M2–> Z^f Z^j –N4–> Z^k –M4–> Z^l
If c=g and f=j and M1=N3 and M2=N4, you can ask if these maps commute, i.e., whether you have a map of chain complexes.
- Parameters:
-
other | the other homomorphism to analyse in conjunction with this. |
- Returns:
- true if and only if c=g, M1=N3, f=j, M2=N4, and the diagram commutes.
bool regina::NHomMarkedAbelianGroup::isCycleMap |
( |
| ) |
const |
Is this at least a cycle map? If not, pretty much any further computations you try with this class will be give you nothing more than carefully-crafted garbage.
Technically, this routine only checks that cycles are sent to cycles, since it only has access to three of the four maps you need to verify you have a cycle map.
- Returns:
true
if and only if this is a chain map.