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' )\).
‣ KernelObject( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \(\alpha\). The output is the kernel \(K\) of \(\alpha\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ KernelLift( alpha, T, tau ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(T,\mathrm{KernelObject}(\alpha))\)
The arguments are a morphism \(\alpha: A \rightarrow B\), a test object \(T\), and a test morphism \(\tau: T \rightarrow A\) satisfying \(\alpha \circ \tau \sim_{T,B} 0\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u(\tau): T \rightarrow \mathrm{KernelObject}(\alpha)\) given by the universal property of the kernel.
‣ KernelLiftWithGivenKernelObject( alpha, T, tau, K ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(T,K)\)
The arguments are a morphism \(\alpha: A \rightarrow B\), a test object \(T\), a test morphism \(\tau: T \rightarrow A\) satisfying \(\alpha \circ \tau \sim_{T,B} 0\), and an object \(K = \mathrm{KernelObject}(\alpha)\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u(\tau): T \rightarrow K\) given by the universal property of the kernel.
‣ 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.
‣ 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.
‣ 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.
‣ 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.
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' )\).
‣ CokernelObject( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \(\alpha: A \rightarrow B\). The output is the cokernel \(K\) of \(\alpha\).
‣ 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 )\).
‣ 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 )\).
‣ 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)\).
‣ 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\).
‣ CokernelColift( alpha, T, tau ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{CokernelObject}(\alpha),T)\)
The arguments are a morphism \(\alpha: A \rightarrow B\), a test object \(T\), and a test morphism \(\tau: B \rightarrow T\) satisfying \(\tau \circ \alpha \sim_{A, T} 0\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u(\tau): \mathrm{CokernelObject}(\alpha) \rightarrow T\) given by the universal property of the cokernel.
‣ CokernelColiftWithGivenCokernelObject( alpha, T, tau, K ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(K,T)\)
The arguments are a morphism \(\alpha: A \rightarrow B\), a test object \(T\), a test morphism \(\tau: B \rightarrow T\) satisfying \(\tau \circ \alpha \sim_{A, T} 0\), and an object \(K = \mathrm{CokernelObject}(\alpha)\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u(\tau): K \rightarrow T\) given by the universal property of the cokernel.
‣ 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.
‣ 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.
‣ 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.
‣ 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.
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.
‣ ZeroObject( C ) | ( attribute ) |
Returns: an object
The argument is a category \(C\). The output is a zero object \(Z\) of \(C\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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}\).
‣ 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\).
‣ MorphismFromZeroObject( A ) | ( attribute ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{ZeroObject}, A)\)
This is a synonym for UniversalMorphismFromZeroObject.
‣ MorphismIntoZeroObject( A ) | ( attribute ) |
Returns: a morphism in \(\mathrm{Hom}(A, \mathrm{ZeroObject})\)
This is a synonym for UniversalMorphismIntoZeroObject.
‣ 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}\).
‣ 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}\).
‣ 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}\).
‣ 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}\).
‣ 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}\).
‣ ZeroObjectFunctorialWithGivenZeroObjects( C, zero_object1, zero_object2 ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(zero_object1, zero_object2)\)
The argument is a category \(C\) and a zero object \(\mathrm{ZeroObject}(C)\) twice (for compatibility with other functorials). The output is the unique morphism \(zero_object1 \rightarrow zero_object2\).
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\).
‣ TerminalObject( C ) | ( attribute ) |
Returns: an object
The argument is a category \(C\). The output is a terminal object \(T\) of \(C\).
‣ 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\).
‣ 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}\).
‣ 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\).
‣ 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}\).
‣ TerminalObjectFunctorialWithGivenTerminalObjects( C, terminal_object1, terminal_object2 ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(terminal_object1, terminal_object2)\)
The argument is a category \(C\) and a terminal object \(\mathrm{TerminalObject}(C)\) twice (for compatibility with other functorials). The output is the unique morphism \(terminal_object1 \rightarrow terminal_object2\).
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\).
‣ InitialObject( C ) | ( attribute ) |
Returns: an object
The argument is a category \(C\). The output is an initial object \(I\) of \(C\).
‣ 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\).
‣ UniversalMorphismFromInitialObject( A ) | ( attribute ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{InitialObject}, A)\).
The argument is an object \(A\). The output is the universal morphism \(u(A): \mathrm{InitialObject} \rightarrow A\).
‣ UniversalMorphismFromInitialObjectWithGivenInitialObject( A, I ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(I, 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\).
‣ 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}\).
‣ InitialObjectFunctorialWithGivenInitialObjects( C, initial_object1, initial_object2 ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(initial_object1, initial_object2)\)
The argument is a category \(C\) and an initial object \(\mathrm{InitialObject}(C)\) twice (for compatibility with other functorials). The output is the unique morphism \(initial_object1 \rightarrow initial_object2\).
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'\).
‣ DirectSum( 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 objects \(D = (S_1, \dots, S_n)\).
The arguments are objects \(S_1, \dots, S_n\).
The output is the direct sum \(\bigoplus_{i=1}^n S_i\).
‣ DirectSumOp( D ) | ( operation ) |
Returns: an object
The argument is a list of objects \(D = (S_1, \dots, S_n)\). The output is the direct sum \(\bigoplus_{i=1}^n S_i\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ UniversalMorphismIntoDirectSum( D, T, tau ) | ( 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 test object \(T\), and a list of morphisms \(\tau = ( \tau_i: T \rightarrow S_i )_{i = 1 \dots n}\). For convenience, the diagram D and/or the test object T can be omitted and are automatically derived from tau in that case. 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.
‣ UniversalMorphismIntoDirectSumWithGivenDirectSum( D, T, 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 test object \(T\), 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\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u_{\mathrm{in}}(\tau): T \rightarrow S\) given by the universal property of the direct sum.
‣ UniversalMorphismFromDirectSum( D, T, tau ) | ( 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 test object \(T\), and a list of morphisms \(\tau = ( \tau_i: S_i \rightarrow T )_{i = 1 \dots n}\). For convenience, the diagram D and/or the test object T can be omitted and are automatically derived from tau in that case. 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.
‣ UniversalMorphismFromDirectSumWithGivenDirectSum( D, T, 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 test object \(T\), 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\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u_{\mathrm{out}}(\tau): S \rightarrow T\) given by the universal property of the direct sum.
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ MorphismBetweenDirectSums( diagram_S, M, diagram_T ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\bigoplus_{i=1}^{m}A_i, \bigoplus_{j=1}^n B_j)\)
The arguments are given as follows:
diagram_S is a list of objects \((A_i)_{i = 1 \dots m}\),
diagram_T is a list of objects \((B_j)_{j = 1 \dots n}\),
M is a list of lists of morphisms \(( ( \phi_{i,j}: A_i \rightarrow B_j )_{j = 1 \dots n} )_{i = 1 \dots m}\).
The output is the morphism \(\bigoplus_{i=1}^{m}A_i \rightarrow \bigoplus_{j=1}^n B_j\) defined by the matrix \(M\).
‣ MorphismBetweenDirectSums( M ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\bigoplus_{i=1}^{m}A_i, \bigoplus_{j=1}^n B_j)\)
This is a convenience method. The argument \(M = ( ( \phi_{i,j}: A_i \rightarrow B_j )_{j = 1 \dots n} )_{i = 1 \dots m}\) is a (non-empty) list of (non-empty) 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\).
‣ MorphismBetweenDirectSumsWithGivenDirectSums( S, diagram_S, M, diagram_T, T ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\bigoplus_{i=1}^{m}A_i, \bigoplus_{j=1}^n B_j)\)
The arguments are given as follows:
diagram_S is a list of objects \((A_i)_{i = 1 \dots m}\),
diagram_T is a list of objects \((B_j)_{j = 1 \dots n}\),
S is the direct sum \(\bigoplus_{i=1}^{m}A_i\),
T is the direct sum \(\bigoplus_{j=1}^{n}B_j\),
M is a list of lists of morphisms \(( ( \phi_{i,j}: A_i \rightarrow B_j )_{j = 1 \dots n} )_{i = 1 \dots m}\).
The output is the morphism \(\bigoplus_{i=1}^{m}A_i \rightarrow \bigoplus_{j=1}^n B_j\) defined by the matrix \(M\).
‣ 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\).
‣ 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\).
‣ DirectSumFunctorial( source_diagram, L, range_diagram ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \bigoplus_{i=1}^n S_i, \bigoplus_{i=1}^n S_i' )\)
The arguments are a list of objects \((S_i)_{i = 1 \dots n}\), a list of morphisms \(L = ( \mu_1: S_1 \rightarrow S_1', \dots, \mu_n: S_n \rightarrow S_n' )\), and a list of objects \((S_i')_{i = 1 \dots n}\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. 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.
‣ DirectSumFunctorialWithGivenDirectSums( d_1, source_diagram, L, range_diagram, 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 objects \((S_i)_{i = 1 \dots n}\), a list of morphisms \(L = ( \mu_1: S_1 \rightarrow S_1', \dots, \mu_n: S_n \rightarrow S_n' )\), a list of objects \((S_i')_{i = 1 \dots n}\), and an object \(d_2 = \bigoplus_{i=1}^n S_i'\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. The output is a morphism \(d_1 \rightarrow d_2\) given by the functoriality of the direct sum.
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'\).
‣ Coproduct( D ) | ( operation ) |
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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ UniversalMorphismFromCoproduct( D, T, tau ) | ( 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 test object \(T\), and a list of morphisms \(\tau = ( \tau_i: I_i \rightarrow T )\). For convenience, the diagram D and/or the test object T can be omitted and are automatically derived from tau in that case. The output is the morphism \(u( \tau ): \bigsqcup_{i=1}^n I_i \rightarrow T\) given by the universal property of the coproduct.
‣ UniversalMorphismFromCoproductWithGivenCoproduct( D, T, 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 test object \(T\), a list of morphisms \(\tau = ( \tau_i: I_i \rightarrow T )\), and an object \(I = \bigsqcup_{i=1}^n I_i\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): I \rightarrow T\) given by the universal property of the coproduct.
‣ CoproductFunctorial( source_diagram, L, range_diagram ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\bigsqcup_{i=1}^n I_i, \bigsqcup_{i=1}^n I_i')\)
The arguments are a list of objects \((I_i)_{i = 1 \dots n}\), a list \(L = ( \mu_1: I_1 \rightarrow I_1', \dots, \mu_n: I_n \rightarrow I_n' )\), and a list of objects \((I_i')_{i = 1 \dots n}\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. 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.
‣ CoproductFunctorialWithGivenCoproducts( s, source_diagram, L, range_diagram, r ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(s, r)\)
The arguments are an object \(s = \bigsqcup_{i=1}^n I_i\), a list of objects \((I_i)_{i = 1 \dots n}\), a list \(L = ( \mu_1: I_1 \rightarrow I_1', \dots, \mu_n: I_n \rightarrow I_n' )\), a list of objects \((I_i')_{i = 1 \dots n}\), and an object \(r = \bigsqcup_{i=1}^n I_i'\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. 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.
‣ ComponentOfMorphismFromCoproduct( alpha, D, k ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(I_k, A)\)
The arguments are a morphism \(\alpha: I \rightarrow A\), a list \(D = (I_1, \dots, I_n)\) of objects with \(I = \bigsqcup_{j=1}^n I_j\), and an integer \(k\). The output is the component morphism \(I_k \rightarrow A\).
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'\).
‣ DirectProduct( 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 objects \(D = ( P_1, \dots, P_n )\).
The arguments are objects \(P_1, \dots, P_n\).
The output is the direct product \(\prod_{i=1}^n P_i\).
‣ DirectProductOp( D ) | ( operation ) |
Returns: an object
The argument is a list of objects \(D = ( P_1, \dots, P_n )\). The output is the direct product \(\prod_{i=1}^n P_i\).
‣ 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\).
‣ 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\).
‣ UniversalMorphismIntoDirectProduct( D, T, tau ) | ( 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 test object \(T\), and a list of morphisms \(\tau = ( \tau_i: T \rightarrow P_i )_{i = 1, \dots, n}\). For convenience, the diagram D and/or the test object T can be omitted and are automatically derived from tau in that case. The output is the morphism \(u(\tau): T \rightarrow \prod_{i=1}^n P_i\) given by the universal property of the direct product.
‣ UniversalMorphismIntoDirectProductWithGivenDirectProduct( D, T, 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 test object \(T\), 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\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u(\tau): T \rightarrow \prod_{i=1}^n P_i\) given by the universal property of the direct product.
‣ DirectProductFunctorial( source_diagram, L, range_diagram ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \prod_{i=1}^n P_i, \prod_{i=1}^n P_i' )\)
The arguments are a list of objects \((P_i)_{i = 1 \dots n}\), a list of morphisms \(L = (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}\), and a list of objects \((P_i')_{i = 1 \dots n}\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. 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.
‣ DirectProductFunctorialWithGivenDirectProducts( s, source_diagram, L, range_diagram, 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 objects \((P_i)_{i = 1 \dots n}\), a list of morphisms \(L = (\mu_i: P_i \rightarrow P'_i)_{i=1\dots n}\), a list of objects \((P_i')_{i = 1 \dots n}\), and an object \(r = \prod_{i=1}^n P_i'\). For convenience, source_diagram and range_diagram can be omitted and are automatically derived from L in that case. 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.
‣ ComponentOfMorphismIntoDirectProduct( alpha, D, k ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(A, P_k)\)
The arguments are a morphism \(\alpha: A \rightarrow P\), a list \(D = (P_1, \dots, P_n)\) of objects with \(P = \prod_{j=1}^n P_j\), and an integer \(k\). The output is the component morphism \(A \rightarrow P_k\).
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' )\).
‣ Equalizer( arg ) | ( function ) |
Returns: an object
This is a convenience method. There are three different ways to use this method:
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\).
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)\).
‣ EqualizerOp( A, D ) | ( operation ) |
Returns: an object
The arguments are an object \(A\) and list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the equalizer \(\mathrm{Equalizer}(D)\).
‣ EmbeddingOfEqualizer( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{Equalizer}(D), A )\)
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the equalizer embedding \(\iota: \mathrm{Equalizer}(D) \rightarrow A\).
‣ EmbeddingOfEqualizerWithGivenEqualizer( A, D, E ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( E, A )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\), and an object \(E = \mathrm{Equalizer}(D)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the equalizer embedding \(\iota: E \rightarrow A\).
‣ MorphismFromEqualizerToSink( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{Equalizer}(D), B )\)
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the composition \(\mu: \mathrm{Equalizer}(D) \rightarrow B\) of the embedding \(\iota: \mathrm{Equalizer}(D) \rightarrow A\) and \(\beta_1\).
‣ MorphismFromEqualizerToSinkWithGivenEqualizer( A, D, E ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( E, B )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\) and an object \(E = \mathrm{Equalizer}(D)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the composition \(\mu: E \rightarrow B\) of the embedding \(\iota: E \rightarrow A\) and \(\beta_1\).
‣ UniversalMorphismIntoEqualizer( A, D, T, tau ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( T, \mathrm{Equalizer}(D) )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\), a test object \(T\), 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\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): T \rightarrow \mathrm{Equalizer}(D)\) given by the universal property of the equalizer.
‣ UniversalMorphismIntoEqualizerWithGivenEqualizer( A, D, T, tau, E ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( T, E )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\), a test object \(T\), 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)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): T \rightarrow E\) given by the universal property of the equalizer.
‣ 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.
‣ 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.
‣ JointPairwiseDifferencesOfMorphismsIntoDirectProduct( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( A, \prod_{i=1}^{n-1} B )\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). The output is a morphism \(A \rightarrow \prod_{i=1}^{n-1} B\) such that its kernel equalizes the \(\beta_i\).
‣ IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{Equalizer}(D), \Delta)\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). The output is a morphism \(\mathrm{Equalizer}(D) \rightarrow \Delta\), where \(\Delta\) denotes the kernel object equalizing the morphisms \(\beta_i\).
‣ IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\Delta, \mathrm{Equalizer}(D))\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: A \rightarrow B )_{i = 1 \dots n}\). The output is a morphism \(\Delta \rightarrow \mathrm{Equalizer}(D)\), where \(\Delta\) denotes the kernel object equalizing the morphisms \(\beta_i\).
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' )\).
‣ Coequalizer( arg ) | ( function ) |
Returns: an object
This is a convenience method. There are three different ways to use this method:
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\).
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)\).
‣ CoequalizerOp( A, D ) | ( operation ) |
Returns: an object
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the coequalizer \(\mathrm{Coequalizer}(D)\).
‣ ProjectionOntoCoequalizer( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( A, \mathrm{Coequalizer}( D ) )\).
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the projection \(\pi: A \rightarrow \mathrm{Coequalizer}( D )\).
‣ ProjectionOntoCoequalizerWithGivenCoequalizer( A, D, C ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( A, C )\).
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\), and an object \(C = \mathrm{Coequalizer}(D)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the projection \(\pi: A \rightarrow C\).
‣ MorphismFromSourceToCoequalizer( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( B, \mathrm{Coequalizer}( D ) )\).
The arguments are an object \(A\) and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the composition \(\mu: B \rightarrow \mathrm{Coequalizer}(D)\) of \(\beta_1\) and the projection \(\pi: A \rightarrow \mathrm{Coequalizer}( D )\).
‣ MorphismFromSourceToCoequalizerWithGivenCoequalizer( A, D, C ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( B, C )\).
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\) and an object \(C = \mathrm{Coequalizer}(D)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. The output is the composition \(\mu: B \rightarrow C\) of \(\beta_1\) and the projection \(\pi: A \rightarrow C\).
‣ UniversalMorphismFromCoequalizer( A, D, T, tau ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{Coequalizer}(D), T )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\), a test object \(T\), 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\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): \mathrm{Coequalizer}(D) \rightarrow T\) given by the universal property of the coequalizer.
‣ UniversalMorphismFromCoequalizerWithGivenCoequalizer( A, D, T, tau, C ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( C, T )\)
The arguments are an object \(A\), a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\), a test object \(T\), 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)\). For convenience, the object \(A\) can be omitted and is automatically derived from \(D\) in that case. For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): C \rightarrow T\) given by the universal property of the coequalizer.
‣ 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.
‣ 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.
‣ JointPairwiseDifferencesOfMorphismsFromCoproduct( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\bigsqcup_{i=1}^{n-1} B, A)\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). The output is a morphism \(\bigsqcup_{i=1}^{n-1} B \rightarrow A\) such that its cokernel coequalizes the \(\beta_i\).
‣ IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{Coequalizer}(D), \Delta)\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). The output is a morphism \(\mathrm{Coequalizer}(D) \rightarrow \Delta\), where \(\Delta\) denotes the cokernel object coequalizing the morphisms \(\beta_i\).
‣ IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( A, D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\Delta, \mathrm{Coequalizer}(D))\)
The arguments are an object A and a list of morphisms \(D = ( \beta_i: B \rightarrow A )_{i = 1 \dots n}\). The output is a morphism \(\Delta \rightarrow \mathrm{Coequalizer}(D)\), where \(\Delta\) denotes the cokernel object coequalizing the morphisms \(\beta_i\).
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' )\).
‣ 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\).
‣ 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\).
‣ FiberProductEmbeddingInDirectProduct( D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{FiberProduct}(D), \prod_{i=1}^n P_i )\)
This is a convenience method. 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 \prod_{i=1}^n P_i\).
‣ FiberProductEmbeddingInDirectSum( D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{FiberProduct}(D), \bigoplus_{i=1}^n P_i )\)
This is a convenience method. 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\).
‣ 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)\).
‣ FiberProductOp( D ) | ( operation ) |
Returns: an object
The argument is a list of morphisms \(D = ( \beta_i: P_i \rightarrow B )_{i = 1 \dots n}\). The output is the fiber product \(\mathrm{FiberProduct}(D)\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ UniversalMorphismIntoFiberProduct( D, T, tau ) | ( 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 test object \(T\), 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\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): T \rightarrow \mathrm{FiberProduct}(D)\) given by the universal property of the fiber product.
‣ UniversalMorphismIntoFiberProductWithGivenFiberProduct( D, T, 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 test object \(T\), 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)\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): T \rightarrow P\) given by the universal property of the fiber product.
‣ 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.
‣ 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.
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' )\).
‣ 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\).
‣ 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\).
‣ PushoutProjectionFromCoproduct( D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \bigsqcup {i=1}^n I_i, \mathrm{Pushout}(D) )\)
This is a convenience method. The argument is a list of morphisms \(D = ( \beta_i: B \rightarrow I_i )_{i = 1 \dots n}\). The output is the natural projection \(\bigsqcup_{i=1}^n I_i \rightarrow \mathrm{Pushout}(D)\).
‣ PushoutProjectionFromDirectSum( D ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \bigoplus_{i=1}^n I_i, \mathrm{Pushout}(D) )\)
This is a convenience method. 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)\).
‣ 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)\).
‣ 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)\).
‣ 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 )\).
‣ 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\).
‣ 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 )\).
‣ 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\).
‣ UniversalMorphismFromPushout( D, T, tau ) | ( 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 test object \(T\), 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\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): \mathrm{Pushout}(D) \rightarrow T\) given by the universal property of the pushout.
‣ UniversalMorphismFromPushoutWithGivenPushout( D, T, 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 test object \(T\), 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)\). For convenience, the test object T can be omitted and is automatically derived from tau in that case. The output is the morphism \(u( \tau ): I \rightarrow T\) given by the universal property of the pushout.
‣ 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.
‣ 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.
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.
‣ 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 ) )\).
‣ 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)\).
‣ ImageObject( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \(\alpha\). The output is the image \(\mathrm{im}( \alpha )\).
‣ 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\).
‣ 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\).
‣ 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 )\).
‣ 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\).
‣ 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.
‣ 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.
‣ ImageObjectFunctorial( alpha, nu, alpha_prime ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( \mathrm{ImageObject}( \alpha ), \mathrm{ImageObject}( \alpha' ) )\)
The arguments are three morphisms \(\alpha: A \rightarrow B\), \(\nu: B \rightarrow B'\), \(\alpha': A' \rightarrow B'\). The output is the morphism \(\mathrm{ImageObject}( \alpha ) \rightarrow \mathrm{ImageObject}( \alpha' )\) given by the functoriality of the image.
‣ ImageObjectFunctorialWithGivenImageObjects( s, alpha, nu, alpha_prime, r ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}( s, r )\)
The arguments are an object \(s = \mathrm{ImageObject}( \alpha )\), three morphisms \(\alpha: A \rightarrow B\), \(\nu: B \rightarrow B'\), \(\alpha': A' \rightarrow B'\), and an object \(r = \mathrm{ImageObject}( \alpha' )\). The output is the morphism \(\mathrm{ImageObject}( \alpha ) \rightarrow \mathrm{ImageObject}( \alpha' )\) given by the functoriality of the image.
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.
‣ 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)\).
‣ MorphismFromCoimageToImageWithGivenObjects( C, alpha, I ) | ( 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\).
‣ InverseOfMorphismFromCoimageToImage( 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)\).
‣ InverseOfMorphismFromCoimageToImageWithGivenObjects( I, alpha, C ) | ( 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\).
‣ 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 ) )\).
‣ 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 )\).
‣ CoimageObject( alpha ) | ( attribute ) |
Returns: an object
The argument is a morphism \(\alpha\). The output is the coimage \(\mathrm{coim}( \alpha )\).
‣ 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 )\).
‣ CoimageProjectionWithGivenCoimageObject( 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\).
‣ 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\).
‣ AstrictionToCoimageWithGivenCoimageObject( 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\).
‣ 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.
‣ UniversalMorphismIntoCoimageWithGivenCoimageObject( 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.
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).
‣ CoimageObjectFunctorial( alpha, mu, alpha_prime ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(\mathrm{CoimageObject}( \alpha ), \mathrm{CoimageObject}( \alpha' ))\)
The arguments are three morphisms \(\alpha: A \rightarrow B, \mu: A \rightarrow A', \alpha': A' \rightarrow B'\). The output is the morphism \(\mathrm{CoimageObject}( \alpha ) \rightarrow \mathrm{CoimageObject}( \alpha' )\) given by the functoriality of the coimage.
‣ CoimageObjectFunctorialWithGivenCoimageObjects( s, alpha, mu, alpha_prime, r ) | ( operation ) |
Returns: a morphism in \(\mathrm{Hom}(s, r)\)
The arguments are an object \(s = \mathrm{CoimageObject}( \alpha )\), three morphisms \(\alpha: A \rightarrow B, \mu: A \rightarrow A', \alpha': A' \rightarrow B'\), and an object \(r = \mathrm{CoimageObject}( \alpha' )\). The output is the morphism \(\mathrm{CoimageObject}( \alpha ) \rightarrow \mathrm{CoimageObject}( \alpha' )\) given by the functoriality of the coimage.
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.
‣ 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.
‣ 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\).
‣ 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\).
‣ 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\).
‣ 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\).
‣ ProjectiveCoverObject( A ) | ( attribute ) |
Returns: an object
The argument is an object \(A\). The output is a projective cover of \(A\).
‣ EpimorphismFromProjectiveCoverObject( A ) | ( attribute ) |
Returns: an epimorphism
The argument is an object \(A\). The output is an epimorphism from a projective cover of \(A\).
‣ EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( A, P ) | ( operation ) |
Returns: an epimorphism
The argument is an object \(A\). The output is the epimorphism from the projective cover \(P\) of \(A\).
‣ InjectiveEnvelopeObject( A ) | ( attribute ) |
Returns: an object
The argument is an object \(A\). The output is an injective envelope of \(A\).
‣ MonomorphismIntoInjectiveEnvelopeObject( A ) | ( attribute ) |
Returns: a monomorphism
The argument is an object \(A\). The output is a monomorphism into an injective envelope of \(A\).
‣ MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( A, I ) | ( operation ) |
Returns: a monomorphism
The argument is an object \(A\). The output is a monomorphism into an injective envelope \(I\) of \(A\).
generated by GAPDoc2HTML