GAP (CAP) - Chapter 6: Universal Objects

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]

6 Universal Objects
6.1 Kernel
6.1-1 KernelObject
6.1-2 KernelEmbedding
6.1-3 KernelEmbeddingWithGivenKernelObject
6.1-4 MorphismFromKernelObjectToSink
6.1-5 MorphismFromKernelObjectToSinkWithGivenKernelObject
6.1-6 KernelLift
6.1-7 KernelLiftWithGivenKernelObject
6.1-8 AddKernelObject
6.1-9 AddKernelEmbedding
6.1-10 AddKernelEmbeddingWithGivenKernelObject
6.1-11 AddMorphismFromKernelObjectToSink
6.1-12 AddMorphismFromKernelObjectToSinkWithGivenKernelObject
6.1-13 AddKernelLift
6.1-14 AddKernelLiftWithGivenKernelObject
6.1-15 KernelObjectFunctorial
6.1-16 KernelObjectFunctorial
6.1-17 KernelObjectFunctorialWithGivenKernelObjects
6.1-18 KernelObjectFunctorialWithGivenKernelObjects
6.1-19 AddKernelObjectFunctorialWithGivenKernelObjects
6.2 Cokernel
6.2-1 CokernelObject
6.2-2 CokernelProjection
6.2-3 CokernelProjectionWithGivenCokernelObject
6.2-4 MorphismFromSourceToCokernelObject
6.2-5 MorphismFromSourceToCokernelObjectWithGivenCokernelObject
6.2-6 CokernelColift
6.2-7 CokernelColiftWithGivenCokernelObject
6.2-8 AddCokernelObject
6.2-9 AddCokernelProjection
6.2-10 AddCokernelProjectionWithGivenCokernelObject
6.2-11 AddMorphismFromSourceToCokernelObject
6.2-12 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject
6.2-13 AddCokernelColift
6.2-14 AddCokernelColiftWithGivenCokernelObject
6.2-15 CokernelObjectFunctorial
6.2-16 CokernelObjectFunctorial
6.2-17 CokernelObjectFunctorialWithGivenCokernelObjects
6.2-18 CokernelObjectFunctorialWithGivenCokernelObjects
6.2-19 AddCokernelObjectFunctorialWithGivenCokernelObjects
6.3 Zero Object
6.3-1 ZeroObject
6.3-2 ZeroObject
6.3-3 MorphismFromZeroObject
6.3-4 MorphismIntoZeroObject
6.3-5 UniversalMorphismFromZeroObject
6.3-6 UniversalMorphismFromZeroObjectWithGivenZeroObject
6.3-7 UniversalMorphismIntoZeroObject
6.3-8 UniversalMorphismIntoZeroObjectWithGivenZeroObject
6.3-9 IsomorphismFromZeroObjectToInitialObject
6.3-10 IsomorphismFromInitialObjectToZeroObject
6.3-11 IsomorphismFromZeroObjectToTerminalObject
6.3-12 IsomorphismFromTerminalObjectToZeroObject
6.3-13 AddZeroObject
6.3-14 AddUniversalMorphismIntoZeroObject
6.3-15 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject
6.3-16 AddUniversalMorphismFromZeroObject
6.3-17 AddUniversalMorphismFromZeroObjectWithGivenZeroObject
6.3-18 AddIsomorphismFromZeroObjectToInitialObject
6.3-19 AddIsomorphismFromInitialObjectToZeroObject
6.3-20 AddIsomorphismFromZeroObjectToTerminalObject
6.3-21 AddIsomorphismFromTerminalObjectToZeroObject
6.3-22 ZeroObjectFunctorial
6.3-23 AddZeroObjectFunctorial
6.4 Terminal Object
6.4-1 TerminalObject
6.4-2 TerminalObject
6.4-3 UniversalMorphismIntoTerminalObject
6.4-4 UniversalMorphismIntoTerminalObjectWithGivenTerminalObject
6.4-5 AddTerminalObject
6.4-6 AddUniversalMorphismIntoTerminalObject
6.4-7 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject
6.4-8 TerminalObjectFunctorial
6.4-9 AddTerminalObjectFunctorial
6.5 Initial Object
6.5-1 InitialObject
6.5-2 InitialObject
6.5-3 UniversalMorphismFromInitialObject
6.5-4 UniversalMorphismFromInitialObjectWithGivenInitialObject
6.5-5 AddInitialObject
6.5-6 AddUniversalMorphismFromInitialObject
6.5-7 AddUniversalMorphismFromInitialObjectWithGivenInitialObject
6.5-8 InitialObjectFunctorial
6.5-9 AddInitialObjectFunctorial
6.6 Direct Sum
6.6-1 DirectSumOp
6.6-2 ProjectionInFactorOfDirectSum
6.6-3 ProjectionInFactorOfDirectSumOp
6.6-4 ProjectionInFactorOfDirectSumWithGivenDirectSum
6.6-5 InjectionOfCofactorOfDirectSum
6.6-6 InjectionOfCofactorOfDirectSumOp
6.6-7 InjectionOfCofactorOfDirectSumWithGivenDirectSum
6.6-8 UniversalMorphismIntoDirectSum
6.6-9 UniversalMorphismIntoDirectSumOp
6.6-10 UniversalMorphismIntoDirectSumWithGivenDirectSum
6.6-11 UniversalMorphismFromDirectSum
6.6-12 UniversalMorphismFromDirectSumOp
6.6-13 UniversalMorphismFromDirectSumWithGivenDirectSum
6.6-14 IsomorphismFromDirectSumToDirectProduct
6.6-15 IsomorphismFromDirectSumToDirectProductOp
6.6-16 IsomorphismFromDirectProductToDirectSum
6.6-17 IsomorphismFromDirectProductToDirectSumOp
6.6-18 IsomorphismFromDirectSumToCoproduct
6.6-19 IsomorphismFromDirectSumToCoproductOp
6.6-20 IsomorphismFromCoproductToDirectSum
6.6-21 IsomorphismFromCoproductToDirectSumOp
6.6-22 MorphismBetweenDirectSums
6.6-23 AddMorphismBetweenDirectSums
6.6-24 MorphismBetweenDirectSumsOp
6.6-25 ComponentOfMorphismIntoDirectSum
6.6-26 ComponentOfMorphismFromDirectSum
6.6-27 AddComponentOfMorphismIntoDirectSum
6.6-28 AddComponentOfMorphismFromDirectSum
6.6-29 AddProjectionInFactorOfDirectSum
6.6-30 AddProjectionInFactorOfDirectSumWithGivenDirectSum
6.6-31 AddInjectionOfCofactorOfDirectSum
6.6-32 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum
6.6-33 AddUniversalMorphismIntoDirectSum
6.6-34 AddUniversalMorphismIntoDirectSumWithGivenDirectSum
6.6-35 AddUniversalMorphismFromDirectSum
6.6-36 AddUniversalMorphismFromDirectSumWithGivenDirectSum
6.6-37 AddIsomorphismFromDirectSumToDirectProduct
6.6-38 AddIsomorphismFromDirectProductToDirectSum
6.6-39 AddIsomorphismFromDirectSumToCoproduct
6.6-40 AddIsomorphismFromCoproductToDirectSum
6.6-41 AddDirectSum
6.6-42 DirectSumFunctorial
6.6-43 DirectSumFunctorialWithGivenDirectSums
6.6-44 AddDirectSumFunctorialWithGivenDirectSums
6.7 Coproduct
6.7-1 Coproduct
6.7-2 Coproduct
6.7-3 Coproduct
6.7-4 CoproductOp
6.7-5 InjectionOfCofactorOfCoproduct
6.7-6 InjectionOfCofactorOfCoproductOp
6.7-7 InjectionOfCofactorOfCoproductWithGivenCoproduct
6.7-8 UniversalMorphismFromCoproduct
6.7-9 UniversalMorphismFromCoproductOp
6.7-10 UniversalMorphismFromCoproductWithGivenCoproduct
6.7-11 AddCoproduct
6.7-12 AddInjectionOfCofactorOfCoproduct
6.7-13 AddInjectionOfCofactorOfCoproductWithGivenCoproduct
6.7-14 AddUniversalMorphismFromCoproduct
6.7-15 AddUniversalMorphismFromCoproductWithGivenCoproduct
6.7-16 CoproductFunctorial
6.7-17 CoproductFunctorialWithGivenCoproducts
6.7-18 AddCoproductFunctorialWithGivenCoproducts
6.8 Direct Product
6.8-1 DirectProductOp
6.8-2 ProjectionInFactorOfDirectProduct
6.8-3 ProjectionInFactorOfDirectProductOp
6.8-4 ProjectionInFactorOfDirectProductWithGivenDirectProduct
6.8-5 UniversalMorphismIntoDirectProduct
6.8-6 UniversalMorphismIntoDirectProductOp
6.8-7 UniversalMorphismIntoDirectProductWithGivenDirectProduct
6.8-8 AddDirectProduct
6.8-9 AddProjectionInFactorOfDirectProduct
6.8-10 AddProjectionInFactorOfDirectProductWithGivenDirectProduct
6.8-11 AddUniversalMorphismIntoDirectProduct
6.8-12 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct
6.8-13 DirectProductFunctorial
6.8-14 DirectProductFunctorialWithGivenDirectProducts
6.8-15 AddDirectProductFunctorialWithGivenDirectProducts
6.9 Equalizer
6.9-1 Equalizer
6.9-2 EqualizerOp
6.9-3 EmbeddingOfEqualizer
6.9-4 EmbeddingOfEqualizerOp
6.9-5 EmbeddingOfEqualizerWithGivenEqualizer
6.9-6 MorphismFromEqualizerToSink
6.9-7 MorphismFromEqualizerToSinkOp
6.9-8 MorphismFromEqualizerToSinkWithGivenEqualizer
6.9-9 UniversalMorphismIntoEqualizer
6.9-10 UniversalMorphismIntoEqualizerWithGivenEqualizer
6.9-11 AddEqualizer
6.9-12 AddEmbeddingOfEqualizer
6.9-13 AddEmbeddingOfEqualizerWithGivenEqualizer
6.9-14 AddMorphismFromEqualizerToSink
6.9-15 AddMorphismFromEqualizerToSinkWithGivenEqualizer
6.9-16 AddUniversalMorphismIntoEqualizer
6.9-17 AddUniversalMorphismIntoEqualizerWithGivenEqualizer
6.9-18 EqualizerFunctorial
6.9-19 EqualizerFunctorialWithGivenEqualizers
6.9-20 AddEqualizerFunctorialWithGivenEqualizers
6.10 Coequalizer
6.10-1 Coequalizer
6.10-2 CoequalizerOp
6.10-3 ProjectionOntoCoequalizer
6.10-4 ProjectionOntoCoequalizerOp
6.10-5 ProjectionOntoCoequalizerWithGivenCoequalizer
6.10-6 MorphismFromSourceToCoequalizer
6.10-7 MorphismFromSourceToCoequalizerOp
6.10-8 MorphismFromSourceToCoequalizerWithGivenCoequalizer
6.10-9 UniversalMorphismFromCoequalizer
6.10-10 UniversalMorphismFromCoequalizerWithGivenCoequalizer
6.10-11 AddCoequalizer
6.10-12 AddProjectionOntoCoequalizer
6.10-13 AddProjectionOntoCoequalizerWithGivenCoequalizer
6.10-14 AddMorphismFromSourceToCoequalizer
6.10-15 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer
6.10-16 AddUniversalMorphismFromCoequalizer
6.10-17 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer
6.10-18 CoequalizerFunctorial
6.10-19 CoequalizerFunctorialWithGivenCoequalizers
6.10-20 AddCoequalizerFunctorialWithGivenCoequalizers
6.11 Fiber Product
6.11-1 IsomorphismFromFiberProductToKernelOfDiagonalDifference
6.11-2 IsomorphismFromFiberProductToKernelOfDiagonalDifferenceOp
6.11-3 AddIsomorphismFromFiberProductToKernelOfDiagonalDifference
6.11-4 IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct
6.11-5 IsomorphismFromKernelOfDiagonalDifferenceToFiberProductOp
6.11-6 AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct
6.11-7 IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram
6.11-8 IsomorphismFromFiberProductToEqualizerOfDirectProductDiagramOp
6.11-9 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram
6.11-10 IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct
6.11-11 IsomorphismFromEqualizerOfDirectProductDiagramToFiberProductOp
6.11-12 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct
6.11-13 DirectSumDiagonalDifference
6.11-14 DirectSumDiagonalDifferenceOp
6.11-15 AddDirectSumDiagonalDifference
6.11-16 FiberProductEmbeddingInDirectSum
6.11-17 FiberProductEmbeddingInDirectSumOp
6.11-18 AddFiberProductEmbeddingInDirectSum
6.11-19 FiberProduct
6.11-20 FiberProductOp
6.11-21 ProjectionInFactorOfFiberProduct
6.11-22 ProjectionInFactorOfFiberProductOp
6.11-23 ProjectionInFactorOfFiberProductWithGivenFiberProduct
6.11-24 MorphismFromFiberProductToSink
6.11-25 MorphismFromFiberProductToSinkOp
6.11-26 MorphismFromFiberProductToSinkWithGivenFiberProduct
6.11-27 UniversalMorphismIntoFiberProduct
6.11-28 UniversalMorphismIntoFiberProductOp
6.11-29 UniversalMorphismIntoFiberProductWithGivenFiberProduct
6.11-30 AddFiberProduct
6.11-31 AddProjectionInFactorOfFiberProduct
6.11-32 AddProjectionInFactorOfFiberProductWithGivenFiberProduct
6.11-33 AddMorphismFromFiberProductToSink
6.11-34 AddMorphismFromFiberProductToSinkWithGivenFiberProduct
6.11-35 AddUniversalMorphismIntoFiberProduct
6.11-36 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct
6.11-37 FiberProductFunctorial
6.11-38 FiberProductFunctorialWithGivenFiberProducts
6.11-39 AddFiberProductFunctorialWithGivenFiberProducts
6.12 Pushout
6.12-1 IsomorphismFromPushoutToCokernelOfDiagonalDifference
6.12-2 IsomorphismFromPushoutToCokernelOfDiagonalDifferenceOp
6.12-3 AddIsomorphismFromPushoutToCokernelOfDiagonalDifference
6.12-4 IsomorphismFromCokernelOfDiagonalDifferenceToPushout
6.12-5 IsomorphismFromCokernelOfDiagonalDifferenceToPushoutOp
6.12-6 AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout
6.12-7 IsomorphismFromPushoutToCoequalizerOfCoproductDiagram
6.12-8 IsomorphismFromPushoutToCoequalizerOfCoproductDiagramOp
6.12-9 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram
6.12-10 IsomorphismFromCoequalizerOfCoproductDiagramToPushout
6.12-11 IsomorphismFromCoequalizerOfCoproductDiagramToPushoutOp
6.12-12 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout
6.12-13 DirectSumCodiagonalDifference
6.12-14 DirectSumCodiagonalDifferenceOp
6.12-15 AddDirectSumCodiagonalDifference
6.12-16 DirectSumProjectionInPushout
6.12-17 DirectSumProjectionInPushoutOp
6.12-18 AddDirectSumProjectionInPushout
6.12-19 Pushout
6.12-20 Pushout
6.12-21 PushoutOp
6.12-22 InjectionOfCofactorOfPushout
6.12-23 InjectionOfCofactorOfPushoutOp
6.12-24 InjectionOfCofactorOfPushoutWithGivenPushout
6.12-25 MorphismFromSourceToPushout
6.12-26 MorphismFromSourceToPushoutOp
6.12-27 MorphismFromSourceToPushoutWithGivenPushout
6.12-28 UniversalMorphismFromPushout
6.12-29 UniversalMorphismFromPushoutOp
6.12-30 UniversalMorphismFromPushoutWithGivenPushout
6.12-31 AddPushout
6.12-32 AddInjectionOfCofactorOfPushout
6.12-33 AddInjectionOfCofactorOfPushoutWithGivenPushout
6.12-34 AddMorphismFromSourceToPushout
6.12-35 AddMorphismFromSourceToPushoutWithGivenPushout
6.12-36 AddUniversalMorphismFromPushout
6.12-37 AddUniversalMorphismFromPushoutWithGivenPushout
6.12-38 PushoutFunctorial
6.12-39 PushoutFunctorialWithGivenPushouts
6.12-40 AddPushoutFunctorialWithGivenPushouts
6.13 Image
6.13-1 IsomorphismFromImageObjectToKernelOfCokernel
6.13-2 AddIsomorphismFromImageObjectToKernelOfCokernel
6.13-3 IsomorphismFromKernelOfCokernelToImageObject
6.13-4 AddIsomorphismFromKernelOfCokernelToImageObject
6.13-5 ImageObject
6.13-6 ImageEmbedding
6.13-7 ImageEmbeddingWithGivenImageObject
6.13-8 CoastrictionToImage
6.13-9 CoastrictionToImageWithGivenImageObject
6.13-10 UniversalMorphismFromImage
6.13-11 UniversalMorphismFromImageWithGivenImageObject
6.13-12 AddImageObject
6.13-13 AddImageEmbedding
6.13-14 AddImageEmbeddingWithGivenImageObject
6.13-15 AddCoastrictionToImage
6.13-16 AddCoastrictionToImageWithGivenImageObject
6.13-17 AddUniversalMorphismFromImage
6.13-18 AddUniversalMorphismFromImageWithGivenImageObject
6.14 Coimage
6.14-1 MorphismFromCoimageToImage
6.14-2 MorphismFromCoimageToImageWithGivenObjects
6.14-3 AddMorphismFromCoimageToImageWithGivenObjects
6.14-4 InverseMorphismFromCoimageToImage
6.14-5 InverseMorphismFromCoimageToImageWithGivenObjects
6.14-6 AddInverseMorphismFromCoimageToImageWithGivenObjects
6.14-7 IsomorphismFromCoimageToCokernelOfKernel
6.14-8 AddIsomorphismFromCoimageToCokernelOfKernel
6.14-9 IsomorphismFromCokernelOfKernelToCoimage
6.14-10 AddIsomorphismFromCokernelOfKernelToCoimage
6.14-11 Coimage
6.14-12 CoimageProjection
6.14-13 CoimageProjectionWithGivenCoimage
6.14-14 AstrictionToCoimage
6.14-15 AstrictionToCoimageWithGivenCoimage
6.14-16 UniversalMorphismIntoCoimage
6.14-17 UniversalMorphismIntoCoimageWithGivenCoimage
6.14-18 AddCoimage
6.14-19 AddCoimageProjection
6.14-20 AddCoimageProjectionWithGivenCoimage
6.14-21 AddAstrictionToCoimage
6.14-22 AddAstrictionToCoimageWithGivenCoimage
6.14-23 AddUniversalMorphismIntoCoimage
6.14-24 AddUniversalMorphismIntoCoimageWithGivenCoimage
6.14-25 CanonicalIdentificationFromImageObjectToCoimage
6.14-26 AddCanonicalIdentificationFromImageObjectToCoimage
6.14-27 CanonicalIdentificationFromCoimageToImageObject
6.14-28 AddCanonicalIdentificationFromCoimageToImageObject
6.15 Homology objects
6.15-1 HomologyObject
6.15-2 HomologyObjectFunctorial
6.15-3 HomologyObjectFunctorialWithGivenHomologyObjects
6.15-4 IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject
6.15-5 IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject
6.15-6 AddHomologyObject
6.15-7 AddHomologyObjectFunctorialWithGivenHomologyObjects

