GAP (CAP) - Chapter 3: Morphisms

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

3 Morphisms
3.1 Attributes for the Type of Morphisms
3.1-1 CapCategory
3.1-2 Source
3.1-3 Range
3.2 Categorical Properties of Morphisms
3.2-1 IsMonomorphism
3.2-2 AddIsMonomorphism
3.2-3 IsEpimorphism
3.2-4 AddIsEpimorphism
3.2-5 IsIsomorphism
3.2-6 AddIsIsomorphism
3.2-7 IsSplitMonomorphism
3.2-8 AddIsSplitMonomorphism
3.2-9 IsSplitEpimorphism
3.2-10 AddIsSplitEpimorphism
3.2-11 IsOne
3.2-12 AddIsOne
3.2-13 IsIdempotent
3.2-14 AddIsIdempotent
3.3 Random Morphisms
3.3-1 RandomMorphismWithFixedSourceByInteger
3.3-2 AddRandomMorphismWithFixedSourceByInteger
3.3-3 RandomMorphismWithFixedSourceByList
3.3-4 AddRandomMorphismWithFixedSourceByList
3.3-5 RandomMorphismWithFixedRangeByInteger
3.3-6 AddRandomMorphismWithFixedRangeByInteger
3.3-7 RandomMorphismWithFixedRangeByList
3.3-8 AddRandomMorphismWithFixedRangeByList
3.3-9 RandomMorphismWithFixedSourceAndRangeByInteger
3.3-10 AddRandomMorphismWithFixedSourceAndRangeByInteger
3.3-11 RandomMorphismWithFixedSourceAndRangeByList
3.3-12 AddRandomMorphismWithFixedSourceAndRangeByList
3.3-13 RandomMorphismByInteger
3.3-14 AddRandomMorphismByInteger
3.3-15 RandomMorphismByList
3.3-16 AddRandomMorphismByList
3.3-17 RandomMorphismWithFixedSource
3.4 Non-Categorical Properties of Morphisms
3.4-1 IsIdenticalToIdentityMorphism
3.4-2 AddIsIdenticalToIdentityMorphism
3.4-3 IsIdenticalToZeroMorphism
3.4-4 AddIsIdenticalToZeroMorphism
3.4-5 IsEndomorphism
3.4-6 AddIsEndomorphism
3.4-7 IsAutomorphism
3.4-8 AddIsAutomorphism
3.5 Adding Morphisms to a Category
3.5-1 Add
3.5-2 AddMorphism
3.5-3 AddMorphismRepresentation
3.5-4 ObjectifyMorphismWithSourceAndRangeForCAPWithAttributes
3.6 Equality and Congruence for Morphisms
3.6-1 IsCongruentForMorphisms
3.6-2 AddIsCongruentForMorphisms
3.6-3 IsEqualForMorphisms
3.6-4 AddIsEqualForMorphisms
3.6-5 IsEqualForMorphismsOnMor
3.6-6 AddIsEqualForMorphismsOnMor
3.7 Basic Operations for Morphisms in Ab-Categories
3.7-1 IsZeroForMorphisms
3.7-2 AddIsZeroForMorphisms
3.7-3 AdditionForMorphisms
3.7-4 AddAdditionForMorphisms
3.7-5 SubtractionForMorphisms
3.7-6 AddSubtractionForMorphisms
3.7-7 AdditiveInverseForMorphisms
3.7-8 AddAdditiveInverseForMorphisms
3.7-9 MultiplyWithElementOfCommutativeRingForMorphisms
`3.7-10 \*`
3.7-11 AddMultiplyWithElementOfCommutativeRingForMorphisms
3.7-12 ZeroMorphism
3.7-13 AddZeroMorphism
3.8 Subobject and Factorobject Operations
3.8-1 IsEqualAsSubobjects
3.8-2 AddIsEqualAsSubobjects
3.8-3 IsEqualAsFactorobjects
3.8-4 AddIsEqualAsFactorobjects
3.8-5 IsDominating
3.8-6 AddIsDominating
3.8-7 IsCodominating
3.8-8 AddIsCodominating
3.9 Identity Morphism and Composition of Morphisms
3.9-1 IdentityMorphism
3.9-2 AddIdentityMorphism
3.9-3 PreCompose
3.9-4 PreCompose
3.9-5 AddPreCompose
3.9-6 PostCompose
3.9-7 PostCompose
3.9-8 AddPostCompose
3.10 Well-Definedness of Morphisms
3.10-1 IsWellDefinedForMorphisms
3.10-2 AddIsWellDefinedForMorphisms
3.11 Lift/Colift
3.11-1 LiftAlongMonomorphism
3.11-2 AddLiftAlongMonomorphism
3.11-3 ColiftAlongEpimorphism
3.11-4 AddColiftAlongEpimorphism
3.11-5 IsLiftableAlongMonomorphism
3.11-6 AddIsLiftableAlongMonomorphism
3.11-7 IsColiftableAlongEpimorphism
3.11-8 AddIsColiftableAlongEpimorphism
3.11-9 Lift
3.11-10 AddLift
3.11-11 Colift
3.11-12 AddColift
3.11-13 IsLiftable
3.11-14 AddIsLiftable
3.11-15 IsColiftable
3.11-16 AddIsColiftable
3.12 Inverses
3.12-1 Inverse
3.12-2 AddInverse
3.13 Tool functions for caches
3.13-1 IsEqualForCacheForMorphisms
3.13-2 AddIsEqualForCacheForMorphisms
3.14 IsHomSetInhabited
3.14-1 IsHomSetInhabited
3.14-2 AddIsHomSetInhabited
3.15 Homomorphism structures
3.15-1 HomomorphismStructureOnObjects
3.15-2 AddHomomorphismStructureOnObjects
3.15-3 HomomorphismStructureOnMorphisms
3.15-4 HomomorphismStructureOnMorphismsWithGivenObjects
3.15-5 AddHomomorphismStructureOnMorphismsWithGivenObjects
3.15-6 DistinguishedObjectOfHomomorphismStructure
3.15-7 AddDistinguishedObjectOfHomomorphismStructure
3.15-8 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure
3.15-9 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure
3.15-10 InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
3.15-11 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
3.15-12 SolveLinearSystemInAbCategory
3.15-13 MereExistenceOfSolutionOfLinearSystemInAbCategory
3.15-14 HomStructure
3.15-15 HomStructure
3.15-16 HomStructure
3.15-17 HomStructure
3.15-18 HomStructure
3.15-19 HomStructure
3.15-20 HomStructure
3.15-21 BasisOfExternalHom
3.15-22 AddBasisOfExternalHom
3.15-23 CoefficientsOfMorphismWithGivenBasisOfExternalHom
3.15-24 AddCoefficientsOfMorphismWithGivenBasisOfExternalHom
3.15-25 CoefficientsOfMorphism
3.16 Simplified Morphisms
3.16-1 SimplifyMorphism
3.16-2 AddSimplifyMorphism
3.16-3 SimplifySource
3.16-4 AddSimplifySource
3.16-5 SimplifySource_IsoToInputObject
3.16-6 AddSimplifySource_IsoToInputObject
3.16-7 SimplifySource_IsoFromInputObject
3.16-8 AddSimplifySource_IsoFromInputObject
3.16-9 SimplifyRange
3.16-10 AddSimplifyRange
3.16-11 SimplifyRange_IsoToInputObject
3.16-12 AddSimplifyRange_IsoToInputObject
3.16-13 SimplifyRange_IsoFromInputObject
3.16-14 AddSimplifyRange_IsoFromInputObject
3.16-15 SimplifySourceAndRange
3.16-16 AddSimplifySourceAndRange
3.16-17 SimplifySourceAndRange_IsoToInputRange
3.16-18 AddSimplifySourceAndRange_IsoToInputRange
3.16-19 SimplifySourceAndRange_IsoFromInputRange
3.16-20 AddSimplifySourceAndRange_IsoFromInputRange
3.16-21 SimplifySourceAndRange_IsoToInputSource
3.16-22 AddSimplifySourceAndRange_IsoToInputSource
3.16-23 SimplifySourceAndRange_IsoFromInputSource
3.16-24 AddSimplifySourceAndRange_IsoFromInputSource
3.16-25 SimplifyEndo
3.16-26 AddSimplifyEndo
3.16-27 SimplifyEndo_IsoToInputObject
3.16-28 AddSimplifyEndo_IsoToInputObject
3.16-29 SimplifyEndo_IsoFromInputObject
3.16-30 AddSimplifyEndo_IsoFromInputObject
3.16-31 Simplify
3.17 Reduction by split epi summands
3.17-1 SomeReductionBySplitEpiSummand
3.17-2 AddSomeReductionBySplitEpiSummand
3.17-3 SomeReductionBySplitEpiSummand_MorphismToInputRange
3.17-4 AddSomeReductionBySplitEpiSummand_MorphismToInputRange
3.17-5 SomeReductionBySplitEpiSummand_MorphismFromInputRange
3.17-6 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange

