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.
‣ CapCategory ( alpha ) | ( attribute ) |
Returns: a category
The argument is a morphism \alpha. The output is the category \mathbf{C} to which \alpha was added.
‣ Source ( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \alpha: a \rightarrow b. The output is its source a.
‣ Range ( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \alpha: a \rightarrow b. The output is its range b.
‣ AddIsMonomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsMonomorphism
. F: \alpha \mapsto \mathtt{IsMonomorphism}(\alpha).
‣ AddIsEpimorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEpimorphism
. F: \alpha \mapsto \mathtt{IsEpimorphism}(\alpha).
‣ AddIsIsomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsIsomorphism
. F: \alpha \mapsto \mathtt{IsIsomorphism}(\alpha).
‣ AddIsSplitMonomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsSplitMonomorphism
. F: \alpha \mapsto \mathtt{IsSplitMonomorphism}(\alpha).
‣ AddIsSplitEpimorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsSplitEpimorphism
. F: \alpha \mapsto \mathtt{IsSplitEpimorphism}(\alpha).
‣ AddIsOne ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsOne
. F: \alpha \mapsto \mathtt{IsOne}(\alpha).
‣ AddIsIdempotent ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsIdempotent
. F: \alpha \mapsto \mathtt{IsIdempotent}(\alpha).
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.
‣ 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
.
‣ 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.
‣ 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
.
‣ 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.
‣ 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
.
‣ 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.
‣ 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
.
‣ 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.
‣ 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
.
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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
.
‣ AddRandomMorphismWithFixedSourceAndRangeByList ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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.
‣ 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.
‣ 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
.
‣ 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.
‣ 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.
Non-categorical properties are not stable under equivalences of categories.
‣ 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
.
‣ AddIsIdenticalToIdentityMorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsIdenticalToIdentityMorphism
. F: \alpha \mapsto \mathtt{IsIdenticalToIdentityMorphism}(\alpha).
‣ 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
.
‣ AddIsIdenticalToZeroMorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsIdenticalToZeroMorphism
. F: \alpha \mapsto \mathtt{IsIdenticalToZeroMorphism }(\alpha).
‣ AddIsEndomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEndomorphism
. F: \alpha \mapsto \mathtt{IsEndomorphism}(\alpha).
‣ AddIsAutomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsAutomorphism
. F: \alpha \mapsto \mathtt{IsAutomorphism}(\alpha).
‣ Add ( category, morphism ) | ( operation ) |
Adds morphism as a morphism to category.
‣ 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.
‣ 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.
‣ ObjectifyMorphismForCAPWithAttributes ( morphism, category[, attribute1, value1, ...] ) | ( function ) |
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.
Please note that the Source
and Range
attribute need to be passed to this function. The values belonging to these attrbutes will not be objectified.
‣ 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
.
‣ AddIsCongruentForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsCongruentForMorphisms
. F: (\alpha, \beta) \mapsto \mathtt{IsCongruentForMorphisms}(\alpha, \beta).
‣ 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
.
‣ AddIsEqualForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEqualForMorphisms
. F: (\alpha, \beta) \mapsto \mathtt{IsEqualForMorphisms}(\alpha, \beta).
‣ 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
.
‣ AddIsEqualForMorphismsOnMor ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEqualForMorphismsOnMor
. F: (\alpha, \beta) \mapsto \mathtt{IsEqualForMorphismsOnMor}(\alpha, \beta).
‣ 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
.
‣ AddIsZeroForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsZeroForMorphisms
. F: \alpha \mapsto \mathtt{IsZeroForMorphisms}(\alpha).
‣ 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.
‣ AddAdditionForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation AdditionForMorphisms
. F: (\alpha, \beta) \mapsto \alpha + \beta.
‣ 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.
‣ AddSubtractionForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation SubtractionForMorphisms
. F: (\alpha, \beta) \mapsto \alpha - \beta.
‣ 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.
‣ AddAdditiveInverseForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation AdditiveInverseForMorphisms
. F: \alpha \mapsto -\alpha.
‣ 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.
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation MultiplyWithElementOfCommutativeRingForMorphisms
. F: (r, \alpha) \mapsto r \cdot \alpha.
‣ 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.
‣ AddZeroMorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation ZeroMorphism
. F: (a,b) \mapsto (0: a \rightarrow b).
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.
‣ 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
.
‣ AddIsEqualAsSubobjects ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEqualAsSubobjects
. F: (\alpha, \beta) \mapsto \mathtt{IsEqualAsSubobjects}(\alpha,\beta).
‣ 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
.
‣ AddIsEqualAsFactorobjects ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsEqualAsFactorobjects
. F: (\alpha, \beta) \mapsto \mathtt{IsEqualAsFactorobjects}(\alpha,\beta).
‣ 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
.
‣ AddIsDominating ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsDominating
. F: (\alpha, \beta) \mapsto \mathtt{IsDominating}(\alpha,\beta).
‣ 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
.
‣ AddIsCodominating ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsCodominating
. F: (\alpha, \beta) \mapsto \mathtt{IsCodominating}(\alpha,\beta).
‣ 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.
‣ AddIdentityMorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IdentityMorphism
. F: a \mapsto \mathrm{id}_a.
‣ 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.
‣ 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 ) ) ).
‣ AddPreCompose ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation PreCompose
. F: (\alpha, \beta) \mapsto \beta \circ \alpha.
‣ 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.
‣ 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.
‣ AddPostCompose ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation PostCompose
. F: (\alpha, \beta) \mapsto \alpha \circ \beta.
‣ 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
.
‣ AddIsWellDefinedForMorphisms ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsWellDefinedForMorphisms
. F: \alpha \mapsto \mathtt{IsWellDefinedForMorphisms}( \alpha ).
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.
‣ 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.
‣ AddLiftAlongMonomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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.
‣ AddColiftAlongEpimorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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
.
‣ AddIsLiftableAlongMonomorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsLiftableAlongMonomorphism
. F: (\iota, \tau) \mapsto \texttt{IsLiftableAlongMonomorphism}( \iota, \tau ).
‣ 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
.
‣ AddIsColiftableAlongEpimorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsColiftableAlongEpimorphism
. F: (\epsilon, \tau) \mapsto \texttt{IsColiftableAlongEpimorphism}( \epsilon, \tau ).
‣ 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.
‣ AddLift ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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.
‣ AddColift ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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.
‣ 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
.
‣ AddIsLiftable ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsLiftable
. F: ( \alpha, \beta ) \mapsto \mathtt{IsLiftable}( \alpha, \beta ).
‣ 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
.
‣ AddIsColiftable ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation IsColiftable
. F: ( \alpha, \beta ) \mapsto \mathtt{IsColiftable}( \alpha, \beta ).
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.
‣ AddInverse ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation Inverse
. F: \alpha \mapsto \alpha^{-1}.
‣ IsEqualForCacheForMorphisms ( phi, psi ) | ( operation ) |
Returns: true or false
Compares two objects in the cache
‣ 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, IsEqualForCacheForMorphism is used. By default this is an alias for IsEqualForMorphismsOnMor, where fail is substituted by false. 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.
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.
‣ 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).
‣ AddHomomorphismStructureOnObjects ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation HomomorphismStructureOnObjects
. F: (a,b) \mapsto H(a,b).
‣ 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 ).
‣ 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 ).
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations 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 ).
‣ 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.
‣ AddDistinguishedObjectOfHomomorphismStructure ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation DistinguishedObjectOfHomomorphismStructure
. F: ( ) \mapsto 1.
‣ InterpretMorphismAsMorphismFromDinstinguishedObjectToHomomorphismStructure ( 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.
‣ AddInterpretMorphismAsMorphismFromDinstinguishedObjectToHomomorphismStructure ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation InterpretMorphismAsMorphismFromDinstinguishedObjectToHomomorphismStructure
. F: (\alpha: a \rightarrow a') \mapsto (\nu(\alpha):1 \rightarrow H(a,a')).
‣ InterpretMorphismFromDinstinguishedObjectToHomomorphismStructureAsMorphism ( 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.
‣ AddInterpretMorphismFromDinstinguishedObjectToHomomorphismStructureAsMorphism ( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operations adds the given function F to the category for the basic operation InterpretMorphismFromDinstinguishedObjectToHomomorphismStructureAsMorphism
. F: (a,a',\iota: 1 \rightarrow H(a,a')) \mapsto (\nu^{-1}(\iota): a \rightarrow a').
‣ 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.
generated by GAPDoc2HTML