### 6 Universal Objects

#### 6.1 Kernel

For a given morphism \alpha: A \rightarrow B, a kernel of \alpha consists of three parts:

- an object K,

- a morphism \iota: K \rightarrow A such that \alpha \circ \iota \sim_{K,B} 0,

- a dependent function u mapping each morphism \tau: T \rightarrow A satisfying \alpha \circ \tau \sim_{T,B} 0 to a morphism u(\tau): T \rightarrow K such that \iota \circ u( \tau ) \sim_{T,A} \tau.

The triple ( K, \iota, u ) is called a kernel of \alpha if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object K of such a triple by \mathrm{KernelObject}(\alpha). We say that the morphism u(\tau) is induced by the universal property of the kernel. \\ \mathrm{KernelObject} is a functorial operation. This means: for \mu: A \rightarrow A', \nu: B \rightarrow B', \alpha: A \rightarrow B, \alpha': A' \rightarrow B' such that \nu \circ \alpha \sim_{A,B'} \alpha' \circ \mu, we obtain a morphism \mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' ).

##### 6.1-1 KernelObject

`‣ KernelObject`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha. The output is the kernel K of \alpha.

##### 6.1-2 KernelEmbedding

`‣ KernelEmbedding`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the kernel embedding \iota: \mathrm{KernelObject}(\alpha) \rightarrow A.

##### 6.1-3 KernelEmbeddingWithGivenKernelObject