### 3 Morphisms

Any GAP object satisfying `IsCapCategoryMorphism` can be added to a category and then becomes a morphism in this category. Any morphism can belong to one or no category. After a GAP object is added to the category, it knows which things can be computed in its category and to which category it belongs. It knows categorical properties and attributes, and the functions for existential quantifiers can be applied to the morphism.

#### 3.1 Attributes for the Type of Morphisms

##### 3.1-1 CapCategory

`‣ CapCategory`( alpha ) | ( attribute )

Returns: a category

The argument is a morphism \alpha. The output is the category \mathbf{C} to which \alpha was added.

##### 3.1-2 Source

`‣ Source`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha: a \rightarrow b. The output is its source a.

##### 3.1-3 Range

`‣ Range`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha: a \rightarrow b. The output is its range b.

#### 3.2 Categorical Properties of Morphisms

##### 3.2-1 IsMonomorphism

`‣ IsMonomorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is a monomorphism, otherwise the output is `false`.

##### 3.2-2 AddIsMonomorphism

`‣ AddIsMonomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsMonomorphism`. F: \alpha \mapsto \mathtt{IsMonomorphism}(\alpha).

##### 3.2-3 IsEpimorphism

`‣ IsEpimorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is an epimorphism, otherwise the output is `false`.

##### 3.2-4 AddIsEpimorphism

`‣ AddIsEpimorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEpimorphism`. F: \alpha \mapsto \mathtt{IsEpimorphism}(\alpha).

##### 3.2-5 IsIsomorphism

`‣ IsIsomorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is an isomorphism, otherwise the output is `false`.

##### 3.2-6 AddIsIsomorphism

`‣ AddIsIsomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIsomorphism`. F: \alpha \mapsto \mathtt{IsIsomorphism}(\alpha).

##### 3.2-7 IsSplitMonomorphism

`‣ IsSplitMonomorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is a split monomorphism, otherwise the output is `false`.

##### 3.2-8 AddIsSplitMonomorphism

`‣ AddIsSplitMonomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsSplitMonomorphism`. F: \alpha \mapsto \mathtt{IsSplitMonomorphism}(\alpha).

##### 3.2-9 IsSplitEpimorphism

`‣ IsSplitEpimorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is a split epimorphism, otherwise the output is `false`.

##### 3.2-10 AddIsSplitEpimorphism

`‣ AddIsSplitEpimorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsSplitEpimorphism`. F: \alpha \mapsto \mathtt{IsSplitEpimorphism}(\alpha).

##### 3.2-11 IsOne

`‣ IsOne`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha: a \rightarrow a. The output is `true` if \alpha is congruent to the identity of a, otherwise the output is `false`.

##### 3.2-12 AddIsOne

`‣ AddIsOne`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsOne`. F: \alpha \mapsto \mathtt{IsOne}(\alpha).

##### 3.2-13 IsIdempotent

`‣ IsIdempotent`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha: a \rightarrow a. The output is `true` if \alpha^2 \sim_{a,a} \alpha, otherwise the output is `false`.

##### 3.2-14 AddIsIdempotent

`‣ AddIsIdempotent`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIdempotent`. F: \alpha \mapsto \mathtt{IsIdempotent}(\alpha).

#### 3.3 Random Morphisms

CAP provides two principal methods to generate random morphisms with or without fixed source and range:

- By integers: The integer is simply a parameter that can be used to create a random morphism.

- By lists: The list is used when creating a random morphism would need more than one parameter. Lists offer more flexibility at the expense of the genericity of the methods. This happens because lists that are valid as input in some category may be not valid for other categories. Hence, these operations are not thought to be used in generic categorical algorithms.

##### 3.3-1 RandomMorphismWithFixedSourceByInteger

`‣ RandomMorphismWithFixedSourceByInteger`( a, n ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

The arguments are an object a in a category C and an integer n. The output is a random morphism \alpha: a \rightarrow b for some object b in C or `fail`.

##### 3.3-2 AddRandomMorphismWithFixedSourceByInteger

`‣ AddRandomMorphismWithFixedSourceByInteger`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceByInteger`. The function F maps (a,n) to `fail` or to a random morphism in C whose source is a.

##### 3.3-3 RandomMorphismWithFixedSourceByList

`‣ RandomMorphismWithFixedSourceByList`( a, L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

The arguments are an object a in a category C and a list L. The output is a random morphism \alpha: a \rightarrow b for some object b in C or `fail`.

##### 3.3-4 AddRandomMorphismWithFixedSourceByList

`‣ AddRandomMorphismWithFixedSourceByList`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceByList`. The function F maps (a,L) to `fail` or to a random morphism in C whose source is a.

##### 3.3-5 RandomMorphismWithFixedRangeByInteger

`‣ RandomMorphismWithFixedRangeByInteger`( b, n ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

The arguments are an object b in a category C and an integer n. The output is a random morphism \alpha: a \rightarrow b for some object a in C or `fail`.

##### 3.3-6 AddRandomMorphismWithFixedRangeByInteger

`‣ AddRandomMorphismWithFixedRangeByInteger`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedRangeByInteger`. The function F maps (b,n) to `fail` or to a random morphism in C whose range is b.

##### 3.3-7 RandomMorphismWithFixedRangeByList

`‣ RandomMorphismWithFixedRangeByList`( b, L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

The arguments are an object b in a category C and a list L. The output is a random morphism \alpha: a \rightarrow b for some object a in C or `fail`.

##### 3.3-8 AddRandomMorphismWithFixedRangeByList

`‣ AddRandomMorphismWithFixedRangeByList`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedRangeByList`. The function F maps (b,L) to `fail` or to a random morphism in C whose range is b.

##### 3.3-9 RandomMorphismWithFixedSourceAndRangeByInteger

`‣ RandomMorphismWithFixedSourceAndRangeByInteger`( a, b, n ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

The arguments are two objects a and b in a category C and an integer n. The output is a random morphism \alpha: a \rightarrow b in C or `fail`.

##### 3.3-10 AddRandomMorphismWithFixedSourceAndRangeByInteger

`‣ AddRandomMorphismWithFixedSourceAndRangeByInteger`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceAndRangeByInteger`. The function F maps (a,b,n) to `fail` or to a random morphism in C from a to b.

##### 3.3-11 RandomMorphismWithFixedSourceAndRangeByList

`‣ RandomMorphismWithFixedSourceAndRangeByList`( a, b, L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) or `fail`

This operation is not a CAP basic operation The arguments are two objects a and b in a category C and a list L. The output is a random morphism \alpha: a \rightarrow b in C or `fail`.

##### 3.3-12 AddRandomMorphismWithFixedSourceAndRangeByList

`‣ AddRandomMorphismWithFixedSourceAndRangeByList`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceAndRangeByList`. The function F maps (a,b,L) to `fail` or to a random morphism in C from a to b.

##### 3.3-13 RandomMorphismByInteger

`‣ RandomMorphismByInteger`( C, n ) | ( operation )

Returns: a morphism or `fail`

The arguments are a category C and an integer n. The output is a random morphism in C or `fail`. If the methods `RandomObjectByInteger` and `RandomMorphismWithFixedSourceByInteger`(`RandomMorphismWithFixedRangeByInteger`) are added to the category C, then `RandomMorphismByInteger` can be derived to return a random morphism of complexity n with random source(range) of complexity n.

##### 3.3-14 AddRandomMorphismByInteger

`‣ AddRandomMorphismByInteger`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismByInteger`. The function F maps (C,n) to `fail` or to a random morphism in C.

##### 3.3-15 RandomMorphismByList

`‣ RandomMorphismByList`( C, L ) | ( operation )

Returns: a morphism or `fail`

The arguments are a category C and a list L. The output is a random morphism in C or `fail`.

##### 3.3-16 AddRandomMorphismByList

`‣ AddRandomMorphismByList`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismByList`. The function F maps (C,L) to `fail` or to a random morphism in C.

##### 3.3-17 RandomMorphismWithFixedSource

`‣ RandomMorphismWithFixedSource`( a, n ) | ( operation )

`‣ RandomMorphismWithFixedSource`( a, L ) | ( operation )

`‣ RandomMorphismWithFixedRange`( b, n ) | ( operation )

`‣ RandomMorphismWithFixedRange`( b, L ) | ( operation )

`‣ RandomMorphismWithFixedSourceAndRange`( a, b, n ) | ( operation )

`‣ RandomMorphismWithFixedSourceAndRange`( a, b, L ) | ( operation )

`‣ RandomMorphism`( C, n ) | ( operation )

`‣ RandomMorphism`( C, L ) | ( operation )

These are convenient methods and they, depending on the input, delegate to one of the above methods.

#### 3.4 Non-Categorical Properties of Morphisms

Non-categorical properties are not stable under equivalences of categories.

##### 3.4-1 IsIdenticalToIdentityMorphism

`‣ IsIdenticalToIdentityMorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha: a \rightarrow b. The output is `true` if \alpha = \mathrm{id}_a, otherwise the output is `false`.

##### 3.4-2 AddIsIdenticalToIdentityMorphism

`‣ AddIsIdenticalToIdentityMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIdenticalToIdentityMorphism`. F: \alpha \mapsto \mathtt{IsIdenticalToIdentityMorphism}(\alpha).

##### 3.4-3 IsIdenticalToZeroMorphism

`‣ IsIdenticalToZeroMorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha: a \rightarrow b. The output is `true` if \alpha = 0, otherwise the output is `false`.

##### 3.4-4 AddIsIdenticalToZeroMorphism

`‣ AddIsIdenticalToZeroMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIdenticalToZeroMorphism`. F: \alpha \mapsto \mathtt{IsIdenticalToZeroMorphism }(\alpha).

##### 3.4-5 IsEndomorphism

`‣ IsEndomorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is an endomorphism, otherwise the output is `false`.

##### 3.4-6 AddIsEndomorphism

`‣ AddIsEndomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEndomorphism`. F: \alpha \mapsto \mathtt{IsEndomorphism}(\alpha).

##### 3.4-7 IsAutomorphism

`‣ IsAutomorphism`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is an automorphism, otherwise the output is `false`.

##### 3.4-8 AddIsAutomorphism

`‣ AddIsAutomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsAutomorphism`. F: \alpha \mapsto \mathtt{IsAutomorphism}(\alpha).

#### 3.5 Adding Morphisms to a Category

##### 3.5-1 Add

`‣ Add`( category, morphism ) | ( operation )

Adds morphism as a morphism to category.

##### 3.5-2 AddMorphism

`‣ AddMorphism`( category, morphism ) | ( operation )

Adds morphism as a morphism to category. If morphism already lies in the filter `IsCapCategoryMorphism`, the operation `Add` (3.5-1) can be used instead.

##### 3.5-3 AddMorphismRepresentation

`‣ AddMorphismRepresentation`( category, filter ) | ( operation )

The argument filter is used to create a morphism type for the category category, which is then used in `ObjectifyMorphismForCAPWithAttributes` to objectify morphisms for this category.

##### 3.5-4 ObjectifyMorphismWithSourceAndRangeForCAPWithAttributes

`‣ ObjectifyMorphismWithSourceAndRangeForCAPWithAttributes`( morphism, category, source, range[, attr1, val1, attr2, val2, ...] ) | ( function )

Returns: a morphism

Objectifies the morphism morphism with the type created for morphisms in the category category. The type is created by passing a representation to `AddMorphismRepresentation`. Morphisms which are objectified using this method do not have to be passed to the `AddMorphism` function. The arguments `source` and `range` are assumed to be objectified. The optional arguments behave like the corresponding arguments in `ObjectifyWithAttributes`. Also returns the objectified morphism.

#### 3.6 Equality and Congruence for Morphisms

##### 3.6-1 IsCongruentForMorphisms

`‣ IsCongruentForMorphisms`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two morphisms \alpha, \beta: a \rightarrow b. The output is `true` if \alpha \sim_{a,b} \beta, otherwise the output is `false`.

##### 3.6-2 AddIsCongruentForMorphisms

`‣ AddIsCongruentForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsCongruentForMorphisms`. F: (\alpha, \beta) \mapsto \mathtt{IsCongruentForMorphisms}(\alpha, \beta).

##### 3.6-3 IsEqualForMorphisms

`‣ IsEqualForMorphisms`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two morphisms \alpha, \beta: a \rightarrow b. The output is `true` if \alpha = \beta, otherwise the output is `false`.

##### 3.6-4 AddIsEqualForMorphisms

`‣ AddIsEqualForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualForMorphisms`. F: (\alpha, \beta) \mapsto \mathtt{IsEqualForMorphisms}(\alpha, \beta).

##### 3.6-5 IsEqualForMorphismsOnMor

`‣ IsEqualForMorphismsOnMor`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two morphisms \alpha: a \rightarrow b, \beta: c \rightarrow d. The output is `true` if \alpha = \beta, otherwise the output is `false`.

##### 3.6-6 AddIsEqualForMorphismsOnMor

`‣ AddIsEqualForMorphismsOnMor`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualForMorphismsOnMor`. F: (\alpha, \beta) \mapsto \mathtt{IsEqualForMorphismsOnMor}(\alpha, \beta).

#### 3.7 Basic Operations for Morphisms in Ab-Categories

##### 3.7-1 IsZeroForMorphisms

`‣ IsZeroForMorphisms`( alpha ) | ( property )

Returns: a boolean

The argument is a morphism \alpha: a \rightarrow b. The output is `true` if \alpha \sim_{a,b} 0, otherwise the output is `false`.

##### 3.7-2 AddIsZeroForMorphisms

`‣ AddIsZeroForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsZeroForMorphisms`. F: \alpha \mapsto \mathtt{IsZeroForMorphisms}(\alpha).

##### 3.7-3 AdditionForMorphisms

`‣ AdditionForMorphisms`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b)

The arguments are two morphisms \alpha, \beta: a \rightarrow b. The output is the addition \alpha + \beta.

##### 3.7-4 AddAdditionForMorphisms

`‣ AddAdditionForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `AdditionForMorphisms`. F: (\alpha, \beta) \mapsto \alpha + \beta.

##### 3.7-5 SubtractionForMorphisms

`‣ SubtractionForMorphisms`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b)

The arguments are two morphisms \alpha, \beta: a \rightarrow b. The output is the addition \alpha - \beta.

##### 3.7-6 AddSubtractionForMorphisms

`‣ AddSubtractionForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SubtractionForMorphisms`. F: (\alpha, \beta) \mapsto \alpha - \beta.

##### 3.7-7 AdditiveInverseForMorphisms

`‣ AdditiveInverseForMorphisms`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(a,b)

The argument is a morphism \alpha: a \rightarrow b. The output is its additive inverse -\alpha.

##### 3.7-8 AddAdditiveInverseForMorphisms

`‣ AddAdditiveInverseForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `AdditiveInverseForMorphisms`. F: \alpha \mapsto -\alpha.

##### 3.7-9 MultiplyWithElementOfCommutativeRingForMorphisms

`‣ MultiplyWithElementOfCommutativeRingForMorphisms`( r, alpha ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b)

The arguments are an element r of a commutative ring and a morphism \alpha: a \rightarrow b. The output is the multiplication with the ring element r \cdot \alpha.

##### `3.7-10 \*`

`‣ \*`( r, alpha ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b)

This is a convenience method. It has two arguments. The first argument is either a rational number q or an element r of a commutative ring R. The second argument is a morphism \alpha: a \rightarrow b in a linear category over the commutative ring R. In the case where the first element is a rational number, this method tries to interpret q as an element r of R via `R!.interpret_rationals_func`. If no such interpretation exists, this method throws an error. The output is the multiplication with the ring element r \cdot \alpha.

##### 3.7-11 AddMultiplyWithElementOfCommutativeRingForMorphisms

`‣ AddMultiplyWithElementOfCommutativeRingForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `MultiplyWithElementOfCommutativeRingForMorphisms`. F: (r, \alpha) \mapsto r \cdot \alpha.

##### 3.7-12 ZeroMorphism

`‣ ZeroMorphism`( a, b ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b)

The arguments are two objects a and b. The output is the zero morphism 0: a \rightarrow b.

##### 3.7-13 AddZeroMorphism

`‣ AddZeroMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `ZeroMorphism`. F: (a,b) \mapsto (0: a \rightarrow b).

#### 3.8 Subobject and Factorobject Operations

Subobjects of an object c are monomorphisms with range c and a special function for comparision. Similarly, factorobjects of an object c are epimorphisms with source c and a special function for comparision.

##### 3.8-1 IsEqualAsSubobjects

`‣ IsEqualAsSubobjects`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two subobjects \alpha: a \rightarrow c, \beta: b \rightarrow c. The output is `true` if there exists an isomorphism \iota: a \rightarrow b such that \beta \circ \iota \sim_{a,c} \alpha, otherwise the output is `false`.

##### 3.8-2 AddIsEqualAsSubobjects

`‣ AddIsEqualAsSubobjects`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualAsSubobjects`. F: (\alpha, \beta) \mapsto \mathtt{IsEqualAsSubobjects}(\alpha,\beta).

##### 3.8-3 IsEqualAsFactorobjects

`‣ IsEqualAsFactorobjects`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two factorobjects \alpha: c \rightarrow a, \beta: c \rightarrow b. The output is `true` if there exists an isomorphism \iota: b \rightarrow a such that \iota \circ \beta \sim_{c,a} \alpha, otherwise the output is `false`.

##### 3.8-4 AddIsEqualAsFactorobjects

`‣ AddIsEqualAsFactorobjects`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualAsFactorobjects`. F: (\alpha, \beta) \mapsto \mathtt{IsEqualAsFactorobjects}(\alpha,\beta).

##### 3.8-5 IsDominating

`‣ IsDominating`( alpha, beta ) | ( operation )

Returns: a boolean

In short: Returns `true` iff \alpha is smaller than \beta. Full description: The arguments are two subobjects \alpha: a \rightarrow c, \beta: b \rightarrow c. The output is `true` if there exists a morphism \iota: a \rightarrow b such that \beta \circ \iota \sim_{a,c} \alpha, otherwise the output is `false`.

##### 3.8-6 AddIsDominating

`‣ AddIsDominating`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsDominating`. F: (\alpha, \beta) \mapsto \mathtt{IsDominating}(\alpha,\beta).

##### 3.8-7 IsCodominating

`‣ IsCodominating`( alpha, beta ) | ( operation )

Returns: a boolean

In short: Returns `true` iff \alpha is smaller than \beta. Full description: The arguments are two factorobjects \alpha: c \rightarrow a, \beta: c \rightarrow b. The output is `true` if there exists a morphism \iota: b \rightarrow a such that \iota \circ \beta \sim_{c,a} \alpha, otherwise the output is `false`.

##### 3.8-8 AddIsCodominating

`‣ AddIsCodominating`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsCodominating`. F: (\alpha, \beta) \mapsto \mathtt{IsCodominating}(\alpha,\beta).

#### 3.9 Identity Morphism and Composition of Morphisms

##### 3.9-1 IdentityMorphism

`‣ IdentityMorphism`( a ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(a,a)

The argument is an object a. The output is its identity morphism \mathrm{id}_a.

##### 3.9-2 AddIdentityMorphism

`‣ AddIdentityMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IdentityMorphism`. F: a \mapsto \mathrm{id}_a.

##### 3.9-3 PreCompose

`‣ PreCompose`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}( a, c )

The arguments are two morphisms \alpha: a \rightarrow b, \beta: b \rightarrow c. The output is the composition \beta \circ \alpha: a \rightarrow c.

##### 3.9-4 PreCompose

`‣ PreCompose`( L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a_1, a_{n+1})

This is a convenience method. The argument is a list of morphisms L = ( \alpha_1: a_1 \rightarrow a_2, \alpha_2: a_2 \rightarrow a_3, \dots, \alpha_n: a_n \rightarrow a_{n+1} ). The output is the composition \alpha_{n} \circ ( \alpha_{n-1} \circ ( \dots ( \alpha_2 \circ \alpha_1 ) ) ).

##### 3.9-5 AddPreCompose

`‣ AddPreCompose`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `PreCompose`. F: (\alpha, \beta) \mapsto \beta \circ \alpha.

##### 3.9-6 PostCompose

`‣ PostCompose`( beta, alpha ) | ( operation )

Returns: a morphism in \mathrm{Hom}( a, c )

The arguments are two morphisms \beta: b \rightarrow c, \alpha: a \rightarrow b. The output is the composition \beta \circ \alpha: a \rightarrow c.

##### 3.9-7 PostCompose

`‣ PostCompose`( L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a_1, a_{n+1})

This is a convenience method. The argument is a list of morphisms L = ( \alpha_n: a_n \rightarrow a_{n+1}, \alpha_{n-1}: a_{n-1} \rightarrow a_n, \dots, \alpha_1: a_1 \rightarrow a_2 ). The output is the composition ((\alpha_{n} \circ \alpha_{n-1}) \circ \dots \alpha_2) \circ \alpha_1.

##### 3.9-8 AddPostCompose

`‣ AddPostCompose`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `PostCompose`. F: (\alpha, \beta) \mapsto \alpha \circ \beta.

#### 3.10 Well-Definedness of Morphisms

##### 3.10-1 IsWellDefinedForMorphisms

`‣ IsWellDefinedForMorphisms`( alpha ) | ( operation )

Returns: a boolean

The argument is a morphism \alpha. The output is `true` if \alpha is well-defined, otherwise the output is `false`.

##### 3.10-2 AddIsWellDefinedForMorphisms

`‣ AddIsWellDefinedForMorphisms`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsWellDefinedForMorphisms`. F: \alpha \mapsto \mathtt{IsWellDefinedForMorphisms}( \alpha ).

#### 3.11 Lift/Colift

- For any pair of morphisms \alpha: a \rightarrow c, \beta: b \rightarrow c, we call each morphism \alpha / \beta: a \rightarrow b such that \beta \circ (\alpha / \beta) \sim_{a,c} \alpha a lift of \alpha along \beta.

- For any pair of morphisms \alpha: a \rightarrow c, \beta: a \rightarrow b, we call each morphism \alpha \backslash \beta: c \rightarrow b such that (\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta a colift of \beta along \alpha.

Note that such lifts (or colifts) do not have to be unique. So in general, we do not expect that algorithms computing lifts (or colifts) do this in a functorial way. Thus the operations \mathtt{Lift} and \mathtt{Colift} are not regarded as categorical operations, but only as set-theoretic operations.

##### 3.11-1 LiftAlongMonomorphism

`‣ LiftAlongMonomorphism`( iota, tau ) | ( operation )

Returns: a morphism in \mathrm{Hom}(t,k)

The arguments are a monomorphism \iota: k \hookrightarrow a and a morphism \tau: t \rightarrow a such that there is a morphism u: t \rightarrow k with \iota \circ u \sim_{t,a} \tau. The output is such a u.

##### 3.11-2 AddLiftAlongMonomorphism

`‣ AddLiftAlongMonomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `LiftAlongMonomorphism`. The function F maps a pair (\iota, \tau) to a lift u.

##### 3.11-3 ColiftAlongEpimorphism

`‣ ColiftAlongEpimorphism`( epsilon, tau ) | ( operation )

Returns: a morphism in \mathrm{Hom}(c,t)

The arguments are an epimorphism \epsilon: a \rightarrow c and a morphism \tau: a \rightarrow t such that there is a morphism u: c \rightarrow t with u \circ \epsilon \sim_{a,t} \tau. The output is such a u.

##### 3.11-4 AddColiftAlongEpimorphism

`‣ AddColiftAlongEpimorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `ColiftAlongEpimorphism`. The function F maps a pair (\epsilon, \tau) to a lift u.

##### 3.11-5 IsLiftableAlongMonomorphism

`‣ IsLiftableAlongMonomorphism`( iota, tau ) | ( operation )

Returns: a boolean

The arguments are a monomorphism \iota: k \hookrightarrow a and a morphism \tau: t \rightarrow a. The output is `true` if there exists a morphism u: t \rightarrow k with \iota \circ u \sim_{t,a} \tau. Otherwise, the output is `false`.

##### 3.11-6 AddIsLiftableAlongMonomorphism

`‣ AddIsLiftableAlongMonomorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsLiftableAlongMonomorphism`. F: (\iota, \tau) \mapsto \texttt{IsLiftableAlongMonomorphism}( \iota, \tau ).

##### 3.11-7 IsColiftableAlongEpimorphism

`‣ IsColiftableAlongEpimorphism`( epsilon, tau ) | ( operation )

Returns: a boolean

The arguments are an epimorphism \epsilon: a \rightarrow c and a morphism \tau: a \rightarrow t. The output is `true` if there exists a morphism u: c \rightarrow t with u \circ \epsilon \sim_{a,t} \tau. Otherwise, the output is `false`.

##### 3.11-8 AddIsColiftableAlongEpimorphism

`‣ AddIsColiftableAlongEpimorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsColiftableAlongEpimorphism`. F: (\epsilon, \tau) \mapsto \texttt{IsColiftableAlongEpimorphism}( \epsilon, \tau ).

##### 3.11-9 Lift

`‣ Lift`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}(a,b) + \{ \mathtt{fail} \}

The arguments are two morphisms \alpha: a \rightarrow c, \beta: b \rightarrow c. The output is a lift \alpha / \beta: a \rightarrow b of \alpha along \beta if such a lift exists or \mathtt{fail} if it doesn't. Recall that a lift \alpha / \beta: a \rightarrow b of \alpha along \beta is a morphism such that \beta \circ (\alpha / \beta) \sim_{a,c} \alpha.

##### 3.11-10 AddLift

`‣ AddLift`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `Lift`. The function F maps a pair (\alpha, \beta) to a lift \alpha / \beta if it exists, and to `fail` otherwise.

##### 3.11-11 Colift

`‣ Colift`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}(c,b) + \{ \mathtt{fail} \}