`‣ KernelEmbeddingWithGivenKernelObject`( alpha, K ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and an object K = \mathrm{KernelObject}(\alpha). The output is the kernel embedding \iota: K \rightarrow A.

##### 6.1-4 MorphismFromKernelObjectToSink

`‣ MorphismFromKernelObjectToSink`( alpha ) | ( operation )

Returns: the zero morphism in \mathrm{Hom}( \mathrm{KernelObject}(\alpha), B )

The argument is a morphism \alpha: A \rightarrow B. The output is the zero morphism 0: \mathrm{KernelObject}(\alpha) \rightarrow B.

##### 6.1-5 MorphismFromKernelObjectToSinkWithGivenKernelObject

`‣ MorphismFromKernelObjectToSinkWithGivenKernelObject`( alpha, K ) | ( operation )

Returns: the zero morphism in \mathrm{Hom}( K, B )

The arguments are a morphism \alpha: A \rightarrow B and an object K = \mathrm{KernelObject}(\alpha). The output is the zero morphism 0: K \rightarrow B.

##### 6.1-6 KernelLift

`‣ KernelLift`( alpha, tau ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and a test morphism \tau: T \rightarrow A satisfying \alpha \circ \tau \sim_{T,B} 0. The output is the morphism u(\tau): T \rightarrow \mathrm{KernelObject}(\alpha) given by the universal property of the kernel.

##### 6.1-7 KernelLiftWithGivenKernelObject

`‣ KernelLiftWithGivenKernelObject`( alpha, tau, K ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B, a test morphism \tau: T \rightarrow A satisfying \alpha \circ \tau \sim_{T,B} 0, and an object K = \mathrm{KernelObject}(\alpha). The output is the morphism u(\tau): T \rightarrow K given by the universal property of the kernel.

##### 6.1-8 AddKernelObject

`‣ AddKernelObject`( 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 `KernelObject`. F: \alpha \mapsto \mathrm{KernelObject}(\alpha).

##### 6.1-9 AddKernelEmbedding

`‣ AddKernelEmbedding`( 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 `KernelEmbedding`. F: \alpha \mapsto \iota.

##### 6.1-10 AddKernelEmbeddingWithGivenKernelObject

`‣ AddKernelEmbeddingWithGivenKernelObject`( 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 `KernelEmbeddingWithGivenKernelObject`. F: (\alpha, K) \mapsto \iota.

##### 6.1-11 AddMorphismFromKernelObjectToSink

`‣ AddMorphismFromKernelObjectToSink`( 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 `MorphismFromKernelObjectToSink`. F: \alpha \mapsto \mu

##### 6.1-12 AddMorphismFromKernelObjectToSinkWithGivenKernelObject

`‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject`( 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 `MorphismFromKernelObjectToSinkWithGivenKernelObject`. F: ( \alpha, K ) \mapsto \mu

##### 6.1-13 AddKernelLift

`‣ AddKernelLift`( 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 `KernelLift`. F: (\alpha, \tau) \mapsto u(\tau).

##### 6.1-14 AddKernelLiftWithGivenKernelObject

`‣ AddKernelLiftWithGivenKernelObject`( 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 `KernelLiftWithGivenKernelObject`. F: (\alpha, \tau, K) \mapsto u.

##### 6.1-15 KernelObjectFunctorial

`‣ KernelObjectFunctorial`( L ) | ( operation )

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

The argument is a list L = [ \alpha: A \rightarrow B, [ \mu: A \rightarrow A', \nu: B \rightarrow B' ], \alpha': A' \rightarrow B' ] of morphisms. The output is the morphism \mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' ) given by the functoriality of the kernel.

##### 6.1-16 KernelObjectFunctorial

`‣ KernelObjectFunctorial`( alpha, mu, alpha_prime ) | ( operation )

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

The arguments are three morphisms \alpha: A \rightarrow B, \mu: A \rightarrow A', \alpha': A' \rightarrow B'. The output is the morphism \mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' ) given by the functoriality of the kernel.

##### 6.1-17 KernelObjectFunctorialWithGivenKernelObjects

`‣ KernelObjectFunctorialWithGivenKernelObjects`( s, alpha, mu, alpha_prime, r ) | ( operation )

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

The arguments are an object s = \mathrm{KernelObject}( \alpha ), three morphisms \alpha: A \rightarrow B, \mu: A \rightarrow A', \alpha': A' \rightarrow B', and an object r = \mathrm{KernelObject}( \alpha' ). The output is the morphism \mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' ) given by the functoriality of the kernel.

##### 6.1-18 KernelObjectFunctorialWithGivenKernelObjects

`‣ KernelObjectFunctorialWithGivenKernelObjects`( s, alpha, mu, nu, alpha_prime, r ) | ( operation )

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

The arguments are an object s = \mathrm{KernelObject}( \alpha ), four morphisms \alpha: A \rightarrow B, \mu: A \rightarrow A', \nu: B \rightarrow B', \alpha': A' \rightarrow B', and an object r = \mathrm{KernelObject}( \alpha' ). The output is the morphism \mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' ) given by the functoriality of the kernel.

##### 6.1-19 AddKernelObjectFunctorialWithGivenKernelObjects

`‣ AddKernelObjectFunctorialWithGivenKernelObjects`( 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 `KernelObjectFunctorialWithGivenKernelObjects`. F: (\mathrm{KernelObject}( \alpha ), \alpha, \mu, \alpha', \mathrm{KernelObject}( \alpha' )) \mapsto (\mathrm{KernelObject}( \alpha ) \rightarrow \mathrm{KernelObject}( \alpha' )).

#### 6.2 Cokernel

For a given morphism \alpha: A \rightarrow B, a cokernel of \alpha consists of three parts:

- an object K,

- a morphism \epsilon: B \rightarrow K such that \epsilon \circ \alpha \sim_{A,K} 0,

- a dependent function u mapping each \tau: B \rightarrow T satisfying \tau \circ \alpha \sim_{A, T} 0 to a morphism u(\tau):K \rightarrow T such that u(\tau) \circ \epsilon \sim_{B,T} \tau.

The triple ( K, \epsilon, u ) is called a cokernel of \alpha if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object K of such a triple by \mathrm{CokernelObject}(\alpha). We say that the morphism u(\tau) is induced by the universal property of the cokernel. \\ \mathrm{CokernelObject} is a functorial operation. This means: for \mu: A \rightarrow A', \nu: B \rightarrow B', \alpha: A \rightarrow B, \alpha': A' \rightarrow B' such that \nu \circ \alpha \sim_{A,B'} \alpha' \circ \mu, we obtain a morphism \mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' ).

##### 6.2-1 CokernelObject

`‣ CokernelObject`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha: A \rightarrow B. The output is the cokernel K of \alpha.

##### 6.2-2 CokernelProjection

`‣ CokernelProjection`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the cokernel projection \epsilon: B \rightarrow \mathrm{CokernelObject}( \alpha ).

##### 6.2-3 CokernelProjectionWithGivenCokernelObject

`‣ CokernelProjectionWithGivenCokernelObject`( alpha, K ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and an object K = \mathrm{CokernelObject}(\alpha). The output is the cokernel projection \epsilon: B \rightarrow \mathrm{CokernelObject}( \alpha ).

##### 6.2-4 MorphismFromSourceToCokernelObject

`‣ MorphismFromSourceToCokernelObject`( alpha ) | ( operation )

Returns: the zero morphism in \mathrm{Hom}( A, \mathrm{CokernelObject}( \alpha ) ).

The argument is a morphism \alpha: A \rightarrow B. The output is the zero morphism 0: A \rightarrow \mathrm{CokernelObject}(\alpha).

##### 6.2-5 MorphismFromSourceToCokernelObjectWithGivenCokernelObject

`‣ MorphismFromSourceToCokernelObjectWithGivenCokernelObject`( alpha, K ) | ( operation )

Returns: the zero morphism in \mathrm{Hom}( A, K ).

The argument is a morphism \alpha: A \rightarrow B and an object K = \mathrm{CokernelObject}(\alpha). The output is the zero morphism 0: A \rightarrow K.

##### 6.2-6 CokernelColift

`‣ CokernelColift`( alpha, tau ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and a test morphism \tau: B \rightarrow T satisfying \tau \circ \alpha \sim_{A, T} 0. The output is the morphism u(\tau): \mathrm{CokernelObject}(\alpha) \rightarrow T given by the universal property of the cokernel.

##### 6.2-7 CokernelColiftWithGivenCokernelObject

`‣ CokernelColiftWithGivenCokernelObject`( alpha, tau, K ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B, a test morphism \tau: B \rightarrow T satisfying \tau \circ \alpha \sim_{A, T} 0, and an object K = \mathrm{CokernelObject}(\alpha). The output is the morphism u(\tau): K \rightarrow T given by the universal property of the cokernel.

##### 6.2-8 AddCokernelObject

`‣ AddCokernelObject`( 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 `CokernelObject`. F: \alpha \mapsto K.

##### 6.2-9 AddCokernelProjection

`‣ AddCokernelProjection`( 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 `CokernelProjection`. F: \alpha \mapsto \epsilon.

##### 6.2-10 AddCokernelProjectionWithGivenCokernelObject

`‣ AddCokernelProjectionWithGivenCokernelObject`( 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 `CokernelProjection`. F: (\alpha, K) \mapsto \epsilon.

##### 6.2-11 AddMorphismFromSourceToCokernelObject

`‣ AddMorphismFromSourceToCokernelObject`( 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 `MorphismFromSourceToCokernelObject`. F: \alpha \mapsto \mu

##### 6.2-12 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject

`‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject`( 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 `MorphismFromSourceToCokernelObjectWithGivenCokernelObject`. F: ( \alpha, K ) \mapsto \mu

##### 6.2-13 AddCokernelColift

`‣ AddCokernelColift`( 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 `CokernelProjection`. F: (\alpha, \tau) \mapsto u(\tau).

##### 6.2-14 AddCokernelColiftWithGivenCokernelObject

`‣ AddCokernelColiftWithGivenCokernelObject`( 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 `CokernelProjection`. F: (\alpha, \tau, K) \mapsto u(\tau).

##### 6.2-15 CokernelObjectFunctorial

`‣ CokernelObjectFunctorial`( L ) | ( operation )

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

The argument is a list L = [ \alpha: A \rightarrow B, [ \mu:A \rightarrow A', \nu: B \rightarrow B' ], \alpha': A' \rightarrow B' ]. The output is the morphism \mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' ) given by the functoriality of the cokernel.

##### 6.2-16 CokernelObjectFunctorial

`‣ CokernelObjectFunctorial`( alpha, nu, alpha_prime ) | ( operation )

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

The arguments are three morphisms \alpha: A \rightarrow B, \nu: B \rightarrow B', \alpha': A' \rightarrow B'. The output is the morphism \mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' ) given by the functoriality of the cokernel.

##### 6.2-17 CokernelObjectFunctorialWithGivenCokernelObjects

`‣ CokernelObjectFunctorialWithGivenCokernelObjects`( s, alpha, nu, alpha_prime, r ) | ( operation )

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

The arguments are an object s = \mathrm{CokernelObject}( \alpha ), three morphisms \alpha: A \rightarrow B, \nu: B \rightarrow B', \alpha': A' \rightarrow B', and an object r = \mathrm{CokernelObject}( \alpha' ). The output is the morphism \mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' ) given by the functoriality of the cokernel.

##### 6.2-18 CokernelObjectFunctorialWithGivenCokernelObjects

`‣ CokernelObjectFunctorialWithGivenCokernelObjects`( s, alpha, mu, nu, alpha_prime, r ) | ( operation )

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

The arguments are an object s = \mathrm{CokernelObject}( \alpha ), four morphisms \alpha: A \rightarrow B, \mu: A \rightarrow A', \nu: B \rightarrow B', \alpha': A' \rightarrow B', and an object r = \mathrm{CokernelObject}( \alpha' ). The output is the morphism \mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' ) given by the functoriality of the cokernel.

##### 6.2-19 AddCokernelObjectFunctorialWithGivenCokernelObjects

`‣ AddCokernelObjectFunctorialWithGivenCokernelObjects`( 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 `CokernelObjectFunctorialWithGivenCokernelObjects`. F: (\mathrm{CokernelObject}( \alpha ), \alpha, \nu, \alpha', \mathrm{CokernelObject}( \alpha' )) \mapsto (\mathrm{CokernelObject}( \alpha ) \rightarrow \mathrm{CokernelObject}( \alpha' )).

#### 6.3 Zero Object

A zero object consists of three parts:

- an object Z,

- a function u_{\mathrm{in}} mapping each object A to a morphism u_{\mathrm{in}}(A): A \rightarrow Z,

- a function u_{\mathrm{out}} mapping each object A to a morphism u_{\mathrm{out}}(A): Z \rightarrow A.

The triple (Z, u_{\mathrm{in}}, u_{\mathrm{out}}) is called a zero object if the morphisms u_{\mathrm{in}}(A), u_{\mathrm{out}}(A) are uniquely determined up to congruence of morphisms. We denote the object Z of such a triple by \mathrm{ZeroObject}. We say that the morphisms u_{\mathrm{in}}(A) and u_{\mathrm{out}}(A) are induced by the universal property of the zero object.

##### 6.3-1 ZeroObject

`‣ ZeroObject`( C ) | ( attribute )

Returns: an object

The argument is a category C. The output is a zero object Z of C.

##### 6.3-2 ZeroObject

`‣ ZeroObject`( c ) | ( attribute )

Returns: an object

This is a convenience method. The argument is a cell c. The output is a zero object Z of the category C for which c \in C.

##### 6.3-3 MorphismFromZeroObject

`‣ MorphismFromZeroObject`( A ) | ( attribute )

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

This is a convenience method. The argument is an object A. It calls \mathrm{UniversalMorphismFromZeroObject} on A.

##### 6.3-4 MorphismIntoZeroObject

`‣ MorphismIntoZeroObject`( A ) | ( attribute )

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

This is a convenience method. The argument is an object A. It calls \mathrm{UniversalMorphismIntoZeroObject} on A.

##### 6.3-5 UniversalMorphismFromZeroObject

`‣ UniversalMorphismFromZeroObject`( A ) | ( attribute )

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

The argument is an object A. The output is the universal morphism u_{\mathrm{out}}: \mathrm{ZeroObject} \rightarrow A.

##### 6.3-6 UniversalMorphismFromZeroObjectWithGivenZeroObject

`‣ UniversalMorphismFromZeroObjectWithGivenZeroObject`( A, Z ) | ( operation )

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

The arguments are an object A, and a zero object Z = \mathrm{ZeroObject}. The output is the universal morphism u_{\mathrm{out}}: Z \rightarrow A.

##### 6.3-7 UniversalMorphismIntoZeroObject

`‣ UniversalMorphismIntoZeroObject`( A ) | ( attribute )

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

The argument is an object A. The output is the universal morphism u_{\mathrm{in}}: A \rightarrow \mathrm{ZeroObject}.

##### 6.3-8 UniversalMorphismIntoZeroObjectWithGivenZeroObject

`‣ UniversalMorphismIntoZeroObjectWithGivenZeroObject`( A, Z ) | ( operation )

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

The arguments are an object A, and a zero object Z = \mathrm{ZeroObject}. The output is the universal morphism u_{\mathrm{in}}: A \rightarrow Z.

##### 6.3-9 IsomorphismFromZeroObjectToInitialObject

`‣ IsomorphismFromZeroObjectToInitialObject`( C ) | ( attribute )

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

The argument is a category C. The output is the unique isomorphism \mathrm{ZeroObject} \rightarrow \mathrm{InitialObject}.

##### 6.3-10 IsomorphismFromInitialObjectToZeroObject

`‣ IsomorphismFromInitialObjectToZeroObject`( C ) | ( attribute )

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

The argument is a category C. The output is the unique isomorphism \mathrm{InitialObject} \rightarrow \mathrm{ZeroObject}.

##### 6.3-11 IsomorphismFromZeroObjectToTerminalObject

`‣ IsomorphismFromZeroObjectToTerminalObject`( C ) | ( attribute )

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

The argument is a category C. The output is the unique isomorphism \mathrm{ZeroObject} \rightarrow \mathrm{TerminalObject}.

##### 6.3-12 IsomorphismFromTerminalObjectToZeroObject

`‣ IsomorphismFromTerminalObjectToZeroObject`( C ) | ( attribute )

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

The argument is a category C. The output is the unique isomorphism \mathrm{TerminalObject} \rightarrow \mathrm{ZeroObject}.

##### 6.3-13 AddZeroObject

`‣ AddZeroObject`( 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 `ZeroObject`. F: () \mapsto \mathrm{ZeroObject}.

##### 6.3-14 AddUniversalMorphismIntoZeroObject

`‣ AddUniversalMorphismIntoZeroObject`( 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 `UniversalMorphismIntoZeroObject`. F: A \mapsto u_{\mathrm{in}}(A).

##### 6.3-15 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject

`‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject`( 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 `UniversalMorphismIntoZeroObjectWithGivenZeroObject`. F: (A, Z) \mapsto u_{\mathrm{in}}(A).

##### 6.3-16 AddUniversalMorphismFromZeroObject

`‣ AddUniversalMorphismFromZeroObject`( 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 `UniversalMorphismFromZeroObject`. F: A \mapsto u_{\mathrm{out}}(A).

##### 6.3-17 AddUniversalMorphismFromZeroObjectWithGivenZeroObject

`‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject`( 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 `UniversalMorphismFromZeroObjectWithGivenZeroObject`. F: (A,Z) \mapsto u_{\mathrm{out}}(A).

##### 6.3-18 AddIsomorphismFromZeroObjectToInitialObject

`‣ AddIsomorphismFromZeroObjectToInitialObject`( 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 `IsomorphismFromZeroObjectToInitialObject`. F: () \mapsto (\mathrm{ZeroObject} \rightarrow \mathrm{InitialObject}).

##### 6.3-19 AddIsomorphismFromInitialObjectToZeroObject

`‣ AddIsomorphismFromInitialObjectToZeroObject`( 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 `IsomorphismFromInitialObjectToZeroObject`. F: () \mapsto ( \mathrm{InitialObject} \rightarrow \mathrm{ZeroObject}).

##### 6.3-20 AddIsomorphismFromZeroObjectToTerminalObject

`‣ AddIsomorphismFromZeroObjectToTerminalObject`( 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 `IsomorphismFromZeroObjectToTerminalObject`. F: () \mapsto (\mathrm{ZeroObject} \rightarrow \mathrm{TerminalObject}).

##### 6.3-21 AddIsomorphismFromTerminalObjectToZeroObject

`‣ AddIsomorphismFromTerminalObjectToZeroObject`( 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 `IsomorphismFromTerminalObjectToZeroObject`. F: () \mapsto ( \mathrm{TerminalObject} \rightarrow \mathrm{ZeroObject}).

##### 6.3-22 ZeroObjectFunctorial

`‣ ZeroObjectFunctorial`( C ) | ( attribute )

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

The argument is a category C. The output is the unique morphism \mathrm{ZeroObject} \rightarrow \mathrm{ZeroObject}.

##### 6.3-23 AddZeroObjectFunctorial

`‣ AddZeroObjectFunctorial`( 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 `ZeroObjectFunctorial`. F: () \mapsto (T \rightarrow T).

#### 6.4 Terminal Object

A terminal object consists of two parts:

- an object T,

- a function u mapping each object A to a morphism u( A ): A \rightarrow T.

The pair ( T, u ) is called a terminal object if the morphisms u( A ) are uniquely determined up to congruence of morphisms. We denote the object T of such a pair by \mathrm{TerminalObject}. We say that the morphism u( A ) is induced by the universal property of the terminal object. \\ \mathrm{TerminalObject} is a functorial operation. This just means: There exists a unique morphism T \rightarrow T.

##### 6.4-1 TerminalObject

`‣ TerminalObject`( C ) | ( attribute )

Returns: an object

The argument is a category C. The output is a terminal object T of C.

##### 6.4-2 TerminalObject

`‣ TerminalObject`( c ) | ( attribute )

Returns: an object

This is a convenience method. The argument is a cell c. The output is a terminal object T of the category C for which c \in C.

##### 6.4-3 UniversalMorphismIntoTerminalObject

`‣ UniversalMorphismIntoTerminalObject`( A ) | ( attribute )

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

The argument is an object A. The output is the universal morphism u(A): A \rightarrow \mathrm{TerminalObject}.

##### 6.4-4 UniversalMorphismIntoTerminalObjectWithGivenTerminalObject

`‣ UniversalMorphismIntoTerminalObjectWithGivenTerminalObject`( A, T ) | ( operation )

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

The argument are an object A, and an object T = \mathrm{TerminalObject}. The output is the universal morphism u(A): A \rightarrow T.

##### 6.4-5 AddTerminalObject

`‣ AddTerminalObject`( 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 `TerminalObject`. F: () \mapsto T.

##### 6.4-6 AddUniversalMorphismIntoTerminalObject

`‣ AddUniversalMorphismIntoTerminalObject`( 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 `UniversalMorphismIntoTerminalObject`. F: A \mapsto u(A).

##### 6.4-7 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject

`‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject`( 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 `UniversalMorphismIntoTerminalObjectWithGivenTerminalObject`. F: (A,T) \mapsto u(A).

##### 6.4-8 TerminalObjectFunctorial

`‣ TerminalObjectFunctorial`( C ) | ( attribute )

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

The argument is a category C. The output is the unique morphism \mathrm{TerminalObject} \rightarrow \mathrm{TerminalObject}.

##### 6.4-9 AddTerminalObjectFunctorial

`‣ AddTerminalObjectFunctorial`( 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 `TerminalObjectFunctorial`. F: () \mapsto (T \rightarrow T).

#### 6.5 Initial Object

An initial object consists of two parts:

- an object I,

- a function u mapping each object A to a morphism u( A ): I \rightarrow A.

The pair (I,u) is called a initial object if the morphisms u(A) are uniquely determined up to congruence of morphisms. We denote the object I of such a triple by \mathrm{InitialObject}. We say that the morphism u( A ) is induced by the universal property of the initial object. \\ \mathrm{InitialObject} is a functorial operation. This just means: There exists a unique morphisms I \rightarrow I.

##### 6.5-1 InitialObject

`‣ InitialObject`( C ) | ( attribute )

Returns: an object

The argument is a category C. The output is an initial object I of C.

##### 6.5-2 InitialObject

`‣ InitialObject`( c ) | ( attribute )

Returns: an object

This is a convenience method. The argument is a cell c. The output is an initial object I of the category C for which c \in C.

##### 6.5-3 UniversalMorphismFromInitialObject

`‣ UniversalMorphismFromInitialObject`( A ) | ( attribute )

Returns: a morphism in \mathrm{Hom}(\mathrm{InitialObject} \rightarrow A).

The argument is an object A. The output is the universal morphism u(A): \mathrm{InitialObject} \rightarrow A.

##### 6.5-4 UniversalMorphismFromInitialObjectWithGivenInitialObject

`‣ UniversalMorphismFromInitialObjectWithGivenInitialObject`( A, I ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\mathrm{InitialObject} \rightarrow A).

The arguments are an object A, and an object I = \mathrm{InitialObject}. The output is the universal morphism u(A): \mathrm{InitialObject} \rightarrow A.

##### 6.5-5 AddInitialObject

`‣ AddInitialObject`( 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 `InitialObject`. F: () \mapsto I.

##### 6.5-6 AddUniversalMorphismFromInitialObject

`‣ AddUniversalMorphismFromInitialObject`( 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 `UniversalMorphismFromInitialObject`. F: A \mapsto u(A).

##### 6.5-7 AddUniversalMorphismFromInitialObjectWithGivenInitialObject

`‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject`( 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 `UniversalMorphismFromInitialObjectWithGivenInitialObject`. F: (A,I) \mapsto u(A).

##### 6.5-8 InitialObjectFunctorial

`‣ InitialObjectFunctorial`( C ) | ( attribute )

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

The argument is a category C. The output is the unique morphism \mathrm{InitialObject} \rightarrow \mathrm{InitialObject}.

##### 6.5-9 AddInitialObjectFunctorial

`‣ AddInitialObjectFunctorial`( 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 `InitialObjectFunctorial`. F: () \rightarrow ( I \rightarrow I ).

#### 6.6 Direct Sum

For an integer n \geq 1 and a given list D = (S_1, \dots, S_n) in an Ab-category, a direct sum consists of five parts:

- an object S,

- a list of morphisms \pi = (\pi_i: S \rightarrow S_i)_{i = 1 \dots n},

- a list of morphisms \iota = (\iota_i: S_i \rightarrow S)_{i = 1 \dots n},

- a dependent function u_{\mathrm{in}} mapping every list \tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n} to a morphism u_{\mathrm{in}}(\tau): T \rightarrow S such that \pi_i \circ u_{\mathrm{in}}(\tau) \sim_{T,S_i} \tau_i for all i = 1, \dots, n.

- a dependent function u_{\mathrm{out}} mapping every list \tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n} to a morphism u_{\mathrm{out}}(\tau): S \rightarrow T such that u_{\mathrm{out}}(\tau) \circ \iota_i \sim_{S_i, T} \tau_i for all i = 1, \dots, n,

such that

- \sum_{i=1}^{n} \iota_i \circ \pi_i \sim_{S,S} \mathrm{id}_S,

- \pi_j \circ \iota_i \sim_{S_i, S_j} \delta_{i,j},

where \delta_{i,j} \in \mathrm{Hom}( S_i, S_j ) is the identity if i=j, and 0 otherwise. The 5-tuple (S, \pi, \iota, u_{\mathrm{in}}, u_{\mathrm{out}}) is called a direct sum of D. We denote the object S of such a 5-tuple by \bigoplus_{i=1}^n S_i. We say that the morphisms u_{\mathrm{in}}(\tau), u_{\mathrm{out}}(\tau) are induced by the universal property of the direct sum. \\ \mathrm{DirectSum} is a functorial operation. This means: For (\mu_i: S_i \rightarrow S'_i)_{i=1\dots n}, we obtain a morphism \bigoplus_{i=1}^n S_i \rightarrow \bigoplus_{i=1}^n S_i'.

##### 6.6-1 DirectSumOp

`‣ DirectSumOp`( D, method_selection_object ) | ( operation )

Returns: an object

The argument is a list of objects D = (S_1, \dots, S_n) and an object for method selection. The output is the direct sum \bigoplus_{i=1}^n S_i.

##### 6.6-2 ProjectionInFactorOfDirectSum

`‣ ProjectionInFactorOfDirectSum`( D, k ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, S_k )

The arguments are a list of objects D = (S_1, \dots, S_n) and an integer k. The output is the k-th projection \pi_k: \bigoplus_{i=1}^n S_i \rightarrow S_k.

##### 6.6-3 ProjectionInFactorOfDirectSumOp

`‣ ProjectionInFactorOfDirectSumOp`( D, k, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, S_k )

The arguments are a list of objects D = (S_1, \dots, S_n), an integer k, and an object for method selection. The output is the k-th projection \pi_k: \bigoplus_{i=1}^n S_i \rightarrow S_k.

##### 6.6-4 ProjectionInFactorOfDirectSumWithGivenDirectSum

`‣ ProjectionInFactorOfDirectSumWithGivenDirectSum`( D, k, S ) | ( operation )

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

The arguments are a list of objects D = (S_1, \dots, S_n), an integer k, and an object S = \bigoplus_{i=1}^n S_i. The output is the k-th projection \pi_k: S \rightarrow S_k.

##### 6.6-5 InjectionOfCofactorOfDirectSum

`‣ InjectionOfCofactorOfDirectSum`( D, k ) | ( operation )

Returns: a morphism in \mathrm{Hom}( S_k, \bigoplus_{i=1}^n S_i )

The arguments are a list of objects D = (S_1, \dots, S_n) and an integer k. The output is the k-th injection \iota_k: S_k \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-6 InjectionOfCofactorOfDirectSumOp

`‣ InjectionOfCofactorOfDirectSumOp`( D, k, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( S_k, \bigoplus_{i=1}^n S_i )

The arguments are a list of objects D = (S_1, \dots, S_n), an integer k, and an object for method selection. The output is the k-th injection \iota_k: S_k \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-7 InjectionOfCofactorOfDirectSumWithGivenDirectSum

`‣ InjectionOfCofactorOfDirectSumWithGivenDirectSum`( D, k, S ) | ( operation )

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

The arguments are a list of objects D = (S_1, \dots, S_n), an integer k, and an object S = \bigoplus_{i=1}^n S_i. The output is the k-th injection \iota_k: S_k \rightarrow S.

##### 6.6-8 UniversalMorphismIntoDirectSum

`‣ UniversalMorphismIntoDirectSum`( arg ) | ( function )

Returns: a morphism in \mathrm{Hom}(T, \bigoplus_{i=1}^n S_i)

This is a convenience method. There are three different ways to use this method:

- The arguments are a list of objects D = (S_1, \dots, S_n) and a list of morphisms \tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n}.

- The argument is a list of morphisms \tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n}.

- The arguments are morphisms \tau_1: T \rightarrow S_1, \dots, \tau_n: T \rightarrow S_n.

The output is the morphism u_{\mathrm{in}}(\tau): T \rightarrow \bigoplus_{i=1}^n S_i given by the universal property of the direct sum.

##### 6.6-9 UniversalMorphismIntoDirectSumOp

`‣ UniversalMorphismIntoDirectSumOp`( D, tau, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(T, \bigoplus_{i=1}^n S_i)

The arguments are a list of objects D = (S_1, \dots, S_n), a list of morphisms \tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n}, and an object for method selection. The output is the morphism u_{\mathrm{in}}(\tau): T \rightarrow \bigoplus_{i=1}^n S_i given by the universal property of the direct sum.

##### 6.6-10 UniversalMorphismIntoDirectSumWithGivenDirectSum

`‣ UniversalMorphismIntoDirectSumWithGivenDirectSum`( D, tau, S ) | ( operation )

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

The arguments are a list of objects D = (S_1, \dots, S_n), a list of morphisms \tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n}, and an object S = \bigoplus_{i=1}^n S_i. The output is the morphism u_{\mathrm{in}}(\tau): T \rightarrow S given by the universal property of the direct sum.

##### 6.6-11 UniversalMorphismFromDirectSum

`‣ UniversalMorphismFromDirectSum`( arg ) | ( function )

Returns: a morphism in \mathrm{Hom}(\bigoplus_{i=1}^n S_i, T)

This is a convenience method. There are three different ways to use this method:

- The arguments are a list of objects D = (S_1, \dots, S_n) and a list of morphisms \tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n}.

- The argument is a list of morphisms \tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n}.

- The arguments are morphisms S_1 \rightarrow T, \dots, S_n \rightarrow T.

The output is the morphism u_{\mathrm{out}}(\tau): \bigoplus_{i=1}^n S_i \rightarrow T given by the universal property of the direct sum.

##### 6.6-12 UniversalMorphismFromDirectSumOp

`‣ UniversalMorphismFromDirectSumOp`( D, tau, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\bigoplus_{i=1}^n S_i, T)

The arguments are a list of objects D = (S_1, \dots, S_n), a list of morphisms \tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n}, and an object for method selection. The output is the morphism u_{\mathrm{out}}(\tau): \bigoplus_{i=1}^n S_i \rightarrow T given by the universal property of the direct sum.

##### 6.6-13 UniversalMorphismFromDirectSumWithGivenDirectSum

`‣ UniversalMorphismFromDirectSumWithGivenDirectSum`( D, tau, S ) | ( operation )

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

The arguments are a list of objects D = (S_1, \dots, S_n), a list of morphisms \tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n}, and an object S = \bigoplus_{i=1}^n S_i. The output is the morphism u_{\mathrm{out}}(\tau): S \rightarrow T given by the universal property of the direct sum.

##### 6.6-14 IsomorphismFromDirectSumToDirectProduct

`‣ IsomorphismFromDirectSumToDirectProduct`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, \prod_{i=1}^{n}S_i )

The argument is a list of objects D = (S_1, \dots, S_n). The output is the canonical isomorphism \bigoplus_{i=1}^n S_i \rightarrow \prod_{i=1}^{n}S_i.

##### 6.6-15 IsomorphismFromDirectSumToDirectProductOp

`‣ IsomorphismFromDirectSumToDirectProductOp`( D, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, \prod_{i=1}^{n}S_i )

The arguments are a list of objects D = (S_1, \dots, S_n) and an object for method selection. The output is the canonical isomorphism \bigoplus_{i=1}^n S_i \rightarrow \prod_{i=1}^{n}S_i.

##### 6.6-16 IsomorphismFromDirectProductToDirectSum

`‣ IsomorphismFromDirectProductToDirectSum`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \prod_{i=1}^{n}S_i, \bigoplus_{i=1}^n S_i )

The argument is a list of objects D = (S_1, \dots, S_n). The output is the canonical isomorphism \prod_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-17 IsomorphismFromDirectProductToDirectSumOp

`‣ IsomorphismFromDirectProductToDirectSumOp`( D, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \prod_{i=1}^{n}S_i, \bigoplus_{i=1}^n S_i )

The argument is a list of objects D = (S_1, \dots, S_n) and an object for method selection. The output is the canonical isomorphism \prod_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-18 IsomorphismFromDirectSumToCoproduct

`‣ IsomorphismFromDirectSumToCoproduct`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, \bigsqcup_{i=1}^{n}S_i )

The argument is a list of objects D = (S_1, \dots, S_n). The output is the canonical isomorphism \bigoplus_{i=1}^n S_i \rightarrow \bigsqcup_{i=1}^{n}S_i.

##### 6.6-19 IsomorphismFromDirectSumToCoproductOp

`‣ IsomorphismFromDirectSumToCoproductOp`( D, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, \bigsqcup_{i=1}^{n}S_i )

The argument is a list of objects D = (S_1, \dots, S_n) and an object for method selection. The output is the canonical isomorphism \bigoplus_{i=1}^n S_i \rightarrow \bigsqcup_{i=1}^{n}S_i.

##### 6.6-20 IsomorphismFromCoproductToDirectSum

`‣ IsomorphismFromCoproductToDirectSum`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigsqcup_{i=1}^{n}S_i, \bigoplus_{i=1}^n S_i )

The argument is a list of objects D = (S_1, \dots, S_n). The output is the canonical isomorphism \bigsqcup_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-21 IsomorphismFromCoproductToDirectSumOp

`‣ IsomorphismFromCoproductToDirectSumOp`( D, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigsqcup_{i=1}^{n}S_i, \bigoplus_{i=1}^n S_i )

The argument is a list of objects D = (S_1, \dots, S_n) and an object for method selection. The output is the canonical isomorphism \bigsqcup_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i.

##### 6.6-22 MorphismBetweenDirectSums

`‣ MorphismBetweenDirectSums`( M ) | ( operation )

`‣ MorphismBetweenDirectSums`( S, M, T ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\bigoplus_{i=1}^{m}A_i, \bigoplus_{j=1}^n B_j)

The argument M = ( ( \phi_{i,j}: A_i \rightarrow B_j )_{j = 1 \dots n} )_{i = 1 \dots m} is a list of lists of morphisms. The output is the morphism \bigoplus_{i=1}^{m}A_i \rightarrow \bigoplus_{j=1}^n B_j defined by the matrix M. The extra arguments S = \bigoplus_{i=1}^{m}A_i and T = \bigoplus_{j=1}^n B_j are source and target of the output, respectively. They must be provided in case M is an empty list or a list of empty lists.

##### 6.6-23 AddMorphismBetweenDirectSums

`‣ AddMorphismBetweenDirectSums`( 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 `MorphismBetweenDirectSums`. F: (\bigoplus_{i=1}^{m}A_i, M, \bigoplus_{j=1}^n B_j) \mapsto (\bigoplus_{i=1}^{m}A_i \rightarrow \bigoplus_{j=1}^n B_j).

##### 6.6-24 MorphismBetweenDirectSumsOp

`‣ MorphismBetweenDirectSumsOp`( M, m, n, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\bigoplus_{i=1}^{m}A_i, \bigoplus_{j=1}^n B_j)

The arguments are a list M = ( \phi_{1,1}, \phi_{1,2}, \dots, \phi_{1,n}, \phi_{2,1}, \dots, \phi_{m,n} ) of morphisms \phi_{i,j}: A_i \rightarrow B_j, an integer m, an integer n, and a method selection morphism. The output is the morphism \bigoplus_{i=1}^{m}A_i \rightarrow \bigoplus_{j=1}^n B_j defined by the list M regarded as a matrix of dimension m \times n.

##### 6.6-25 ComponentOfMorphismIntoDirectSum

`‣ ComponentOfMorphismIntoDirectSum`( alpha, D, k ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow S, a list D = (S_1, \dots, S_n) of objects with S = \bigoplus_{j=1}^n S_j, and an integer k. The output is the component morphism A \rightarrow S_k.

##### 6.6-26 ComponentOfMorphismFromDirectSum

`‣ ComponentOfMorphismFromDirectSum`( alpha, D, k ) | ( operation )

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

The arguments are a morphism \alpha: S \rightarrow A, a list D = (S_1, \dots, S_n) of objects with S = \bigoplus_{j=1}^n S_j, and an integer k. The output is the component morphism S_k \rightarrow A.

##### 6.6-27 AddComponentOfMorphismIntoDirectSum

`‣ AddComponentOfMorphismIntoDirectSum`( 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 `ComponentOfMorphismIntoDirectSum`. F: (\alpha: A \rightarrow S,D,k) \mapsto (A \rightarrow S_k).

##### 6.6-28 AddComponentOfMorphismFromDirectSum

`‣ AddComponentOfMorphismFromDirectSum`( 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 `ComponentOfMorphismFromDirectSum`. F: (\alpha: S \rightarrow A,D,k) \mapsto (S_k \rightarrow A).

##### 6.6-29 AddProjectionInFactorOfDirectSum

`‣ AddProjectionInFactorOfDirectSum`( 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 `ProjectionInFactorOfDirectSum`. F: (D,k) \mapsto \pi_{k}.

##### 6.6-30 AddProjectionInFactorOfDirectSumWithGivenDirectSum

`‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum`( 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 `ProjectionInFactorOfDirectSumWithGivenDirectSum`. F: (D,k,S) \mapsto \pi_{k}.

##### 6.6-31 AddInjectionOfCofactorOfDirectSum

`‣ AddInjectionOfCofactorOfDirectSum`( 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 `InjectionOfCofactorOfDirectSum`. F: (D,k) \mapsto \iota_{k}.

##### 6.6-32 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum

`‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum`( 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 `InjectionOfCofactorOfDirectSumWithGivenDirectSum`. F: (D,k,S) \mapsto \iota_{k}.

##### 6.6-33 AddUniversalMorphismIntoDirectSum

`‣ AddUniversalMorphismIntoDirectSum`( 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 `UniversalMorphismIntoDirectSum`. F: (D,\tau) \mapsto u_{\mathrm{in}}(\tau).

##### 6.6-34 AddUniversalMorphismIntoDirectSumWithGivenDirectSum

`‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum`( 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 `UniversalMorphismIntoDirectSumWithGivenDirectSum`. F: (D,\tau,S) \mapsto u_{\mathrm{in}}(\tau).

##### 6.6-35 AddUniversalMorphismFromDirectSum

`‣ AddUniversalMorphismFromDirectSum`( 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 `UniversalMorphismFromDirectSum`. F: (D,\tau) \mapsto u_{\mathrm{out}}(\tau).

##### 6.6-36 AddUniversalMorphismFromDirectSumWithGivenDirectSum

`‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum`( 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 `UniversalMorphismFromDirectSumWithGivenDirectSum`. F: (D,\tau,S) \mapsto u_{\mathrm{out}}(\tau).

##### 6.6-37 AddIsomorphismFromDirectSumToDirectProduct

`‣ AddIsomorphismFromDirectSumToDirectProduct`( 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 `IsomorphismFromDirectSumToDirectProduct`. F: D \mapsto (\bigoplus_{i=1}^n S_i \rightarrow \prod_{i=1}^{n}S_i).

##### 6.6-38 AddIsomorphismFromDirectProductToDirectSum

`‣ AddIsomorphismFromDirectProductToDirectSum`( 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 `IsomorphismFromDirectProductToDirectSum`. F: D \mapsto ( \prod_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i ).

##### 6.6-39 AddIsomorphismFromDirectSumToCoproduct

`‣ AddIsomorphismFromDirectSumToCoproduct`( 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 `IsomorphismFromDirectSumToCoproduct`. F: D \mapsto ( \bigoplus_{i=1}^n S_i \rightarrow \bigsqcup_{i=1}^{n}S_i ).

##### 6.6-40 AddIsomorphismFromCoproductToDirectSum

`‣ AddIsomorphismFromCoproductToDirectSum`( 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 `IsomorphismFromCoproductToDirectSum`. F: D \mapsto ( \bigsqcup_{i=1}^{n}S_i \rightarrow \bigoplus_{i=1}^n S_i ).

##### 6.6-41 AddDirectSum

`‣ AddDirectSum`( 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 `DirectSum`. F: D \mapsto \bigoplus_{i=1}^n S_i.

##### 6.6-42 DirectSumFunctorial

`‣ DirectSumFunctorial`( L ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n S_i, \bigoplus_{i=1}^n S_i' )

The argument is a list of morphisms L = ( \mu_1: S_1 \rightarrow S_1', \dots, \mu_n: S_n \rightarrow S_n' ). The output is a morphism \bigoplus_{i=1}^n S_i \rightarrow \bigoplus_{i=1}^n S_i' given by the functoriality of the direct sum.

##### 6.6-43 DirectSumFunctorialWithGivenDirectSums

`‣ DirectSumFunctorialWithGivenDirectSums`( d_1, L, d_2 ) | ( operation )

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

The arguments are an object d_1 = \bigoplus_{i=1}^n S_i, a list of morphisms L = ( \mu_1: S_1 \rightarrow S_1', \dots, \mu_n: S_n \rightarrow S_n' ), and an object d_2 = \bigoplus_{i=1}^n S_i'. The output is a morphism d_1 \rightarrow d_2 given by the functoriality of the direct sum.

##### 6.6-44 AddDirectSumFunctorialWithGivenDirectSums

`‣ AddDirectSumFunctorialWithGivenDirectSums`( 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 `DirectSumFunctorialWithGivenDirectSums`. F: (\bigoplus_{i=1}^n S_i, ( \mu_1, \dots, \mu_n ), \bigoplus_{i=1}^n S_i') \mapsto (\bigoplus_{i=1}^n S_i \rightarrow \bigoplus_{i=1}^n S_i').

#### 6.7 Coproduct

For an integer n \geq 1 and a given list of objects D = ( I_1, \dots, I_n ), a coproduct of D consists of three parts:

- an object I,

- a list of morphisms \iota = ( \iota_i: I_i \rightarrow I )_{i = 1 \dots n}

- a dependent function u mapping each list of morphisms \tau = ( \tau_i: I_i \rightarrow T ) to a morphism u( \tau ): I \rightarrow T such that u( \tau ) \circ \iota_i \sim_{I_i, T} \tau_i for all i = 1, \dots, n.

The triple ( I, \iota, u ) is called a coproduct of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object I of such a triple by \bigsqcup_{i=1}^n I_i. We say that the morphism u( \tau ) is induced by the universal property of the coproduct. \\ \mathrm{Coproduct} is a functorial operation. This means: For (\mu_i: I_i \rightarrow I'_i)_{i=1\dots n}, we obtain a morphism \bigsqcup_{i=1}^n I_i \rightarrow \bigsqcup_{i=1}^n I_i'.

##### 6.7-1 Coproduct

`‣ Coproduct`( D ) | ( attribute )

Returns: an object

The argument is a list of objects D = ( I_1, \dots, I_n ). The output is the coproduct \bigsqcup_{i=1}^n I_i.

##### 6.7-2 Coproduct

`‣ Coproduct`( I1, I2 ) | ( operation )

Returns: an object

This is a convenience method. The arguments are two objects I_1, I_2. The output is the coproduct I_1 \bigsqcup I_2.

##### 6.7-3 Coproduct

`‣ Coproduct`( I1, I2 ) | ( operation )

Returns: an object

This is a convenience method. The arguments are three objects I_1, I_2, I_3. The output is the coproduct I_1 \bigsqcup I_2 \bigsqcup I_3.

##### 6.7-4 CoproductOp

`‣ CoproductOp`( D, method_selection_object ) | ( operation )

Returns: an object

The arguments are a list of objects D = ( I_1, \dots, I_n ) and a method selection object. The output is the coproduct \bigsqcup_{i=1}^n I_i.

##### 6.7-5 InjectionOfCofactorOfCoproduct

`‣ InjectionOfCofactorOfCoproduct`( D, k ) | ( operation )

Returns: a morphism in \mathrm{Hom}(I_k, \bigsqcup_{i=1}^n I_i)

The arguments are a list of objects D = ( I_1, \dots, I_n ) and an integer k. The output is the k-th injection \iota_k: I_k \rightarrow \bigsqcup_{i=1}^n I_i.

##### 6.7-6 InjectionOfCofactorOfCoproductOp

`‣ InjectionOfCofactorOfCoproductOp`( D, k, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(I_k, \bigsqcup_{i=1}^n I_i)

The arguments are a list of objects D = ( I_1, \dots, I_n ), an integer k, and a method selection object. The output is the k-th injection \iota_k: I_k \rightarrow \bigsqcup_{i=1}^n I_i.

##### 6.7-7 InjectionOfCofactorOfCoproductWithGivenCoproduct

`‣ InjectionOfCofactorOfCoproductWithGivenCoproduct`( D, k, I ) | ( operation )

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

The arguments are a list of objects D = ( I_1, \dots, I_n ), an integer k, and an object I = \bigsqcup_{i=1}^n I_i. The output is the k-th injection \iota_k: I_k \rightarrow I.

##### 6.7-8 UniversalMorphismFromCoproduct

`‣ UniversalMorphismFromCoproduct`( arg ) | ( function )

Returns: a morphism in \mathrm{Hom}(\bigsqcup_{i=1}^n I_i, T)

This is a convenience method. There are three different ways to use this method.

- The arguments are a list of objects D = ( I_1, \dots, I_n ), a list of morphisms \tau = ( \tau_i: I_i \rightarrow T ).

- The argument is a list of morphisms \tau = ( \tau_i: I_i \rightarrow T ).

- The arguments are morphisms \tau_1: I_1 \rightarrow T, \dots, \tau_n: I_n \rightarrow T

The output is the morphism u( \tau ): \bigsqcup_{i=1}^n I_i \rightarrow T given by the universal property of the coproduct.

##### 6.7-9 UniversalMorphismFromCoproductOp

`‣ UniversalMorphismFromCoproductOp`( D, tau, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\bigsqcup_{i=1}^n I_i, T)

The arguments are a list of objects D = ( I_1, \dots, I_n ), a list of morphisms \tau = ( \tau_i: I_i \rightarrow T ), and a method selection object. The output is the morphism u( \tau ): \bigsqcup_{i=1}^n I_i \rightarrow T given by the universal property of the coproduct.

##### 6.7-10 UniversalMorphismFromCoproductWithGivenCoproduct

`‣ UniversalMorphismFromCoproductWithGivenCoproduct`( D, tau, I ) | ( operation )

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

The arguments are a list of objects D = ( I_1, \dots, I_n ), a list of morphisms \tau = ( \tau_i: I_i \rightarrow T ), and an object I = \bigsqcup_{i=1}^n I_i. The output is the morphism u( \tau ): I \rightarrow T given by the universal property of the coproduct.

##### 6.7-11 AddCoproduct

`‣ AddCoproduct`( 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 `Coproduct`. F: ( (I_1, \dots, I_n) ) \mapsto I.

##### 6.7-12 AddInjectionOfCofactorOfCoproduct

`‣ AddInjectionOfCofactorOfCoproduct`( 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 `InjectionOfCofactorOfCoproduct`. F: ( (I_1, \dots, I_n), i ) \mapsto \iota_i.

##### 6.7-13 AddInjectionOfCofactorOfCoproductWithGivenCoproduct

`‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct`( 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 `InjectionOfCofactorOfCoproductWithGivenCoproduct`. F: ( (I_1, \dots, I_n), i, I ) \mapsto \iota_i.

##### 6.7-14 AddUniversalMorphismFromCoproduct

`‣ AddUniversalMorphismFromCoproduct`( 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 `UniversalMorphismFromCoproduct`. F: ( (I_1, \dots, I_n), \tau ) \mapsto u( \tau ).

##### 6.7-15 AddUniversalMorphismFromCoproductWithGivenCoproduct

`‣ AddUniversalMorphismFromCoproductWithGivenCoproduct`( 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 `UniversalMorphismFromCoproductWithGivenCoproduct`. F: ( (I_1, \dots, I_n), \tau, I ) \mapsto u( \tau ).

##### 6.7-16 CoproductFunctorial

`‣ CoproductFunctorial`( L ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\bigsqcup_{i=1}^n I_i, \bigsqcup_{i=1}^n I_i')

The argument is a list L = ( \mu_1: I_1 \rightarrow I_1', \dots, \mu_n: I_n \rightarrow I_n' ). The output is a morphism \bigsqcup_{i=1}^n I_i \rightarrow \bigsqcup_{i=1}^n I_i' given by the functoriality of the coproduct.

##### 6.7-17 CoproductFunctorialWithGivenCoproducts

`‣ CoproductFunctorialWithGivenCoproducts`( s, L, r ) | ( operation )

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

The arguments are an object s = \bigsqcup_{i=1}^n I_i, a list L = ( \mu_1: I_1 \rightarrow I_1', \dots, \mu_n: I_n \rightarrow I_n' ), and an object r = \bigsqcup_{i=1}^n I_i'. The output is a morphism \bigsqcup_{i=1}^n I_i \rightarrow \bigsqcup_{i=1}^n I_i' given by the functoriality of the coproduct.

##### 6.7-18 AddCoproductFunctorialWithGivenCoproducts

`‣ AddCoproductFunctorialWithGivenCoproducts`( 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 `CoproductFunctorialWithGivenCoproducts`. F: (\bigsqcup_{i=1}^n I_i, (\mu_1, \dots, \mu_n), \bigsqcup_{i=1}^n I_i') \rightarrow (\bigsqcup_{i=1}^n I_i \rightarrow \bigsqcup_{i=1}^n I_i').

#### 6.8 Direct Product

For an integer n \geq 1 and a given list of objects D = ( P_1, \dots, P_n ), a direct product of D consists of three parts:

- an object P,

- a list of morphisms \pi = ( \pi_i: P \rightarrow P_i )_{i = 1 \dots n}

- a dependent function u mapping each list of morphisms \tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n} to a morphism u(\tau): T \rightarrow P such that \pi_i \circ u( \tau ) \sim_{T,P_i} \tau_i for all i = 1, \dots, n.

The triple ( P, \pi, u ) is called a direct product of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object P of such a triple by \prod_{i=1}^n P_i. We say that the morphism u( \tau ) is induced by the universal property of the direct product. \\ \mathrm{DirectProduct} is a functorial operation. This means: For (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}, we obtain a morphism \prod_{i=1}^n P_i \rightarrow \prod_{i=1}^n P_i'.

##### 6.8-1 DirectProductOp

`‣ DirectProductOp`( D ) | ( operation )

Returns: an object

The arguments are a list of objects D = ( P_1, \dots, P_n ) and an object for method selection. The output is the direct product \prod_{i=1}^n P_i.

##### 6.8-2 ProjectionInFactorOfDirectProduct

`‣ ProjectionInFactorOfDirectProduct`( D, k ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\prod_{i=1}^n P_i, P_k)

The arguments are a list of objects D = ( P_1, \dots, P_n ) and an integer k. The output is the k-th projection \pi_k: \prod_{i=1}^n P_i \rightarrow P_k.

##### 6.8-3 ProjectionInFactorOfDirectProductOp

`‣ ProjectionInFactorOfDirectProductOp`( D, k, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\prod_{i=1}^n P_i, P_k)

The arguments are a list of objects D = ( P_1, \dots, P_n ), an integer k, and an object for method selection. The output is the k-th projection \pi_k: \prod_{i=1}^n P_i \rightarrow P_k.

##### 6.8-4 ProjectionInFactorOfDirectProductWithGivenDirectProduct

`‣ ProjectionInFactorOfDirectProductWithGivenDirectProduct`( D, k, P ) | ( operation )

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

The arguments are a list of objects D = ( P_1, \dots, P_n ), an integer k, and an object P = \prod_{i=1}^n P_i. The output is the k-th projection \pi_k: P \rightarrow P_k.

##### 6.8-5 UniversalMorphismIntoDirectProduct

`‣ UniversalMorphismIntoDirectProduct`( arg ) | ( function )

Returns: a morphism in \mathrm{Hom}(T, \prod_{i=1}^n P_i)

This is a convenience method. There are three different ways to use this method.

- The arguments are a list of objects D = ( P_1, \dots, P_n ) and a list of morphisms \tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n}.

- The argument is a list of morphisms \tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n}.

- The arguments are morphisms \tau_1: T \rightarrow P_1, \dots, \tau_n: T \rightarrow P_n.

The output is the morphism u(\tau): T \rightarrow \prod_{i=1}^n P_i given by the universal property of the direct product.

##### 6.8-6 UniversalMorphismIntoDirectProductOp

`‣ UniversalMorphismIntoDirectProductOp`( D, tau, method_selection_object ) | ( operation )

Returns: a morphism in \mathrm{Hom}(T, \prod_{i=1}^n P_i)

The arguments are a list of objects D = ( P_1, \dots, P_n ), a list of morphisms \tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n}, and an object for method selection. The output is the morphism u(\tau): T \rightarrow \prod_{i=1}^n P_i given by the universal property of the direct product.

##### 6.8-7 UniversalMorphismIntoDirectProductWithGivenDirectProduct

`‣ UniversalMorphismIntoDirectProductWithGivenDirectProduct`( D, tau, P ) | ( operation )

Returns: a morphism in \mathrm{Hom}(T, \prod_{i=1}^n P_i)

The arguments are a list of objects D = ( P_1, \dots, P_n ), a list of morphisms \tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n}, and an object P = \prod_{i=1}^n P_i. The output is the morphism u(\tau): T \rightarrow \prod_{i=1}^n P_i given by the universal property of the direct product.

##### 6.8-8 AddDirectProduct

`‣ AddDirectProduct`( 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 `DirectProduct`. F: ( (P_1, \dots, P_n) ) \mapsto P

##### 6.8-9 AddProjectionInFactorOfDirectProduct

`‣ AddProjectionInFactorOfDirectProduct`( 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 `ProjectionInFactorOfDirectProduct`. F: ( (P_1, \dots, P_n),k ) \mapsto \pi_k

##### 6.8-10 AddProjectionInFactorOfDirectProductWithGivenDirectProduct

`‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct`( 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 `ProjectionInFactorOfDirectProductWithGivenDirectProduct`. F: ( (P_1, \dots, P_n),k,P ) \mapsto \pi_k

##### 6.8-11 AddUniversalMorphismIntoDirectProduct

`‣ AddUniversalMorphismIntoDirectProduct`( 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 `UniversalMorphismIntoDirectProduct`. F: ( (P_1, \dots, P_n), \tau ) \mapsto u( \tau )

##### 6.8-12 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct

`‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct`( 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 `UniversalMorphismIntoDirectProductWithGivenDirectProduct`. F: ( (P_1, \dots, P_n), \tau, P ) \mapsto u( \tau )

##### 6.8-13 DirectProductFunctorial

`‣ DirectProductFunctorial`( L ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \prod_{i=1}^n P_i, \prod_{i=1}^n P_i' )

The argument is a list of morphisms L = (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}. The output is a morphism \prod_{i=1}^n P_i \rightarrow \prod_{i=1}^n P_i' given by the functoriality of the direct product.

##### 6.8-14 DirectProductFunctorialWithGivenDirectProducts

`‣ DirectProductFunctorialWithGivenDirectProducts`( s, L, r ) | ( operation )

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

The arguments are an object s = \prod_{i=1}^n P_i, a list of morphisms L = (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}, and an object r = \prod_{i=1}^n P_i'. The output is a morphism \prod_{i=1}^n P_i \rightarrow \prod_{i=1}^n P_i' given by the functoriality of the direct product.

##### 6.8-15 AddDirectProductFunctorialWithGivenDirectProducts

`‣ AddDirectProductFunctorialWithGivenDirectProducts`( 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 `DirectProductFunctorialWithGivenDirectProducts`. F: ( \prod_{i=1}^n P_i, (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}, \prod_{i=1}^n P_i' ) \mapsto (\prod_{i=1}^n P_i \rightarrow \prod_{i=1}^n P_i')

#### 6.9 Equalizer

For an integer n \geq 1 and a given list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}, an equalizer of D consists of three parts:

- an object E,

- a morphism \iota: E \rightarrow A such that \beta_i \circ \iota \sim_{E, B} \beta_j \circ \iota for all pairs i,j.

- a dependent function u mapping each morphism \tau = ( \tau: T \rightarrow A ) such that \beta_i \circ \tau \sim_{T, B} \beta_j \circ \tau for all pairs i,j to a morphism u( \tau ): T \rightarrow E such that \iota \circ u( \tau ) \sim_{T, A} \tau.

The triple ( E, \iota, u ) is called an equalizer of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object E of such a triple by \mathrm{Equalizer}(D). We say that the morphism u( \tau ) is induced by the universal property of the equalizer. \\ \mathrm{Equalizer} is a functorial operation. This means: For a second diagram D' = (\beta_i': A' \rightarrow B')_{i = 1 \dots n} and a natural morphism between equalizer diagrams (i.e., a collection of morphisms \mu: A \rightarrow A' and \beta: B \rightarrow B' such that \beta_i' \circ \mu \sim_{A,B'} \beta \circ \beta_i for i = 1, \dots, n) we obtain a morphism \mathrm{Equalizer}( D ) \rightarrow \mathrm{Equalizer}( D' ).

##### 6.9-1 Equalizer

`‣ Equalizer`( arg ) | ( function )

Returns: an object

This is a convenience method. There are two different ways to use this method:

- The argument is a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}.

- The arguments are morphisms \beta_1: A \rightarrow B, \dots, \beta_n: A \rightarrow B.

The output is the equalizer \mathrm{Equalizer}(D).

##### 6.9-2 EqualizerOp

`‣ EqualizerOp`( D, method_selection_morphism ) | ( operation )

Returns: an object

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is the equalizer \mathrm{Equalizer}(D).

##### 6.9-3 EmbeddingOfEqualizer

`‣ EmbeddingOfEqualizer`( D ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}. The output is the equalizer embedding \iota: \mathrm{Equalizer}(D) \rightarrow A.

##### 6.9-4 EmbeddingOfEqualizerOp

`‣ EmbeddingOfEqualizerOp`( D, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}. and a morphism for method selection. The output is the equalizer embedding \iota: \mathrm{Equalizer}(D) \rightarrow A.

##### 6.9-5 EmbeddingOfEqualizerWithGivenEqualizer

`‣ EmbeddingOfEqualizerWithGivenEqualizer`( D, E ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}, and an object E = \mathrm{Equalizer}(D). The output is the equalizer embedding \iota: E \rightarrow A.

##### 6.9-6 MorphismFromEqualizerToSink

`‣ MorphismFromEqualizerToSink`( D ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}. The output is the composition \mu: \mathrm{Equalizer}(D) \rightarrow B of the embedding \iota: \mathrm{Equalizer}(D) \rightarrow A and \beta_1.

##### 6.9-7 MorphismFromEqualizerToSinkOp

`‣ MorphismFromEqualizerToSinkOp`( D, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is the composition \mu: \mathrm{Equalizer}(D) \rightarrow B of the embedding \iota: \mathrm{Equalizer}(D) \rightarrow A and \beta_1.

##### 6.9-8 MorphismFromEqualizerToSinkWithGivenEqualizer

`‣ MorphismFromEqualizerToSinkWithGivenEqualizer`( D, E ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n} and an object E = \mathrm{Equalizer}(D). The output is the composition \mu: E \rightarrow B of the embedding \iota: E \rightarrow A and \beta_1.

##### 6.9-9 UniversalMorphismIntoEqualizer

`‣ UniversalMorphismIntoEqualizer`( D, tau ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n} and a morphism \tau: T \rightarrow A such that \beta_i \circ \tau \sim_{T, B} \beta_j \circ \tau for all pairs i,j. The output is the morphism u( \tau ): T \rightarrow \mathrm{Equalizer}(D) given by the universal property of the equalizer.

##### 6.9-10 UniversalMorphismIntoEqualizerWithGivenEqualizer

`‣ UniversalMorphismIntoEqualizerWithGivenEqualizer`( D, tau, E ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}, a morphism \tau: T \rightarrow A ) such that \beta_i \circ \tau \sim_{T, B} \beta_j \circ \tau for all pairs i,j, and an object E = \mathrm{Equalizer}(D). The output is the morphism u( \tau ): T \rightarrow E given by the universal property of the equalizer.

##### 6.9-11 AddEqualizer

`‣ AddEqualizer`( 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 `Equalizer`. F: ( (\beta_i: A \rightarrow B)_{i = 1 \dots n} ) \mapsto E

##### 6.9-12 AddEmbeddingOfEqualizer

`‣ AddEmbeddingOfEqualizer`( 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 `EmbeddingOfEqualizer`. F: ( (\beta_i: A \rightarrow B)_{i = 1 \dots n}, k ) \mapsto \iota

##### 6.9-13 AddEmbeddingOfEqualizerWithGivenEqualizer

`‣ AddEmbeddingOfEqualizerWithGivenEqualizer`( 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 `EmbeddingOfEqualizerWithGivenEqualizer`. F: ( (\beta_i: A \rightarrow B)_{i = 1 \dots n},E ) \mapsto \iota

##### 6.9-14 AddMorphismFromEqualizerToSink

`‣ AddMorphismFromEqualizerToSink`( 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 `MorphismFromEqualizerToSink`. F: ( (\beta_i: P \rightarrow B)_{i = 1 \dots n} ) \mapsto \mu

##### 6.9-15 AddMorphismFromEqualizerToSinkWithGivenEqualizer

`‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer`( 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 `MorphismFromEqualizerToSinkWithGivenEqualizer`. F: ( (\beta_i: P \rightarrow B)_{i = 1 \dots n}, E ) \mapsto \mu

##### 6.9-16 AddUniversalMorphismIntoEqualizer

`‣ AddUniversalMorphismIntoEqualizer`( 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 `UniversalMorphismIntoEqualizer`. F: ( (\beta_i: A \rightarrow B)_{i = 1 \dots n}, \tau ) \mapsto u(\tau)

##### 6.9-17 AddUniversalMorphismIntoEqualizerWithGivenEqualizer

`‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer`( 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 `UniversalMorphismIntoEqualizerWithGivenEqualizer`. F: ( (\beta_i: A \rightarrow B)_{i = 1 \dots n}, \tau, E ) \mapsto u(\tau)

##### 6.9-18 EqualizerFunctorial

`‣ EqualizerFunctorial`( Ls, mu, Lr ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\mathrm{Equalizer}( ( \beta_i )_{i=1 \dots n} ), \mathrm{Equalizer}( ( \beta_i' )_{i=1 \dots n} ))

The arguments are a list of morphisms L_s = (\beta_i: A \rightarrow B)_{i = 1 \dots n}, a morphism \mu: A \rightarrow A', and a list of morphisms L_r = (\beta_i': A' \rightarrow B')_{i = 1 \dots n} such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \mu \sim_{A,B'} \beta \circ \beta_i for i = 1, \dots, n. The output is the morphism \mathrm{Equalizer}( ( \beta_i )_{i=1 \dots n} ) \rightarrow \mathrm{Equalizer}( ( \beta_i' )_{i=1 \dots n} ) given by the functorality of the equalizer.

##### 6.9-19 EqualizerFunctorialWithGivenEqualizers

`‣ EqualizerFunctorialWithGivenEqualizers`( s, Ls, mu, Lr, r ) | ( operation )

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

The arguments are an object s = \mathrm{Equalizer}( ( \beta_i )_{i=1 \dots n} ), a list of morphisms L_s = (\beta_i: A \rightarrow B)_{i = 1 \dots n}, a morphism \mu: A \rightarrow A', and a list of morphisms L_r = (\beta_i': A' \rightarrow B')_{i = 1 \dots n} such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \mu \sim_{A,B'} \beta \circ \beta_i for i = 1, \dots, n, and an object r = \mathrm{Equalizer}( ( \beta_i' )_{i=1 \dots n} ). The output is the morphism s \rightarrow r given by the functorality of the equalizer.

##### 6.9-20 AddEqualizerFunctorialWithGivenEqualizers

`‣ AddEqualizerFunctorialWithGivenEqualizers`( 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 `EqualizerFunctorialWithGivenEqualizers`. F: ( \mathrm{Equalizer}( ( \beta_i )_{i=1 \dots n} ), ( \beta_i: A \rightarrow B )_{i = 1 \dots n}, \mu: A \rightarrow A', ( \beta_i': A' \rightarrow B' )_{i = 1 \dots n}, \mathrm{Equalizer}( ( \beta_i' )_{i=1 \dots n} ) ) \mapsto (\mathrm{Equalizer}( ( \beta_i )_{i=1 \dots n} ) \rightarrow \mathrm {Equalizer}( ( \beta_i' )_{i=1 \dots n} ) )

#### 6.10 Coequalizer

For an integer n \geq 1 and a given list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, a coequalizer of D consists of three parts:

- an object C,

- a morphism \pi: A \rightarrow C such that \pi \circ \beta_i \sim_{B,C} \pi \circ \beta_j for all pairs i,j,

- a dependent function u mapping the morphism \tau: A \rightarrow T such that \tau \circ \beta_i \sim_{B,T} \tau \circ \beta_j to a morphism u( \tau ): C \rightarrow T such that u( \tau ) \circ \pi \sim_{A, T} \tau.

The triple ( C, \pi, u ) is called a coequalizer of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object C of such a triple by \mathrm{Coequalizer}(D). We say that the morphism u( \tau ) is induced by the universal property of the coequalizer. \\ \mathrm{Coequalizer} is a functorial operation. This means: For a second diagram D' = (\beta_i': B' \rightarrow A')_{i = 1 \dots n} and a natural morphism between coequalizer diagrams (i.e., a collection of morphisms \mu: A \rightarrow A' and \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, A'} \mu \circ \beta_i for i = 1, \dots n) we obtain a morphism \mathrm{Coequalizer}( D ) \rightarrow \mathrm{Coequalizer}( D' ).

##### 6.10-1 Coequalizer

`‣ Coequalizer`( arg ) | ( function )

Returns: an object

This is a convenience method. There are two different ways to use this method:

- The argument is a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}.

- The arguments are morphisms \beta_1: B \rightarrow A, \dots, \beta_n: B \rightarrow A.

The output is the coequalizer \mathrm{Coequalizer}(D).

##### 6.10-2 CoequalizerOp

`‣ CoequalizerOp`( D, method_selection_morphism ) | ( operation )

Returns: an object

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n} and a morphism for method selection. The output is the coequalizer \mathrm{Coequalizer}(D).

##### 6.10-3 ProjectionOntoCoequalizer

`‣ ProjectionOntoCoequalizer`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( A, \mathrm{Coequalizer}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}. The output is the projection \pi: A \rightarrow \mathrm{Coequalizer}( D ).

##### 6.10-4 ProjectionOntoCoequalizerOp

`‣ ProjectionOntoCoequalizerOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( A, \mathrm{Coequalizer}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, and a morphism for method selection. The output is the projection \pi: A \rightarrow \mathrm{Coequalizer}( D ).

##### 6.10-5 ProjectionOntoCoequalizerWithGivenCoequalizer

`‣ ProjectionOntoCoequalizerWithGivenCoequalizer`( D, C ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, and an object C = \mathrm{Coequalizer}(D). The output is the projection \pi: A \rightarrow C.

##### 6.10-6 MorphismFromSourceToCoequalizer

`‣ MorphismFromSourceToCoequalizer`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( B, \mathrm{Coequalizer}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}. The output is the composition \mu: B \rightarrow \mathrm{Coequalizer}(D) of \beta_1 and the projection \pi: A \rightarrow \mathrm{Coequalizer}( D ).

##### 6.10-7 MorphismFromSourceToCoequalizerOp

`‣ MorphismFromSourceToCoequalizerOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( B, \mathrm{Coequalizer}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n} and a morphism for method selection. The output is the composition \mu: B \rightarrow \mathrm{Coequalizer}(D) of \beta_1 and the projection \pi: A \rightarrow \mathrm{Coequalizer}( D ).

##### 6.10-8 MorphismFromSourceToCoequalizerWithGivenCoequalizer

`‣ MorphismFromSourceToCoequalizerWithGivenCoequalizer`( D, C ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n} and an object C = \mathrm{Coequalizer}(D). The output is the composition \mu: B \rightarrow C of \beta_1 and the projection \pi: A \rightarrow C.

##### 6.10-9 UniversalMorphismFromCoequalizer

`‣ UniversalMorphismFromCoequalizer`( D, tau ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n} and a morphism \tau: A \rightarrow T such that \tau \circ \beta_i \sim_{B,T} \tau \circ \beta_j for all pairs i,j. The output is the morphism u( \tau ): \mathrm{Coequalizer}(D) \rightarrow T given by the universal property of the coequalizer.

##### 6.10-10 UniversalMorphismFromCoequalizerWithGivenCoequalizer

`‣ UniversalMorphismFromCoequalizerWithGivenCoequalizer`( D, tau, C ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, a morphism \tau: A \rightarrow T such that \tau \circ \beta_i \sim_{B,T} \tau \circ \beta_j, and an object C = \mathrm{Coequalizer}(D). The output is the morphism u( \tau ): C \rightarrow T given by the universal property of the coequalizer.

##### 6.10-11 AddCoequalizer

`‣ AddCoequalizer`( 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 `Coequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n} ) \mapsto C

##### 6.10-12 AddProjectionOntoCoequalizer

`‣ AddProjectionOntoCoequalizer`( 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 `ProjectionOntoCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n}, k ) \mapsto \pi

##### 6.10-13 AddProjectionOntoCoequalizerWithGivenCoequalizer

`‣ AddProjectionOntoCoequalizerWithGivenCoequalizer`( 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 `ProjectionOntoCoequalizerWithGivenCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n}, C) \mapsto \pi

##### 6.10-14 AddMorphismFromSourceToCoequalizer

`‣ AddMorphismFromSourceToCoequalizer`( 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 `MorphismFromSourceToCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n} ) \mapsto \mu

##### 6.10-15 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer

`‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer`( 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 `MorphismFromSourceToCoequalizerWithGivenCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n}, C ) \mapsto \mu

##### 6.10-16 AddUniversalMorphismFromCoequalizer

`‣ AddUniversalMorphismFromCoequalizer`( 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 `UniversalMorphismFromCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n}, \tau ) \mapsto u(\tau)

##### 6.10-17 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer

`‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer`( 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 `UniversalMorphismFromCoequalizerWithGivenCoequalizer`. F: ( (\beta_i: B \rightarrow A)_{i = 1 \dots n}, \tau, C ) \mapsto u(\tau)

##### 6.10-18 CoequalizerFunctorial

`‣ CoequalizerFunctorial`( Ls, mu, Lr ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\mathrm{Coequalizer}( ( \beta_i )_{i=1 \dots n} ), \mathrm{Coequalizer}( ( \beta_i' )_{i=1 \dots n} ))

The arguments are a list of morphisms L_s = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, a morphism \mu: A \rightarrow A', and a list of morphisms L_r = ( \beta_i': B' \rightarrow A' )_{i = 1 \dots n} such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, A'} \mu \circ \beta_i for i = 1, \dots n. The output is the morphism \mathrm{Coequalizer}( ( \beta_i )_{i=1}^n ) \rightarrow \mathrm{Coequalizer}( ( \beta_i' )_{i=1}^n ) given by the functorality of the coequalizer.

##### 6.10-19 CoequalizerFunctorialWithGivenCoequalizers

`‣ CoequalizerFunctorialWithGivenCoequalizers`( s, Ls, mu, Lr, r ) | ( operation )

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

The arguments are an object s = \mathrm{Coequalizer}( ( \beta_i )_{i=1}^n ), a list of morphisms L_s = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, a morphism \mu: A \rightarrow A', and a list of morphisms L_r = ( \beta_i': B' \rightarrow A' )_{i = 1 \dots n} such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, A'} \mu \circ \beta_i for i = 1, \dots n, and an object r = \mathrm{Coequalizer}( ( \beta_i' )_{i=1}^n ). The output is the morphism s \rightarrow r given by the functorality of the coequalizer.

##### 6.10-20 AddCoequalizerFunctorialWithGivenCoequalizers

`‣ AddCoequalizerFunctorialWithGivenCoequalizers`( 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 `CoequalizerFunctorialWithGivenCoequalizers`. F: ( \mathrm{Coequalizer}( ( \beta_i )_{i=1}^n ), ( \beta_i: B \rightarrow A )_{i = 1 \dots n}, \mu: A \rightarrow A', ( \beta_i': B' \rightarrow A' )_{i = 1 \dots n}, \mathrm{Coequalizer}( ( \beta_i' )_{i=1}^n ) ) \mapsto (\mathrm{Coequalizer}( ( \beta_i )_{i=1}^n ) \rightarrow \mathrm{Coequalizer}( ( \beta_i' )_{i=1}^n ) )

#### 6.11 Fiber Product

For an integer n \geq 1 and a given list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}, a fiber product of D consists of three parts:

- an object P,

- a list of morphisms \pi = ( \pi_i: P \rightarrow P_i )_{i = 1 \dots n} such that \beta_i \circ \pi_i \sim_{P, B} \beta_j \circ \pi_j for all pairs i,j.

- a dependent function u mapping each list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) such that \beta_i \circ \tau_i \sim_{T, B} \beta_j \circ \tau_j for all pairs i,j to a morphism u( \tau ): T \rightarrow P such that \pi_i \circ u( \tau ) \sim_{T, P_i} \tau_i for all i = 1, \dots, n.

The triple ( P, \pi, u ) is called a fiber product of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object P of such a triple by \mathrm{FiberProduct}(D). We say that the morphism u( \tau ) is induced by the universal property of the fiber product. \\ \mathrm{FiberProduct} is a functorial operation. This means: For a second diagram D' = (\beta_i': P_i' \rightarrow B')_{i = 1 \dots n} and a natural morphism between pullback diagrams (i.e., a collection of morphisms (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n} and \beta: B \rightarrow B' such that \beta_i' \circ \mu_i \sim_{P_i,B'} \beta \circ \beta_i for i = 1, \dots, n) we obtain a morphism \mathrm{FiberProduct}( D ) \rightarrow \mathrm{FiberProduct}( D' ).

##### 6.11-1 IsomorphismFromFiberProductToKernelOfDiagonalDifference

`‣ IsomorphismFromFiberProductToKernelOfDiagonalDifference`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is a morphism \mathrm{FiberProduct}(D) \rightarrow \Delta, where \Delta denotes the kernel object equalizing the morphisms \beta_i.

##### 6.11-2 IsomorphismFromFiberProductToKernelOfDiagonalDifferenceOp

`‣ IsomorphismFromFiberProductToKernelOfDiagonalDifferenceOp`( D, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \mathrm{FiberProduct}(D) \rightarrow \Delta, where \Delta denotes the kernel object equalizing the morphisms \beta_i.

##### 6.11-3 AddIsomorphismFromFiberProductToKernelOfDiagonalDifference

`‣ AddIsomorphismFromFiberProductToKernelOfDiagonalDifference`( 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 `IsomorphismFromFiberProductToKernelOfDiagonalDifference`. F: ( ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} ) \mapsto \mathrm{FiberProduct}(D) \rightarrow \Delta

##### 6.11-4 IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct

`‣ IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is a morphism \Delta \rightarrow \mathrm{FiberProduct}(D), where \Delta denotes the kernel object equalizing the morphisms \beta_i.

##### 6.11-5 IsomorphismFromKernelOfDiagonalDifferenceToFiberProductOp

`‣ IsomorphismFromKernelOfDiagonalDifferenceToFiberProductOp`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \Delta \rightarrow \mathrm{FiberProduct}(D), where \Delta denotes the kernel object equalizing the morphisms \beta_i.

##### 6.11-6 AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct

`‣ AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct`( 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 `IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct`. F: ( ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} ) \mapsto \Delta \rightarrow \mathrm{FiberProduct}(D)

##### 6.11-7 IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram

`‣ IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is a morphism \mathrm{FiberProduct}(D) \rightarrow \Delta, where \Delta denotes the equalizer of the product diagram of the morphisms \beta_i.

##### 6.11-8 IsomorphismFromFiberProductToEqualizerOfDirectProductDiagramOp

`‣ IsomorphismFromFiberProductToEqualizerOfDirectProductDiagramOp`( D, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \mathrm{FiberProduct}(D) \rightarrow \Delta, where \Delta denotes the equalizer of the product diagram of the morphisms \beta_i.

##### 6.11-9 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram

`‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram`( 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 `IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram`. F: ( ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} ) \mapsto \mathrm{FiberProduct}(D) \rightarrow \Delta

##### 6.11-10 IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct

`‣ IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is a morphism \Delta \rightarrow \mathrm{FiberProduct}(D), where \Delta denotes the equalizer of the product diagram of the morphisms \beta_i.

##### 6.11-11 IsomorphismFromEqualizerOfDirectProductDiagramToFiberProductOp

`‣ IsomorphismFromEqualizerOfDirectProductDiagramToFiberProductOp`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \Delta \rightarrow \mathrm{FiberProduct}(D), where \Delta denotes the equalizer of the product diagram of the morphisms \beta_i.

##### 6.11-12 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct

`‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct`( 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 `IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct`. F: ( ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} ) \mapsto \Delta \rightarrow \mathrm{FiberProduct}(D)

##### 6.11-13 DirectSumDiagonalDifference

`‣ DirectSumDiagonalDifference`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n P_i, B )

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is a morphism \bigoplus_{i=1}^n P_i \rightarrow B such that its kernel equalizes the \beta_i.

##### 6.11-14 DirectSumDiagonalDifferenceOp

`‣ DirectSumDiagonalDifferenceOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n P_i, B )

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \bigoplus_{i=1}^n P_i \rightarrow B such that its kernel equalizes the \beta_i.

##### 6.11-15 AddDirectSumDiagonalDifference

`‣ AddDirectSumDiagonalDifference`( 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 `DirectSumDiagonalDifference`. F: ( D ) \mapsto \mathrm{DirectSumDiagonalDifference}(D)

##### 6.11-16 FiberProductEmbeddingInDirectSum

`‣ FiberProductEmbeddingInDirectSum`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \mathrm{FiberProduct}(D), \bigoplus_{i=1}^n P_i )

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is the natural embedding \mathrm{FiberProduct}(D) \rightarrow \bigoplus_{i=1}^n P_i.

##### 6.11-17 FiberProductEmbeddingInDirectSumOp

`‣ FiberProductEmbeddingInDirectSumOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \mathrm{FiberProduct}(D), \bigoplus_{i=1}^n P_i )

The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is the natural embedding \mathrm{FiberProduct}(D) \rightarrow \bigoplus_{i=1}^n P_i.

##### 6.11-18 AddFiberProductEmbeddingInDirectSum

`‣ AddFiberProductEmbeddingInDirectSum`( 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 `FiberProductEmbeddingInDirectSum`. F: ( ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} ) \mapsto \mathrm{FiberProduct}(D) \rightarrow \bigoplus_{i=1}^n P_i

##### 6.11-19 FiberProduct

`‣ FiberProduct`( arg ) | ( function )

Returns: an object

This is a convenience method. There are two different ways to use this method:

- The argument is a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}.

- The arguments are morphisms \beta_1: P_1 \rightarrow B, \dots, \beta_n: P_n \rightarrow B.

The output is the fiber product \mathrm{FiberProduct}(D).

##### 6.11-20 FiberProductOp

`‣ FiberProductOp`( D, method_selection_morphism ) | ( operation )

Returns: an object

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is the fiber product \mathrm{FiberProduct}(D).

##### 6.11-21 ProjectionInFactorOfFiberProduct

`‣ ProjectionInFactorOfFiberProduct`( D, k ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and an integer k. The output is the k-th projection \pi_{k}: \mathrm{FiberProduct}(D) \rightarrow P_k.

##### 6.11-22 ProjectionInFactorOfFiberProductOp

`‣ ProjectionInFactorOfFiberProductOp`( D, k, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}, an integer k, and a morphism for method selection. The output is the k-th projection \pi_{k}: \mathrm{FiberProduct}(D) \rightarrow P_k.

##### 6.11-23 ProjectionInFactorOfFiberProductWithGivenFiberProduct

`‣ ProjectionInFactorOfFiberProductWithGivenFiberProduct`( D, k, P ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}, an integer k, and an object P = \mathrm{FiberProduct}(D). The output is the k-th projection \pi_{k}: P \rightarrow P_k.

##### 6.11-24 MorphismFromFiberProductToSink

`‣ MorphismFromFiberProductToSink`( D ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}. The output is the composition \mu: \mathrm{FiberProduct}(D) \rightarrow B of the 1-st projection \pi_1: \mathrm{FiberProduct}(D) \rightarrow P_1 and \beta_1.

##### 6.11-25 MorphismFromFiberProductToSinkOp

`‣ MorphismFromFiberProductToSinkOp`( D, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a morphism for method selection. The output is the composition \mu: \mathrm{FiberProduct}(D) \rightarrow B of the 1-st projection \pi_1: \mathrm{FiberProduct}(D) \rightarrow P_1 and \beta_1.

##### 6.11-26 MorphismFromFiberProductToSinkWithGivenFiberProduct

`‣ MorphismFromFiberProductToSinkWithGivenFiberProduct`( D, P ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and an object P = \mathrm{FiberProduct}(D). The output is the composition \mu: P \rightarrow B of the 1-st projection \pi_1: P \rightarrow P_1 and \beta_1.

##### 6.11-27 UniversalMorphismIntoFiberProduct

`‣ UniversalMorphismIntoFiberProduct`( arg ) | ( function )

This is a convenience method. There are two different ways to use this method:

- The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and a list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) such that \beta_i \circ \tau_i \sim_{T, B} \beta_j \circ \tau_j for all pairs i,j. The output is the morphism u( \tau ): T \rightarrow \mathrm{FiberProduct}(D) given by the universal property of the fiber product.

- The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n} and morphisms \tau_1: T \rightarrow P_1, \dots, \tau_n: T \rightarrow P_n such that \beta_i \circ \tau_i \sim_{T, B} \beta_j \circ \tau_j for all pairs i,j. The output is the morphism u( \tau ): T \rightarrow \mathrm{FiberProduct}(D) given by the universal property of the fiber product.

##### 6.11-28 UniversalMorphismIntoFiberProductOp

`‣ UniversalMorphismIntoFiberProductOp`( D, tau, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}, a list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) such that \beta_i \circ \tau_i \sim_{T, B} \beta_j \circ \tau_j for all pairs i,j, and a morphism for method selection. The output is the morphism u( \tau ): T \rightarrow \mathrm{FiberProduct}(D) given by the universal property of the fiber product.

##### 6.11-29 UniversalMorphismIntoFiberProductWithGivenFiberProduct

`‣ UniversalMorphismIntoFiberProductWithGivenFiberProduct`( D, tau, P ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}, a list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) such that \beta_i \circ \tau_i \sim_{T, B} \beta_j \circ \tau_j for all pairs i,j, and an object P = \mathrm{FiberProduct}(D). The output is the morphism u( \tau ): T \rightarrow P given by the universal property of the fiber product.

##### 6.11-30 AddFiberProduct

`‣ AddFiberProduct`( 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 `FiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n} ) \mapsto P

##### 6.11-31 AddProjectionInFactorOfFiberProduct

`‣ AddProjectionInFactorOfFiberProduct`( 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 `ProjectionInFactorOfFiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, k ) \mapsto \pi_k

##### 6.11-32 AddProjectionInFactorOfFiberProductWithGivenFiberProduct

`‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct`( 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 `ProjectionInFactorOfFiberProductWithGivenFiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, k,P ) \mapsto \pi_k

##### 6.11-33 AddMorphismFromFiberProductToSink

`‣ AddMorphismFromFiberProductToSink`( 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 `MorphismFromFiberProductToSink`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n} ) \mapsto \mu

##### 6.11-34 AddMorphismFromFiberProductToSinkWithGivenFiberProduct

`‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct`( 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 `MorphismFromFiberProductToSinkWithGivenFiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, P ) \mapsto \mu

##### 6.11-35 AddUniversalMorphismIntoFiberProduct

`‣ AddUniversalMorphismIntoFiberProduct`( 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 `UniversalMorphismIntoFiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, \tau ) \mapsto u(\tau)

##### 6.11-36 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct

`‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct`( 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 `UniversalMorphismIntoFiberProductWithGivenFiberProduct`. F: ( (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, \tau, P ) \mapsto u(\tau)

##### 6.11-37 FiberProductFunctorial

`‣ FiberProductFunctorial`( Ls, Lm, Lr ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\mathrm{FiberProduct}( ( \beta_i )_{i=1 \dots n} ), \mathrm{FiberProduct}( ( \beta_i' )_{i=1 \dots n} ))

The arguments are three lists of morphisms L_s = ( \beta_i: P_i \rightarrow B)_{i = 1 \dots n}, L_m = ( \mu_i: P_i \rightarrow P_i' )_{i = 1 \dots n}, L_r = ( \beta_i': P_i' \rightarrow B')_{i = 1 \dots n} having the same length n such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \mu_i \sim_{P_i,B'} \beta \circ \beta_i for i = 1, \dots, n. The output is the morphism \mathrm{FiberProduct}( ( \beta_i )_{i=1 \dots n} ) \rightarrow \mathrm{FiberProduct}( ( \beta_i' )_{i=1 \dots n} ) given by the functoriality of the fiber product.

##### 6.11-38 FiberProductFunctorialWithGivenFiberProducts

`‣ FiberProductFunctorialWithGivenFiberProducts`( s, Ls, Lm, Lr, r ) | ( operation )

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

The arguments are an object s = \mathrm{FiberProduct}( ( \beta_i )_{i=1 \dots n} ), three lists of morphisms L_s = ( \beta_i: P_i \rightarrow B)_{i = 1 \dots n}, L_m = ( \mu_i: P_i \rightarrow P_i' )_{i = 1 \dots n}, L_r = ( \beta_i': P_i' \rightarrow B')_{i = 1 \dots n} having the same length n such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \mu_i \sim_{P_i,B'} \beta \circ \beta_i for i = 1, \dots, n, and an object r = \mathrm{FiberProduct}( ( \beta_i' )_{i=1 \dots n} ). The output is the morphism s \rightarrow r given by the functoriality of the fiber product.

##### 6.11-39 AddFiberProductFunctorialWithGivenFiberProducts

`‣ AddFiberProductFunctorialWithGivenFiberProducts`( 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 `FiberProductFunctorialWithGivenFiberProducts`. F: ( \mathrm{FiberProduct}( ( \beta_i )_{i=1 \dots n} ), (\beta_i: P_i \rightarrow B)_{i = 1 \dots n}, (\mu_i: P_i \rightarrow P_i')_{i = 1 \dots n}, (\beta_i': P_i' \rightarrow B')_{i = 1 \dots n}, \mathrm{FiberProduct}( ( \beta_i' )_{i=1 \dots n} ) ) ) \mapsto (\mathrm{FiberProduct}( ( \beta_i )_{i=1 \dots n} ) \rightarrow \mathrm{FiberProduct}( ( \beta_i' )_{i=1 \dots n} ) )

#### 6.12 Pushout

For an integer n \geq 1 and a given list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, a pushout of D consists of three parts:

- an object I,

- a list of morphisms \iota = ( \iota_i: I_i \rightarrow I )_{i = 1 \dots n} such that \iota_i \circ \beta_i \sim_{B,I} \iota_j \circ \beta_j for all pairs i,j,

- a dependent function u mapping each list of morphisms \tau = ( \tau_i: I_i \rightarrow T )_{i = 1 \dots n} such that \tau_i \circ \beta_i \sim_{B,T} \tau_j \circ \beta_j to a morphism u( \tau ): I \rightarrow T such that u( \tau ) \circ \iota_i \sim_{I_i, T} \tau_i for all i = 1, \dots, n.

The triple ( I, \iota, u ) is called a pushout of D if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object I of such a triple by \mathrm{Pushout}(D). We say that the morphism u( \tau ) is induced by the universal property of the pushout. \\ \mathrm{Pushout} is a functorial operation. This means: For a second diagram D' = (\beta_i': B' \rightarrow I_i')_{i = 1 \dots n} and a natural morphism between pushout diagrams (i.e., a collection of morphisms (\mu_i: I_i \rightarrow I'_i)_{i=1\dots n} and \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, I_i'} \mu_i \circ \beta_i for i = 1, \dots n) we obtain a morphism \mathrm{Pushout}( D ) \rightarrow \mathrm{Pushout}( D' ).

##### 6.12-1 IsomorphismFromPushoutToCokernelOfDiagonalDifference

`‣ IsomorphismFromPushoutToCokernelOfDiagonalDifference`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is a morphism \mathrm{Pushout}(D) \rightarrow \Delta, where \Delta denotes the cokernel object coequalizing the morphisms \beta_i.

##### 6.12-2 IsomorphismFromPushoutToCokernelOfDiagonalDifferenceOp

`‣ IsomorphismFromPushoutToCokernelOfDiagonalDifferenceOp`( D, method_selection_morphism ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \mathrm{Pushout}(D) \rightarrow \Delta, where \Delta denotes the cokernel object coequalizing the morphisms \beta_i.

##### 6.12-3 AddIsomorphismFromPushoutToCokernelOfDiagonalDifference

`‣ AddIsomorphismFromPushoutToCokernelOfDiagonalDifference`( 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 `IsomorphismFromPushoutToCokernelOfDiagonalDifference`. F: ( ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} ) \mapsto (\mathrm{Pushout}(D) \rightarrow \Delta)

##### 6.12-4 IsomorphismFromCokernelOfDiagonalDifferenceToPushout

`‣ IsomorphismFromCokernelOfDiagonalDifferenceToPushout`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is a morphism \Delta \rightarrow \mathrm{Pushout}(D), where \Delta denotes the cokernel object coequalizing the morphisms \beta_i.

##### 6.12-5 IsomorphismFromCokernelOfDiagonalDifferenceToPushoutOp

`‣ IsomorphismFromCokernelOfDiagonalDifferenceToPushoutOp`( D, method_selection_morphism ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \Delta \rightarrow \mathrm{Pushout}(D), where \Delta denotes the cokernel object coequalizing the morphisms \beta_i.

##### 6.12-6 AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout

`‣ AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout`( 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 `IsomorphismFromCokernelOfDiagonalDifferenceToPushout`. F: ( ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} ) \mapsto (\Delta \rightarrow \mathrm{Pushout}(D))

##### 6.12-7 IsomorphismFromPushoutToCoequalizerOfCoproductDiagram

`‣ IsomorphismFromPushoutToCoequalizerOfCoproductDiagram`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is a morphism \mathrm{Pushout}(D) \rightarrow \Delta, where \Delta denotes the coequalizer of the coproduct diagram of the morphisms \beta_i.

##### 6.12-8 IsomorphismFromPushoutToCoequalizerOfCoproductDiagramOp

`‣ IsomorphismFromPushoutToCoequalizerOfCoproductDiagramOp`( D, method_selection_morphism ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \mathrm{Pushout}(D) \rightarrow \Delta, where \Delta denotes the coequalizer of the coproduct diagram of the morphisms \beta_i.

##### 6.12-9 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram

`‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram`( 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 `IsomorphismFromPushoutToCoequalizerOfCoproductDiagram`. F: ( ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} ) \mapsto (\mathrm{Pushout}(D) \rightarrow \Delta)

##### 6.12-10 IsomorphismFromCoequalizerOfCoproductDiagramToPushout

`‣ IsomorphismFromCoequalizerOfCoproductDiagramToPushout`( D ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is a morphism \Delta \rightarrow \mathrm{Pushout}(D), where \Delta denotes the coequalizer of the coproduct diagram of the morphisms \beta_i.

##### 6.12-11 IsomorphismFromCoequalizerOfCoproductDiagramToPushoutOp

`‣ IsomorphismFromCoequalizerOfCoproductDiagramToPushoutOp`( D, method_selection_morphism ) | ( operation )

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

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism \Delta \rightarrow \mathrm{Pushout}(D), where \Delta denotes the coequalizer of the coproduct diagram of the morphisms \beta_i.

##### 6.12-12 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout

`‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout`( 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 `IsomorphismFromCoequalizerOfCoproductDiagramToPushout`. F: ( ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} ) \mapsto (\Delta \rightarrow \mathrm{Pushout}(D))

##### 6.12-13 DirectSumCodiagonalDifference

`‣ DirectSumCodiagonalDifference`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B, \bigoplus_{i=1}^n I_i)

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is a morphism B \rightarrow \bigoplus_{i=1}^n I_i such that its cokernel coequalizes the \beta_i.

##### 6.12-14 DirectSumCodiagonalDifferenceOp

`‣ DirectSumCodiagonalDifferenceOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}(B, \bigoplus_{i=1}^n I_i)

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is a morphism B \rightarrow \bigoplus_{i=1}^n I_i such that its cokernel coequalizes the \beta_i.

##### 6.12-15 AddDirectSumCodiagonalDifference

`‣ AddDirectSumCodiagonalDifference`( 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 `DirectSumCodiagonalDifference`. F: ( D ) \mapsto \mathrm{DirectSumCodiagonalDifference}(D)

##### 6.12-16 DirectSumProjectionInPushout

`‣ DirectSumProjectionInPushout`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n I_i, \mathrm{Pushout}(D) )

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is the natural projection \bigoplus_{i=1}^n I_i \rightarrow \mathrm{Pushout}(D).

##### 6.12-17 DirectSumProjectionInPushoutOp

`‣ DirectSumProjectionInPushoutOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( \bigoplus_{i=1}^n I_i, \mathrm{Pushout}(D) )

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is the natural projection \bigoplus_{i=1}^n I_i \rightarrow \mathrm{Pushout}(D).

##### 6.12-18 AddDirectSumProjectionInPushout

`‣ AddDirectSumProjectionInPushout`( 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 `DirectSumProjectionInPushout`. F: ( ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} ) \mapsto (\bigoplus_{i=1}^n I_i \rightarrow \mathrm{Pushout}(D))

##### 6.12-19 Pushout

`‣ Pushout`( D ) | ( operation )

Returns: an object

The argument is a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} The output is the pushout \mathrm{Pushout}(D).

##### 6.12-20 Pushout

`‣ Pushout`( D ) | ( operation )

Returns: an object

This is a convenience method. The arguments are a morphism \alpha and a morphism \beta. The output is the pushout \mathrm{Pushout}(\alpha, \beta).

##### 6.12-21 PushoutOp

`‣ PushoutOp`( D ) | ( operation )

Returns: an object

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is the pushout \mathrm{Pushout}(D).

##### 6.12-22 InjectionOfCofactorOfPushout

`‣ InjectionOfCofactorOfPushout`( D, k ) | ( operation )

Returns: a morphism in \mathrm{Hom}( I_k, \mathrm{Pushout}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and an integer k. The output is the k-th injection \iota_k: I_k \rightarrow \mathrm{Pushout}( D ).

##### 6.12-23 InjectionOfCofactorOfPushoutOp

`‣ InjectionOfCofactorOfPushoutOp`( D, k, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( I_k, \mathrm{Pushout}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, an integer k, and a morphism for method selection. The output is the k-th injection \iota_k: I_k \rightarrow \mathrm{Pushout}( D ).

##### 6.12-24 InjectionOfCofactorOfPushoutWithGivenPushout

`‣ InjectionOfCofactorOfPushoutWithGivenPushout`( D, k, I ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, an integer k, and an object I = \mathrm{Pushout}(D). The output is the k-th injection \iota_k: I_k \rightarrow I.

##### 6.12-25 MorphismFromSourceToPushout

`‣ MorphismFromSourceToPushout`( D ) | ( operation )

Returns: a morphism in \mathrm{Hom}( B, \mathrm{Pushout}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}. The output is the composition \mu: B \rightarrow \mathrm{Pushout}(D) of \beta_1 and the 1-st injection \iota_1: I_1 \rightarrow \mathrm{Pushout}( D ).

##### 6.12-26 MorphismFromSourceToPushoutOp

`‣ MorphismFromSourceToPushoutOp`( D, method_selection_morphism ) | ( operation )

Returns: a morphism in \mathrm{Hom}( B, \mathrm{Pushout}( D ) ).

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a morphism for method selection. The output is the composition \mu: B \rightarrow \mathrm{Pushout}(D) of \beta_1 and the 1-st injection \iota_1: I_1 \rightarrow \mathrm{Pushout}( D ).

##### 6.12-27 MorphismFromSourceToPushoutWithGivenPushout

`‣ MorphismFromSourceToPushoutWithGivenPushout`( D, I ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and an object I = \mathrm{Pushout}(D). The output is the composition \mu: B \rightarrow I of \beta_1 and the 1-st injection \iota_1: I_1 \rightarrow I.

##### 6.12-28 UniversalMorphismFromPushout

`‣ UniversalMorphismFromPushout`( arg ) | ( function )

This is a convenience method. There are two different ways to use this method:

- The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and a list of morphisms \tau = ( \tau_i: I_i \rightarrow T )_{i = 1 \dots n} such that \tau_i \circ \beta_i \sim_{B,T} \tau_j \circ \beta_j. The output is the morphism u( \tau ): \mathrm{Pushout}(D) \rightarrow T given by the universal property of the pushout.

- The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n} and morphisms \tau_1: I_1 \rightarrow T, \dots, \tau_n: I_n \rightarrow T such that \tau_i \circ \beta_i \sim_{B,T} \tau_j \circ \beta_j. The output is the morphism u( \tau ): \mathrm{Pushout}(D) \rightarrow T given by the universal property of the pushout.

##### 6.12-29 UniversalMorphismFromPushoutOp

`‣ UniversalMorphismFromPushoutOp`( D, tau, method_selection_morphism ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, a list of morphisms \tau = ( \tau_i: I_i \rightarrow T )_{i = 1 \dots n} such that \tau_i \circ \beta_i \sim_{B,T} \tau_j \circ \beta_j, and a morphism for method selection. The output is the morphism u( \tau ): \mathrm{Pushout}(D) \rightarrow T given by the universal property of the pushout.

##### 6.12-30 UniversalMorphismFromPushoutWithGivenPushout

`‣ UniversalMorphismFromPushoutWithGivenPushout`( D, tau, I ) | ( operation )

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

The arguments are a list of morphisms D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, a list of morphisms \tau = ( \tau_i: I_i \rightarrow T )_{i = 1 \dots n} such that \tau_i \circ \beta_i \sim_{B,T} \tau_j \circ \beta_j, and an object I = \mathrm{Pushout}(D). The output is the morphism u( \tau ): I \rightarrow T given by the universal property of the pushout.

##### 6.12-31 AddPushout

`‣ AddPushout`( 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 `Pushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n} ) \mapsto I

##### 6.12-32 AddInjectionOfCofactorOfPushout

`‣ AddInjectionOfCofactorOfPushout`( 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 `InjectionOfCofactorOfPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n}, k ) \mapsto \iota_k

##### 6.12-33 AddInjectionOfCofactorOfPushoutWithGivenPushout

`‣ AddInjectionOfCofactorOfPushoutWithGivenPushout`( 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 `InjectionOfCofactorOfPushoutWithGivenPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n}, k, I ) \mapsto \iota_k

##### 6.12-34 AddMorphismFromSourceToPushout

`‣ AddMorphismFromSourceToPushout`( 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 `MorphismFromSourceToPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n} ) \mapsto \mu

##### 6.12-35 AddMorphismFromSourceToPushoutWithGivenPushout

`‣ AddMorphismFromSourceToPushoutWithGivenPushout`( 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 `MorphismFromSourceToPushoutWithGivenPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n}, I ) \mapsto \mu

##### 6.12-36 AddUniversalMorphismFromPushout

`‣ AddUniversalMorphismFromPushout`( 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 `UniversalMorphismFromPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n}, \tau ) \mapsto u(\tau)

##### 6.12-37 AddUniversalMorphismFromPushoutWithGivenPushout

`‣ AddUniversalMorphismFromPushoutWithGivenPushout`( 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 `UniversalMorphismFromPushout`. F: ( (\beta_i: B \rightarrow I_i)_{i = 1 \dots n}, \tau, I ) \mapsto u(\tau)

##### 6.12-38 PushoutFunctorial

`‣ PushoutFunctorial`( Ls, Lm, Lr ) | ( operation )

Returns: a morphism in \mathrm{Hom}(\mathrm{Pushout}( ( \beta_i )_{i=1}^n ), \mathrm{Pushout}( ( \beta_i' )_{i=1}^n ))

The arguments are three lists of morphisms L_s = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, L_m = ( \mu_i: I_i \rightarrow I_i' )_{i = 1 \dots n}, L_r = ( \beta_i': B' \rightarrow I_i' )_{i = 1 \dots n} having the same length n such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, I_i'} \mu_i \circ \beta_i for i = 1, \dots n. The output is the morphism \mathrm{Pushout}( ( \beta_i )_{i=1}^n ) \rightarrow \mathrm{Pushout}( ( \beta_i' )_{i=1}^n ) given by the functoriality of the pushout.

##### 6.12-39 PushoutFunctorialWithGivenPushouts

`‣ PushoutFunctorialWithGivenPushouts`( s, Ls, Lm, Lr, r ) | ( operation )

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

The arguments are an object s = \mathrm{Pushout}( ( \beta_i )_{i=1}^n ), three lists of morphisms L_s = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, L_m = ( \mu_i: I_i \rightarrow I_i' )_{i = 1 \dots n}, L_r = ( \beta_i': B' \rightarrow I_i' )_{i = 1 \dots n} having the same length n such that there exists a morphism \beta: B \rightarrow B' such that \beta_i' \circ \beta \sim_{B, I_i'} \mu_i \circ \beta_i for i = 1, \dots n, and an object r = \mathrm{Pushout}( ( \beta_i' )_{i=1}^n ). The output is the morphism s \rightarrow r given by the functoriality of the pushout.

##### 6.12-40 AddPushoutFunctorialWithGivenPushouts

`‣ AddPushoutFunctorialWithGivenPushouts`( 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 `PushoutFunctorial`. F: ( \mathrm{Pushout}( ( \beta_i )_{i=1}^n ), ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}, ( \mu_i: I_i \rightarrow I_i' )_{i = 1 \dots n}, ( \beta_i': B' \rightarrow I_i' )_{i = 1 \dots n}, \mathrm{Pushout}( ( \beta_i' )_{i=1}^n ) ) ) \mapsto (\mathrm{Pushout}( ( \beta_i )_{i=1}^n ) \rightarrow \mathrm{Pushout}( ( \beta_i' )_{i=1}^n ) )

#### 6.13 Image

For a given morphism \alpha: A \rightarrow B, an image of \alpha consists of four parts:

- an object I,

- a morphism c: A \rightarrow I,

- a monomorphism \iota: I \hookrightarrow B such that \iota \circ c \sim_{A,B} \alpha,

- a dependent function u mapping each pair of morphisms \tau = ( \tau_1: A \rightarrow T, \tau_2: T \hookrightarrow B ) where \tau_2 is a monomorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha to a morphism u(\tau): I \rightarrow T such that \tau_2 \circ u(\tau) \sim_{I,B} \iota and u(\tau) \circ c \sim_{A,T} \tau_1.

The 4-tuple ( I, c, \iota, u ) is called an image of \alpha if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object I of such a 4-tuple by \mathrm{im}(\alpha). We say that the morphism u( \tau ) is induced by the universal property of the image.

##### 6.13-1 IsomorphismFromImageObjectToKernelOfCokernel

`‣ IsomorphismFromImageObjectToKernelOfCokernel`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}( \mathrm{im}(\alpha), \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ) )

The argument is a morphism \alpha. The output is the canonical morphism \mathrm{im}(\alpha) \rightarrow \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ).

##### 6.13-2 AddIsomorphismFromImageObjectToKernelOfCokernel

`‣ AddIsomorphismFromImageObjectToKernelOfCokernel`( 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 `IsomorphismFromImageObjectToKernelOfCokernel`. F: \alpha \mapsto ( \mathrm{im}(\alpha) \rightarrow \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ) )

##### 6.13-3 IsomorphismFromKernelOfCokernelToImageObject

`‣ IsomorphismFromKernelOfCokernelToImageObject`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}( \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ), \mathrm{im}(\alpha) )

The argument is a morphism \alpha. The output is the canonical morphism \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ) \rightarrow \mathrm{im}(\alpha).

##### 6.13-4 AddIsomorphismFromKernelOfCokernelToImageObject

`‣ AddIsomorphismFromKernelOfCokernelToImageObject`( 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 `IsomorphismFromKernelOfCokernelToImageObject`. F: \alpha \mapsto ( \mathrm{KernelObject}( \mathrm{CokernelProjection}( \alpha ) ) \rightarrow \mathrm{im}(\alpha) )

##### 6.13-5 ImageObject

`‣ ImageObject`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha. The output is the image \mathrm{im}( \alpha ).

##### 6.13-6 ImageEmbedding

`‣ ImageEmbedding`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the image embedding \iota: \mathrm{im}(\alpha) \hookrightarrow B.

##### 6.13-7 ImageEmbeddingWithGivenImageObject

`‣ ImageEmbeddingWithGivenImageObject`( alpha, I ) | ( operation )

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

The argument is a morphism \alpha: A \rightarrow B and an object I = \mathrm{im}( \alpha ). The output is the image embedding \iota: I \hookrightarrow B.

##### 6.13-8 CoastrictionToImage

`‣ CoastrictionToImage`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the coastriction to image c: A \rightarrow \mathrm{im}( \alpha ).

##### 6.13-9 CoastrictionToImageWithGivenImageObject

`‣ CoastrictionToImageWithGivenImageObject`( alpha, I ) | ( operation )

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

The argument is a morphism \alpha: A \rightarrow B and an object I = \mathrm{im}( \alpha ). The output is the coastriction to image c: A \rightarrow I.

##### 6.13-10 UniversalMorphismFromImage

`‣ UniversalMorphismFromImage`( alpha, tau ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and a pair of morphisms \tau = ( \tau_1: A \rightarrow T, \tau_2: T \hookrightarrow B ) where \tau_2 is a monomorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha. The output is the morphism u(\tau): \mathrm{im}(\alpha) \rightarrow T given by the universal property of the image.

##### 6.13-11 UniversalMorphismFromImageWithGivenImageObject

`‣ UniversalMorphismFromImageWithGivenImageObject`( alpha, tau, I ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B, a pair of morphisms \tau = ( \tau_1: A \rightarrow T, \tau_2: T \hookrightarrow B ) where \tau_2 is a monomorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha, and an object I = \mathrm{im}( \alpha ). The output is the morphism u(\tau): \mathrm{im}(\alpha) \rightarrow T given by the universal property of the image.

##### 6.13-12 AddImageObject

`‣ AddImageObject`( 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 `ImageObject`. F: \alpha \mapsto I.

##### 6.13-13 AddImageEmbedding

`‣ AddImageEmbedding`( 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 `ImageEmbedding`. F: \alpha \mapsto \iota.

##### 6.13-14 AddImageEmbeddingWithGivenImageObject

`‣ AddImageEmbeddingWithGivenImageObject`( 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 `ImageEmbeddingWithGivenImageObject`. F: (\alpha,I) \mapsto \iota.

##### 6.13-15 AddCoastrictionToImage

`‣ AddCoastrictionToImage`( 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 `CoastrictionToImage`. F: \alpha \mapsto c.

##### 6.13-16 AddCoastrictionToImageWithGivenImageObject

`‣ AddCoastrictionToImageWithGivenImageObject`( 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 `CoastrictionToImageWithGivenImageObject`. F: (\alpha,I) \mapsto c.

##### 6.13-17 AddUniversalMorphismFromImage

`‣ AddUniversalMorphismFromImage`( 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 `UniversalMorphismFromImage`. F: (\alpha, \tau) \mapsto u(\tau).

##### 6.13-18 AddUniversalMorphismFromImageWithGivenImageObject

`‣ AddUniversalMorphismFromImageWithGivenImageObject`( 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 `UniversalMorphismFromImageWithGivenImageObject`. F: (\alpha, \tau, I) \mapsto u(\tau).

#### 6.14 Coimage

For a given morphism \alpha: A \rightarrow B, a coimage of \alpha consists of four parts:

- an object C,

- an epimorphism \pi: A \twoheadrightarrow C,

- a morphism a: C \rightarrow B such that a \circ \pi \sim_{A,B} \alpha,

- a dependent function u mapping each pair of morphisms \tau = ( \tau_1: A \twoheadrightarrow T, \tau_2: T \rightarrow B ) where \tau_1 is an epimorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha to a morphism u(\tau): T \rightarrow C such that u( \tau ) \circ \tau_1 \sim_{A,C} \pi and a \circ u( \tau ) \sim_{T,B} \tau_2.

The 4-tuple ( C, \pi, a, u ) is called a coimage of \alpha if the morphisms u( \tau ) are uniquely determined up to congruence of morphisms. We denote the object C of such a 4-tuple by \mathrm{coim}(\alpha). We say that the morphism u( \tau ) is induced by the universal property of the coimage.

##### 6.14-1 MorphismFromCoimageToImage

`‣ MorphismFromCoimageToImage`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the canonical morphism (in a preabelian category) \mathrm{coim}(\alpha) \rightarrow \mathrm{im}(\alpha).

##### 6.14-2 MorphismFromCoimageToImageWithGivenObjects

`‣ MorphismFromCoimageToImageWithGivenObjects`( alpha ) | ( operation )

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

The argument is an object C = \mathrm{coim}(\alpha), a morphism \alpha: A \rightarrow B, and an object I = \mathrm{im}(\alpha). The output is the canonical morphism (in a preabelian category) C \rightarrow I.

##### 6.14-3 AddMorphismFromCoimageToImageWithGivenObjects

`‣ AddMorphismFromCoimageToImageWithGivenObjects`( 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 `MorphismFromCoimageToImageWithGivenObjects`. F: (C, \alpha, I) \mapsto ( C \rightarrow I ).

##### 6.14-4 InverseMorphismFromCoimageToImage

`‣ InverseMorphismFromCoimageToImage`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the inverse of the canonical morphism (in an abelian category) \mathrm{im}(\alpha) \rightarrow \mathrm{coim}(\alpha).

##### 6.14-5 InverseMorphismFromCoimageToImageWithGivenObjects

`‣ InverseMorphismFromCoimageToImageWithGivenObjects`( C, alpha, I ) | ( operation )

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

The argument is an object C = \mathrm{coim}(\alpha), a morphism \alpha: A \rightarrow B, and an object I = \mathrm{im}(\alpha). The output is the inverse of the canonical morphism (in an abelian category) I \rightarrow C.

##### 6.14-6 AddInverseMorphismFromCoimageToImageWithGivenObjects

`‣ AddInverseMorphismFromCoimageToImageWithGivenObjects`( 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 `MorphismFromCoimageToImageWithGivenObjects`. F: (C, \alpha, I) \mapsto ( I \rightarrow C ).

##### 6.14-7 IsomorphismFromCoimageToCokernelOfKernel

`‣ IsomorphismFromCoimageToCokernelOfKernel`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}( \mathrm{coim}( \alpha ), \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ) ).

The argument is a morphism \alpha: A \rightarrow B. The output is the canonical morphism \mathrm{coim}( \alpha ) \rightarrow \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ).

##### 6.14-8 AddIsomorphismFromCoimageToCokernelOfKernel

`‣ AddIsomorphismFromCoimageToCokernelOfKernel`( 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 `IsomorphismFromCoimageToCokernelOfKernel`. F: \alpha \mapsto ( \mathrm{coim}( \alpha ) \rightarrow \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ) ).

##### 6.14-9 IsomorphismFromCokernelOfKernelToCoimage

`‣ IsomorphismFromCokernelOfKernelToCoimage`( alpha ) | ( attribute )

Returns: a morphism in \mathrm{Hom}( \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ), \mathrm{coim}( \alpha ) ).

The argument is a morphism \alpha: A \rightarrow B. The output is the canonical morphism \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ) \rightarrow \mathrm{coim}( \alpha ).

##### 6.14-10 AddIsomorphismFromCokernelOfKernelToCoimage

`‣ AddIsomorphismFromCokernelOfKernelToCoimage`( 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 `IsomorphismFromCokernelOfKernelToCoimage`. F: \alpha \mapsto ( \mathrm{CokernelObject}( \mathrm{KernelEmbedding}( \alpha ) ) \rightarrow \mathrm{coim}( \alpha ) ).

##### 6.14-11 Coimage

`‣ Coimage`( alpha ) | ( attribute )

Returns: an object

The argument is a morphism \alpha. The output is the coimage \mathrm{coim}( \alpha ).

##### 6.14-12 CoimageProjection

`‣ CoimageProjection`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the coimage projection \pi: A \twoheadrightarrow \mathrm{coim}( \alpha ).

##### 6.14-13 CoimageProjectionWithGivenCoimage

`‣ CoimageProjectionWithGivenCoimage`( alpha, C ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and an object C = \mathrm{coim}(\alpha). The output is the coimage projection \pi: A \twoheadrightarrow C.

##### 6.14-14 AstrictionToCoimage

`‣ AstrictionToCoimage`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the astriction to coimage a: \mathrm{coim}( \alpha ) \rightarrow B.

##### 6.14-15 AstrictionToCoimageWithGivenCoimage

`‣ AstrictionToCoimageWithGivenCoimage`( alpha, C ) | ( operation )

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

The argument are a morphism \alpha: A \rightarrow B and an object C = \mathrm{coim}( \alpha ). The output is the astriction to coimage a: C \rightarrow B.

##### 6.14-16 UniversalMorphismIntoCoimage

`‣ UniversalMorphismIntoCoimage`( alpha, tau ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B and a pair of morphisms \tau = ( \tau_1: A \twoheadrightarrow T, \tau_2: T \rightarrow B ) where \tau_1 is an epimorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha. The output is the morphism u(\tau): T \rightarrow \mathrm{coim}( \alpha ) given by the universal property of the coimage.

##### 6.14-17 UniversalMorphismIntoCoimageWithGivenCoimage

`‣ UniversalMorphismIntoCoimageWithGivenCoimage`( alpha, tau, C ) | ( operation )

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

The arguments are a morphism \alpha: A \rightarrow B, a pair of morphisms \tau = ( \tau_1: A \twoheadrightarrow T, \tau_2: T \rightarrow B ) where \tau_1 is an epimorphism such that \tau_2 \circ \tau_1 \sim_{A,B} \alpha, and an object C = \mathrm{coim}( \alpha ). The output is the morphism u(\tau): T \rightarrow C given by the universal property of the coimage.

##### 6.14-18 AddCoimage

`‣ AddCoimage`( 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 `Coimage`. F: \alpha \mapsto C

##### 6.14-19 AddCoimageProjection

`‣ AddCoimageProjection`( 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 `CoimageProjection`. F: \alpha \mapsto \pi

##### 6.14-20 AddCoimageProjectionWithGivenCoimage

`‣ AddCoimageProjectionWithGivenCoimage`( 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 `CoimageProjectionWithGivenCoimage`. F: (\alpha,C) \mapsto \pi

##### 6.14-21 AddAstrictionToCoimage

`‣ AddAstrictionToCoimage`( 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 `AstrictionToCoimage`. F: \alpha \mapsto a

##### 6.14-22 AddAstrictionToCoimageWithGivenCoimage

`‣ AddAstrictionToCoimageWithGivenCoimage`( 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 `AstrictionToCoimageWithGivenCoimage`. F: (\alpha,C) \mapsto a

##### 6.14-23 AddUniversalMorphismIntoCoimage

`‣ AddUniversalMorphismIntoCoimage`( 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 `UniversalMorphismIntoCoimage`. F: (\alpha, \tau) \mapsto u(\tau)

##### 6.14-24 AddUniversalMorphismIntoCoimageWithGivenCoimage

`‣ AddUniversalMorphismIntoCoimageWithGivenCoimage`( 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 `UniversalMorphismIntoCoimageWithGivenCoimage`. F: (\alpha, \tau,C) \mapsto u(\tau)

Whenever the `CoastrictionToImage` is an epi, or the `AstrictionToCoimage` is a mono, there is a canonical morphism from the image to the coimage. If this canonical morphism is an isomorphism, we call it the canonical identification (between image and coimage).

##### 6.14-25 CanonicalIdentificationFromImageObjectToCoimage

`‣ CanonicalIdentificationFromImageObjectToCoimage`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the canonical identification c: \mathrm{im}( \alpha ) \rightarrow \mathrm{coim}( \alpha ).

##### 6.14-26 AddCanonicalIdentificationFromImageObjectToCoimage

`‣ AddCanonicalIdentificationFromImageObjectToCoimage`( 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 `CanonicalIdentificationFromImageObjectToCoimage`. F: \alpha \mapsto c

##### 6.14-27 CanonicalIdentificationFromCoimageToImageObject

`‣ CanonicalIdentificationFromCoimageToImageObject`( alpha ) | ( attribute )

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

The argument is a morphism \alpha: A \rightarrow B. The output is the canonical identification c: \mathrm{coim}( \alpha ) \rightarrow \mathrm{im}( \alpha ).

##### 6.14-28 AddCanonicalIdentificationFromCoimageToImageObject

`‣ AddCanonicalIdentificationFromCoimageToImageObject`( 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 `CanonicalIdentificationFromCoimageToImageObject`. F: \alpha \mapsto c

#### 6.15 Homology objects

In an abelian category, we can define the operation that takes as an input a pair of morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C and outputs the subquotient of B given by

- H := \mathrm{KernelObject}( \beta )/ (\mathrm{KernelObject}( \beta ) \cap \mathrm{ImageObject( \alpha )}).

This object is called a homology object of the pair \alpha, \beta. Note that we do not need the precomposition of \alpha and \beta to be zero in order to make sense of this notion. Moreover, given a second pair \gamma: D \rightarrow E, \delta: E \rightarrow F of morphisms, and a morphism \epsilon: B \rightarrow E such that there exists \omega_1: A \rightarrow D, \omega_2: C \rightarrow F with \epsilon \circ \alpha \sim_{A,E} \gamma \circ \omega_1 and \omega_2 \circ \beta \sim_{B,F} \delta \circ \epsilon there is a functorial way to obtain from these data a morphism between the two corresponding homology objects.

##### 6.15-1 HomologyObject

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

Returns: an object

The arguments are two morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C. The output is the homology object H of this pair.

##### 6.15-2 HomologyObjectFunctorial

`‣ HomologyObjectFunctorial`( alpha, beta, epsilon, gamma, delta ) | ( operation )

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

The argument are five morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C, \epsilon: B \rightarrow E, \gamma: D \rightarrow E, \delta: E \rightarrow F such that there exists \omega_1: A \rightarrow D, \omega_2: C \rightarrow F with \epsilon \circ \alpha \sim_{A,E} \gamma \circ \omega_1 and \omega_2 \circ \beta \sim_{B,F} \delta \circ \epsilon. The output is the functorial morphism induced by \epsilon between the corresponding homology objects H_1 and H_2, where H_1 denotes the homology object of the pair \alpha, \beta, and H_2 denotes the homology object of the pair \gamma, \delta.

##### 6.15-3 HomologyObjectFunctorialWithGivenHomologyObjects

`‣ HomologyObjectFunctorialWithGivenHomologyObjects`( H_1, L, H_2 ) | ( operation )

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

The arguments are an object H_1, a list L consisting of five morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C, \epsilon: B \rightarrow E, \gamma: D \rightarrow E, \delta: E \rightarrow F, and an object H_2, such that H_1 = \mathrm{HomologyObject}( \alpha, \beta ) and H_2 = \mathrm{HomologyObject}( \gamma, \delta ), and such that there exists \omega_1: A \rightarrow D, \omega_2: C \rightarrow F with \epsilon \circ \alpha \sim_{A,E} \gamma \circ \omega_1 and \omega_2 \circ \beta \sim_{B,F} \delta \circ \epsilon. The output is the functorial morphism induced by \epsilon between the corresponding homology objects H_1 and H_2, where H_1 denotes the homology object of the pair \alpha, \beta, and H_2 denotes the homology object of the pair \gamma, \delta.

##### 6.15-4 IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject

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

Returns: a morphism in \mathrm{Hom}( \mathrm{HomologyObject}( \alpha, \beta ), I )

The arguments are two morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C. The output is the natural isomorphism from the homology object H of \alpha and \beta to the construction of the homology object as \mathrm{ImageObject}( \mathrm{PreCompose}( \mathrm{KernelEmbedding}( \beta ), \mathrm{CokernelProjection}( \alpha ) ) ), denoted by I.

##### 6.15-5 IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject

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

Returns: a morphism in \mathrm{Hom}( I, \mathrm{HomologyObject}( \alpha, \beta ) )

The arguments are two morphisms \alpha: A \rightarrow B, \beta: B \rightarrow C. The output is the natural isomorphism from the construction of the homology object as \mathrm{ImageObject}( \mathrm{PreCompose}( \mathrm{KernelEmbedding}( \beta ), \mathrm{CokernelProjection}( \alpha ) ) ), denoted by I, to the homology object H of \alpha and \beta.

##### 6.15-6 AddHomologyObject

`‣ AddHomologyObject`( 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 `HomologyObject`. F: (\alpha, \beta) \mapsto \mathrm{HomologyObject}(\alpha, \beta).

##### 6.15-7 AddHomologyObjectFunctorialWithGivenHomologyObjects

`‣ AddHomologyObjectFunctorialWithGivenHomologyObjects`( 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 `AddHomologyObjectFunctorialWithGivenHomologyObjects`. F: (H_1, \alpha, \beta, \epsilon, \gamma, \delta, H_2) \mapsto (H_1 \rightarrow H_2)

[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