The arguments are two morphisms \alpha: a \rightarrow c, \beta: a \rightarrow b. The output is a colift \alpha \backslash \beta: c \rightarrow b of \beta along \alpha if such a colift exists or \mathtt{fail} if it doesn't. Recall that a colift \alpha \backslash \beta: c \rightarrow b of \beta along \alpha is a morphism such that (\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta.

##### 3.11-12 AddColift

`‣ AddColift`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `Colift`. The function F maps a pair (\alpha, \beta) to a colift \alpha \backslash \beta if it exists, and to `fail` otherwise.

##### 3.11-13 IsLiftable

`‣ IsLiftable`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two morphisms \alpha: a \rightarrow c, \beta: b \rightarrow c. The output is `true` if there exists a lift \alpha / \beta: a \rightarrow b of \alpha along \beta, i.e., a morphism such that \beta \circ (\alpha / \beta) \sim_{a,c} \alpha. Otherwise, the output is `false`.

##### 3.11-14 AddIsLiftable

`‣ AddIsLiftable`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsLiftable`. F: ( \alpha, \beta ) \mapsto \mathtt{IsLiftable}( \alpha, \beta ).

##### 3.11-15 IsColiftable

`‣ IsColiftable`( alpha, beta ) | ( operation )

Returns: a boolean

The arguments are two morphisms \alpha: a \rightarrow c, \beta: a \rightarrow b. The output is `true` if there exists a colift \alpha \backslash \beta: c \rightarrow b of \beta along \alpha., i.e., a morphism such that (\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta. Otherwise, the output is `false`.

##### 3.11-16 AddIsColiftable

`‣ AddIsColiftable`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsColiftable`. F: ( \alpha, \beta ) \mapsto \mathtt{IsColiftable}( \alpha, \beta ).

#### 3.12 Inverses

Let \alpha: a \rightarrow b be a morphism. An inverse of \alpha is a morphism \alpha^{-1}: b \rightarrow a such that \alpha \circ \alpha^{-1} \sim_{b,b} \mathrm{id}_b and \alpha^{-1} \circ \alpha \sim_{a,a} \mathrm{id}_a.

##### 3.12-1 Inverse

`‣ Inverse`( alpha ) | ( operation )

Returns: a morphism in \mathrm{Hom}(b,a)

The argument is an isomorphism \alpha: a \rightarrow b. The output is its inverse \alpha^{-1}: b \rightarrow a.

##### 3.12-2 AddInverse

`‣ AddInverse`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `Inverse`. F: \alpha \mapsto \alpha^{-1}.

#### 3.13 Tool functions for caches

##### 3.13-1 IsEqualForCacheForMorphisms

`‣ IsEqualForCacheForMorphisms`( phi, psi ) | ( operation )

Returns: true or false

Compares two objects in the cache

##### 3.13-2 AddIsEqualForCacheForMorphisms

`‣ AddIsEqualForCacheForMorphisms`( c, F ) | ( operation )

Returns: northing

By default, CAP uses caches to store the values of Categorical operations. To get a value out of the cache, one needs to compare the input of a basic operation with its previous input. To compare morphisms in the category, IsEqualForCacheForMorphisms is used. By default, IsEqualForCacheForMorphisms falls back to IsEqualForCache (see ToolsForHomalg), which in turn defaults to recursive comparison for lists and `IsIdenticalObj` in all other cases. If you add a function, this function used instead. A function F: a,b \mapsto bool is expected here. The output has to be true or false. Fail is not allowed in this context.

#### 3.14 IsHomSetInhabited

##### 3.14-1 IsHomSetInhabited

`‣ IsHomSetInhabited`( A, B ) | ( operation )

Returns: a boolean

The arguments are two objects A and B. The output is `true` if there exists a morphism from A to B, otherwise the output is `false`.

##### 3.14-2 AddIsHomSetInhabited

`‣ AddIsHomSetInhabited`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsHomSetInhabited`. F: A, B \mapsto \mathrm{IsHomSetInhabited}(A, B).

#### 3.15 Homomorphism structures

Homomorphism structures are way to "oversee" the homomorphisms between two given objects. Let C, D be categories. A D-homomorphism structure for C consists of the following data:

- a functor H: C^{\mathrm{op}} \times C \rightarrow D (when C and D are Ab-categories, H is assumed to be bilinear).

- an object 1 \in D, called the distinguished object,

- a bijection \nu: \mathrm{Hom}_{C}(a,b) \simeq \mathrm{Hom}_{D}(1, H(a,b)) natural in a,b \in C.

##### 3.15-1 HomomorphismStructureOnObjects

`‣ HomomorphismStructureOnObjects`( a, b ) | ( operation )

Returns: an object in D

The arguments are two objects a, b in C. The output is the value of the homomorphism structure on objects H(a,b).

##### 3.15-2 AddHomomorphismStructureOnObjects

`‣ AddHomomorphismStructureOnObjects`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `HomomorphismStructureOnObjects`. F: (a,b) \mapsto H(a,b).

##### 3.15-3 HomomorphismStructureOnMorphisms

`‣ HomomorphismStructureOnMorphisms`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{D}(H(a',b), H(a,b'))

The arguments are two morphisms \alpha: a \rightarrow a', \beta: b \rightarrow b' in C. The output is the value of the homomorphism structure on morphisms H(\alpha, \beta ).

##### 3.15-4 HomomorphismStructureOnMorphismsWithGivenObjects

`‣ HomomorphismStructureOnMorphismsWithGivenObjects`( s, alpha, beta, r ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{D}(H(a',b), H(a,b'))

The arguments are an object s = H(a',b) in D, two morphisms \alpha: a \rightarrow a', \beta: b \rightarrow b' in C, and an object r = H(a,b') in D. The output is the value of the homomorphism structure on morphisms H(\alpha, \beta ).

##### 3.15-5 AddHomomorphismStructureOnMorphismsWithGivenObjects

`‣ AddHomomorphismStructureOnMorphismsWithGivenObjects`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `HomomorphismStructureOnMorphismsWithGivenObjects`. F: ( s, \alpha: a \rightarrow a', \beta: b \rightarrow b', r ) \mapsto H( \alpha, \beta ).

##### 3.15-6 DistinguishedObjectOfHomomorphismStructure

`‣ DistinguishedObjectOfHomomorphismStructure`( C ) | ( attribute )

Returns: an object in D

The argument is a category C. The output is the distinguished object 1 in D of the homomorphism structure.

##### 3.15-7 AddDistinguishedObjectOfHomomorphismStructure

`‣ AddDistinguishedObjectOfHomomorphismStructure`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `DistinguishedObjectOfHomomorphismStructure`. F: ( ) \mapsto 1.

##### 3.15-8 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure

`‣ InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}_{D}(1, H(a,a'))

The argument is a morphism \alpha: a \rightarrow a' in C. The output is the corresponding morphism \nu( \alpha ): 1 \rightarrow H(a,a') in D of the homomorphism structure.

##### 3.15-9 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure

`‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure`. F: (\alpha: a \rightarrow a') \mapsto (\nu(\alpha):1 \rightarrow H(a,a')).

##### 3.15-10 InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism

`‣ InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism`( a, a', iota ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{C}(a,a')

The arguments are objects a,a' in C and a morphism \iota: 1 \rightarrow H(a,a') in D. The output is the corresponding morphism \nu^{-1}(\iota): a \rightarrow a' in C of the homomorphism structure.

##### 3.15-11 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism

`‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism`. F: (a,a',\iota: 1 \rightarrow H(a,a')) \mapsto (\nu^{-1}(\iota): a \rightarrow a').

##### 3.15-12 SolveLinearSystemInAbCategory

`‣ SolveLinearSystemInAbCategory`( alpha, beta, gamma ) | ( operation )

Returns: a list of morphisms [X_1, \dots, X_n]

The arguments are three lists \alpha, \beta, and \gamma. The first list \alpha (the left coefficients) is a list of list of morphisms \alpha_{ij}: A_i \rightarrow B_j, where i = 1 \dots m and j = 1 \dots n for integers m,n \geq 1. The second list \beta (the right coefficients) is a list of list of morphisms \beta_{ij}: C_j \rightarrow D_i, where i = 1 \dots m and j = 1 \dots n. The third list \gamma (the right side) is a list of morphisms \gamma_i: A_i \rightarrow D_i, where i = 1, \dots, m. The output is either a list of morphisms X_j: B_j \rightarrow C_j for j=1\dots n solving the linear system defined by \alpha, \beta, \gamma, i.e., \sum_{j = 1}^n \alpha_{ij}\cdot X_j \cdot \beta_{ij} = \gamma_i for all i = 1 \dots m, or \texttt{fail} if no such solution exists.

##### 3.15-13 MereExistenceOfSolutionOfLinearSystemInAbCategory

`‣ MereExistenceOfSolutionOfLinearSystemInAbCategory`( alpha, beta, gamma ) | ( operation )

Returns: a boolean

Like `SolveLinearSystemInAbCategory`, but the output is simply `true` if a solution exists, `false` otherwise.

##### 3.15-14 HomStructure

`‣ HomStructure`( alpha, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{D}(H(a',b), H(a,b'))

This is a convenience method. The arguments are two morphisms \alpha: a \rightarrow a', \beta: b \rightarrow b' in C. The output is `HomomorphismStructureOnMorphisms` called on \alpha, \beta.

##### 3.15-15 HomStructure

`‣ HomStructure`( alpha, b ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{D}(H(a',b), H(a,b))

This is a convenience method. The arguments are a morphism \alpha: a \rightarrow a' and an object b in C. The output is `HomomorphismStructureOnMorphisms` called on \alpha, \mathrm{id}_b.

##### 3.15-16 HomStructure

`‣ HomStructure`( a, beta ) | ( operation )

Returns: a morphism in \mathrm{Hom}_{D}(H(a,b), H(a,b'))

This is a convenience method. The arguments are an object a and a morphism \beta: b \rightarrow b' in C. The output is `HomomorphismStructureOnMorphisms` called on \mathrm{id}_a, \beta.

##### 3.15-17 HomStructure

`‣ HomStructure`( a, b ) | ( operation )

Returns: an object

This is a convenience method. The arguments are two objects a and b in C. The output is `HomomorphismStructureOnObjects` called on a,b.

##### 3.15-18 HomStructure

`‣ HomStructure`( arg ) | ( operation )

This is a convenience method for `InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure`.

##### 3.15-19 HomStructure

`‣ HomStructure`( arg1, arg2, arg3 ) | ( operation )

This is a convenience method for `InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism`.

##### 3.15-20 HomStructure

`‣ HomStructure`( arg ) | ( operation )

This is a convenience method for `DistinguishedObjectOfHomomorphismStructure`.

##### 3.15-21 BasisOfExternalHom

`‣ BasisOfExternalHom`( a, b ) | ( operation )

Returns: a list of morphisms in \mathrm{Hom}_{C}(a,b)

The arguments are objects a,b in a k-linear category C. The output is a list L of morphisms which is a basis of \mathrm{Hom}_{C}(a,b) in the sense that any given morphism \alpha: a \to b can uniquely be written as a linear combination of L with the coefficients in `CoefficientsOfMorphismWithGivenBasisOfExternalHom`(\alpha,L).

##### 3.15-22 AddBasisOfExternalHom

`‣ AddBasisOfExternalHom`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `BasisOfExternalHom`.

##### 3.15-23 CoefficientsOfMorphismWithGivenBasisOfExternalHom

`‣ CoefficientsOfMorphismWithGivenBasisOfExternalHom`( alpha, L ) | ( operation )

Returns: a list of elements in k

The arguments are a morphism \alpha: a \to b in a k-linear category C and a list L`=BasisOfExternalHom`(a,b). The output is a list of coefficients of \alpha with respect to L.

##### 3.15-24 AddCoefficientsOfMorphismWithGivenBasisOfExternalHom

`‣ AddCoefficientsOfMorphismWithGivenBasisOfExternalHom`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `CoefficientsOfMorphismWithGivenBasisOfExternalHom`.

##### 3.15-25 CoefficientsOfMorphism

`‣ CoefficientsOfMorphism`( alpha ) | ( attribute )

Returns: a list of elements in k

This is a convenience method. The argument is a morphism \alpha: a \to b in a k-linear category C. The output is a list of coefficients of \alpha with respect to the list `BasisOfExternalHom`(a,b).

#### 3.16 Simplified Morphisms

Let \phi: A \rightarrow B be a morphism. There are several different natural ways to look at \phi as an object in an ambient category:

- \mathrm{Hom}( A, B ), the set of homomorphisms with the equivalence relation \mathtt{IsCongruentForMorphisms} regarded as a category,

- \sum_{A}\mathrm{Hom}( A, B ), the category of morphisms where the range is fixed,

- \sum_{B}\mathrm{Hom}( A, B ), the category of morphisms where the source is fixed,

- \sum_{A,B}\mathrm{Hom}( A, B ), the category of morphisms where neither source nor range is fixed,

and furthermore, if \phi happens to be an endomorphism A \rightarrow A, we also have

- \sum_{A}\mathrm{Hom}(A,A), the category of endomorphisms.

Let \mathbf{C} be one of the categories above in which \phi may reside as an object, and let i be a non-negative integer or \infty. CAP provides commands for passing from \phi to \phi_i, where \phi_i is isomorphic to \phi in \mathbf{C}, but "simpler". The idea is that the greater the i, the "simpler" the \phi_i (but this could mean the harder the computation), with \infty as a possible value. The case i = 0 defaults to the identity operator for all simplifications. For the Add-operatations, only the cases i \geq 1 have to be given as functions.

\

If we regard \phi as an object in the category \mathrm{Hom}( A, B ), \phi_i is again in \mathrm{Hom}( A, B ) such that \phi \sim_{A,B} \phi_i. This case is handled by the following commands:

##### 3.16-1 SimplifyMorphism

`‣ SimplifyMorphism`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A,B)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is a simplified morphism \phi_i.

##### 3.16-2 AddSimplifyMorphism

`‣ AddSimplifyMorphism`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyMorphism`. The function F maps (\phi,i \geq 1) to \phi_i.

\

If we regard \phi as an object in the category \sum_{A}\mathrm{Hom}( A, B ), then \phi_i is a morphism of type A_i \rightarrow B and there is an isomorphism \sigma_i: A \rightarrow A_i such that \phi_i \circ \sigma_i \sim_{A,B} \phi. This case is handled by the following commands:

##### 3.16-3 SimplifySource

`‣ SimplifySource`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,B)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is a simplified morphism with simplified source \phi_i: A_i \rightarrow B.

##### 3.16-4 AddSimplifySource

`‣ AddSimplifySource`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource`. The function F maps (\phi,i \geq 1) to \phi_i.

##### 3.16-5 SimplifySource_IsoToInputObject

`‣ SimplifySource_IsoToInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,A)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism (\sigma_i)^{-1}: A_i \rightarrow A.

##### 3.16-6 AddSimplifySource_IsoToInputObject

`‣ AddSimplifySource_IsoToInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource_IsoToInputObject`. The function F maps (\phi,i) to (\sigma_i)^{-1}.

##### 3.16-7 SimplifySource_IsoFromInputObject

`‣ SimplifySource_IsoFromInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A,A_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism \sigma_i: A \rightarrow A_i.

##### 3.16-8 AddSimplifySource_IsoFromInputObject

`‣ AddSimplifySource_IsoFromInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource_IsoFromInputObject`. The function F maps (\phi,i) to (\sigma_i).

\

If we regard \phi as an object in the category \sum_{B}\mathrm{Hom}( A, B ), then \phi_i is a morphism of type A \rightarrow B_i and there is an isomorphism \rho_i: B \rightarrow B_i such that \rho_i^{-1} \circ \phi_i\sim_{A,B} \phi. This case is handled by the following commands:

##### 3.16-9 SimplifyRange

`‣ SimplifyRange`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A,B_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is a simplified morphism with simplified range \phi_i: A \rightarrow B_i.

##### 3.16-10 AddSimplifyRange

`‣ AddSimplifyRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange`. The function F maps (\phi,i \geq 1) to \phi_i.

##### 3.16-11 SimplifyRange_IsoToInputObject

`‣ SimplifyRange_IsoToInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B_i,B)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism (\rho_i)^{-1}: B_i \rightarrow B.

##### 3.16-12 AddSimplifyRange_IsoToInputObject

`‣ AddSimplifyRange_IsoToInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange_IsoToInputObject`. The function F maps (\phi,i) to (\rho_i)^{-1}.

##### 3.16-13 SimplifyRange_IsoFromInputObject

`‣ SimplifyRange_IsoFromInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B,B_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism \rho_i: B \rightarrow B_i.

##### 3.16-14 AddSimplifyRange_IsoFromInputObject

`‣ AddSimplifyRange_IsoFromInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange_IsoFromInputObject`. The function F maps (\phi,i) to \rho_i.

\

If we regard \phi as an object in the category \sum_{A, B}\mathrm{Hom}( A, B ), then \phi_i is a morphism of type A_i \rightarrow B_i and there is are isomorphisms \sigma_i: A \rightarrow A_i and \rho_i: B \rightarrow B_i such that \rho_i^{-1} \circ \phi_i \circ \sigma_i \sim_{A,B} \phi. This case is handled by the following commands:

##### 3.16-15 SimplifySourceAndRange

`‣ SimplifySourceAndRange`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,B_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is a simplified morphism with simplified source and range \phi_i: A_i \rightarrow B_i.

##### 3.16-16 AddSimplifySourceAndRange

`‣ AddSimplifySourceAndRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange`. The function F maps (\phi,i \geq 1) to \phi_i.

##### 3.16-17 SimplifySourceAndRange_IsoToInputRange

`‣ SimplifySourceAndRange_IsoToInputRange`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B_i,B)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism (\rho_i)^{-1}: B_i \rightarrow B.

##### 3.16-18 AddSimplifySourceAndRange_IsoToInputRange

`‣ AddSimplifySourceAndRange_IsoToInputRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoToInputRange`. The function F maps (\phi,i) to (\rho_i)^{-1}.

##### 3.16-19 SimplifySourceAndRange_IsoFromInputRange

`‣ SimplifySourceAndRange_IsoFromInputRange`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B,B_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism \rho_i: B \rightarrow B_i.

##### 3.16-20 AddSimplifySourceAndRange_IsoFromInputRange

`‣ AddSimplifySourceAndRange_IsoFromInputRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoFromInputRange`. The function F maps (\phi,i) to \rho_i.

##### 3.16-21 SimplifySourceAndRange_IsoToInputSource

`‣ SimplifySourceAndRange_IsoToInputSource`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,A)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism (\sigma_i)^{-1}: A_i \rightarrow A.

##### 3.16-22 AddSimplifySourceAndRange_IsoToInputSource

`‣ AddSimplifySourceAndRange_IsoToInputSource`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoToInputSource`. The function F maps (\phi,i) to (\sigma_i)^{-1}.

##### 3.16-23 SimplifySourceAndRange_IsoFromInputSource

`‣ SimplifySourceAndRange_IsoFromInputSource`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A,A_i)

The arguments are a morphism \phi: A \rightarrow B and a non-negative integer i or `infinity`. The output is the isomorphism \sigma_i: A \rightarrow A_i.

##### 3.16-24 AddSimplifySourceAndRange_IsoFromInputSource

`‣ AddSimplifySourceAndRange_IsoFromInputSource`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoFromInputSource`. The function F maps (\phi,i) to (\sigma_i).

\

If \phi:A \rightarrow A is an endomorphism, we may regard it as an object in the category \sum_{A}\mathrm{Hom}( A, A ). In this case \phi_i is a morphism of type A_i \rightarrow A_i and there is an isomorphism \sigma_i: A \rightarrow A_i such that \sigma_i^{-1} \circ \phi_i \circ \sigma_i \sim_{A,A} \phi. This case is handled by the following commands:

##### 3.16-25 SimplifyEndo

`‣ SimplifyEndo`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,A_i)

The arguments are an endomorphism \phi: A \rightarrow A and a non-negative integer i or `infinity`. The output is a simplified endomorphism \phi_i: A_i \rightarrow A_i.

##### 3.16-26 AddSimplifyEndo

`‣ AddSimplifyEndo`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo`. The function F maps (\phi,i \geq 1) to \phi_i.

##### 3.16-27 SimplifyEndo_IsoToInputObject

`‣ SimplifyEndo_IsoToInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A_i,A)

The arguments are an endomorphism \phi: A \rightarrow A and a non-negative integer i or `infinity`. The output is the isomorphism (\sigma_i)^{-1}: A_i \rightarrow A.

##### 3.16-28 AddSimplifyEndo_IsoToInputObject

`‣ AddSimplifyEndo_IsoToInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo_IsoToInputObject`. The function F maps (\phi,i) to (\sigma_i)^{-1}.

##### 3.16-29 SimplifyEndo_IsoFromInputObject

`‣ SimplifyEndo_IsoFromInputObject`( phi, i ) | ( operation )

Returns: a morphism in \mathrm{Hom}(A,A_i)

The arguments are an endomorphism \phi: A \rightarrow A and a non-negative integer i or `infinity`. The output is the isomorphism \sigma_i: A \rightarrow A_i.

##### 3.16-30 AddSimplifyEndo_IsoFromInputObject

`‣ AddSimplifyEndo_IsoFromInputObject`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo_IsoFromInputObject`. The function F maps (\phi,i) to (\sigma_i).

##### 3.16-31 Simplify

`‣ Simplify`( phi ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(A_{\infty},B_{\infty})

This is a convenient method. The argument is a morphism \phi: A \rightarrow B. The output is a "simplified" version of \phi that may change the source and range of \phi (up to isomorphism). To be precise, the output is an \infty-th simplified morphism of (\iota_A^{\infty})^{-1}\circ \phi \circ \iota_A^{\infty}.

#### 3.17 Reduction by split epi summands

Let \alpha: A \rightarrow B be a morphism in an additive category. Suppose we are given direct sum decompositions of A \simeq A' \oplus A'' and B \simeq B' \oplus B'' such that If \alpha'' is a split epimorphism, then we call \alpha': A' \rightarrow B' some reduction of \alpha by split epi summands. The inclusions/projections of the decompositions into direct sums induce commutative diagrams and

##### 3.17-1 SomeReductionBySplitEpiSummand

`‣ SomeReductionBySplitEpiSummand`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(A',B')

The argument is a morphism \alpha: A \rightarrow B. The output is some reduction of \alpha by split epi summands \alpha': A' \rightarrow B'.

##### 3.17-2 AddSomeReductionBySplitEpiSummand

`‣ AddSomeReductionBySplitEpiSummand`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand`. The function F maps \alpha to \alpha'.

##### 3.17-3 SomeReductionBySplitEpiSummand_MorphismToInputRange

`‣ SomeReductionBySplitEpiSummand_MorphismToInputRange`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(B',B)

The argument is a morphism \alpha: A \rightarrow B. The output is the morphism \beta': B' \rightarrow B linking \alpha with some reduction by split epi summands.

##### 3.17-4 AddSomeReductionBySplitEpiSummand_MorphismToInputRange

`‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand_MorphismToInputRange`. The function F maps \alpha to \beta'.

##### 3.17-5 SomeReductionBySplitEpiSummand_MorphismFromInputRange

`‣ SomeReductionBySplitEpiSummand_MorphismFromInputRange`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(B,B')

The argument is a morphism \alpha: A \rightarrow B. The output is the morphism \beta: B \rightarrow B' linking \alpha with some reduction by split epi summands.

##### 3.17-6 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange

`‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange`( C, F ) | ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand_MorphismFromInputRange`. The function F maps \alpha to \beta.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 Ind

generated by GAPDoc2HTML