Add Functions

This section describes the overall structure of Add-functions and the functions installed by them.

Functions Installed by Add

Add functions have the following syntax:

<#Include Label="AddSomeFunc">

The first argument is the category to which some function (e.g. `KernelObject`) is added, the second is a list containing pairs of functions and additional filters for the arguments, (e.g. if one argument is a morphism, an additional filter could be `IsMomomorphism`). The third is an optional weight which will then be the weight for `SomeFunc` (default value: 100). This is described later. If only one function is to be installed, the list can be replaced by the function. CAP installs the given function(s) as methods for `SomeFunc` (resp. `SomeFuncOp` if `SomeFunc` is not an operation).

All installed methods follow the following steps, described below: Redirect function Prefunction Function Logic Postfunction Addfunction

Every other part, except from function, does only depend on the name `SomeFunc`. We now explain the steps in detail.

Redirect function: The redirect is used to redirect the computation from the given functions to some other symbol. If there is for example a with given method for some universal property, and the universal object is already computed, the redirect function might detect such a thing, calls the with given operation with the universal object as additional argument and then returns the value. In general, the redirect can be an arbitrary function. It is called with the same arguments as the operation `SomeFunc` itself and can return an array containing `[ true, something ]`, which will cause the installed method to simply return the object `something`, or `[ false ]`. If the output is `false`, the computation will continue with the step Prefunction.

Prefunction: The prefunction should be used for error handling and plausibility checks of the input to `SomeFunc` (e.g. for `KernelLift` it should check wether range and source of the morphims coincide). Generally, the prefunction is defined in the method record and only depends on the name `SomeFunc`. It is called with the same input as the function itself, and should return either `[ true ]`, which continues the computation, or `[ false, "message" ]`, which will cause an error with message `"message"` and some additional information.

Full prefunction: The full prefuction has the same semantics as the prefunction, but can perform additional, very costly checks. They are disabled by default.

Function: This will launch the function(s) given as arguments. The result should be as specified in the type of `SomeFunc`. The resulting object is now named the result.

Logic: For every function, some logical todos can be implemented in a logic texfile for the category. If there is some logic written down in a file belonging to the category, or belonging to some type of category. Please see the description of logic for more details. If there is some logic and some predicate relations for the function `SomeFunc`, it is installed in this step for the result.

Postfunction: The postfunction called with the arguments of the function and the result. It can be an arbitrary function doing some cosmetics. If for example `SomeFunc` is `KernelEmbedding`, it will set the `KernelObject` of the input morphism to result. The postfunction is also taken from the method record and does only depend on the name `SomeFunc`.

Addfunction: If the result is a category cell, it is added to the category for which the function was installed. This is disabled by default and can be enabled via .

Add Method

Except from installing a new method for the name `SomeFunc`, an Add method does slightly more. Every Add method has the same structure. The steps in the Add method are as follows:

Default weight: If the weight parameter is -1, the default weight is assumed, which is 100.

Weight check: If the current weight of the operation is lower than the given weight of the new functions, then the add function returns and installs nothing.

Installation: Next, the method to install the functions is created. It creates the correct filter list, by merging the standard filters for the operation with the particular filters for the given functions, then installs the method as described above.

After calling an add method, the corresponding operation is available in the category. Also, some derivations, which are triggered by the setting of the primitive value, might be available.

InstallAdd Function

Almost all Add methods in the CAP kernel are installed by the `CapInternalInstallAdd` operation. The definition of this function is as follows:

<#Include Label="CapInternalInstallAdd">

The record can have the following components, most of which can be set in the method name record, used as described:

function_name: The name of the function. This does not have to coincide with the installation name. It is used for the derivation weight.

installation_name (optional): A string which is the name of the operation for which the functions given to the Add method are installed as methods.

pre_function (optional): A function which is used as the prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the pre function of the referenced operation is used.

pre_function_full (optional): A function which is used as the full prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the full pre function of the referenced operation is used.

redirect_function (optional): A function which is used as the redirect function of the installed methods, as described above. Can also be the name of another operation. In this case the redirect function of the referenced operation is used.

post_function (optional): A function which is used as the postfunction of the installed methods, as described above.

filter_list: A list containing the basic filters for the methods installed by the add methods. Possible entries are filters, or the strings listed below, which will be replaced by appropriate filters at the time the add method is called. The first entry of `filter_list` must be the string `category`. If the category can be inferred from the remaining arguments, a convenience method without the category as the first argument is installed automatically. Additionally, the category is not passed to primitively added functions, except if `category!.category_as_first_argument` is set to `true` (this will probably change to be the default in the future). category, object, morphism, twocell, object_in_range_category_of_homomorphism_structure, morphism_in_range_category_of_homomorphism_structure, other_category, other_object, other_morphism, other_twocell, list_of_objects, list_of_morphisms, list_of_twocells.

well_defined_todo (optional): A boolean, default value is true, which states wether there should be to do list entries which propagate well definedness from the input of the installed methods to their output. Please note that true only makes sense if at least one argument and the output of the installed method is a cell.

return_type: The return type can either be a filter or one of the strings in the list below. For objects, morphisms and 2-cells the correct Add function (see above) is used for the result of the computation. Otherwise, no Add function is used after all. <#Include Label="CAP_INTERNAL_VALID_RETURN_TYPES">

is_with_given (optional): Boolean, marks whether the function which is to be installed is a with given function or not.

with_given_without_given_name_pair (optional): If the currently installed operation has a corresponding with given operation or is the with given of another operation, the names of both should be in this list.

functorial (optional): If an object has a corresponding functorial function, e.g., `KernelObject` and `KernelObjectFunctorial`, the name of the functorial is stored as a string.

dual_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation all arguments have to be given in reversed order.

dual_with_given_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation the source and range of a with given operation have to be given in reversed order.

dual_preprocessor_func (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the arguments given to g are preprocessed by this given function.

dual_postprocessor_func (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the computed value of f is postprocessed by the given function.

input_arguments_names (optional): A duplicate free list (of the same length as `filter_list`) of strings. For example, these strings will be used as the names of the arguments when automatically generating functions for this operation, e.g. in the opposite category.

output_source_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the source of the returned morphism. The input arguments are available via the names given in `input_arguments_names`.

can_always_compute_output_source_getter (optional): Only valid if `output_source_getter_string` is also set: Whether the code in `output_source_getter_string` is independent of CAP operations and can thus always be computed without having to check the installed operations of a category.

output_range_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the range of the returned morphism. The input arguments are available via the names given in `input_arguments_names`.

can_always_compute_output_range_getter (optional): Only valid if `output_range_getter_string` is also set: Whether the code in `output_range_getter_string` is independent of CAP operations and can thus always be computed without having to check the installed operations of a category.

with_given_object_position (optional): One of the following strings: `"Source"`, `"Range"`, or `"both"`. Set for the without given operation in a with given pair. Describes whether the source resp. range are given (as the last argument of the with given operation) or both (as the second and the last argument of the with given operation).

compatible_with_congruence_of_morphisms (optional): Indicates if the operation is compatible with the congruence of morphisms, that is, if the output does not change with regard to `IsEqualForObjects` and `IsCongruentForMorphisms` if the input changes with regard to `IsEqualForObjects` and `IsCongruentForMorphisms`.

Using all those entries, the operation `CapInternalInstallAdd` installs add methods as described above. It first provides plausibility checks for all the entries described, then installs the Add method in 4 ways, with list or functions as second argument, and with an optional third parameter for the weight.

See .
Enhancing the method name record

The function CAP_INTERNAL_ENHANCE_NAME_RECORD can be applied to a method name record to make the following enhancements:

Function name: Set the component function_name to the entry name.

WithGiven special case: If the current entry belongs to a WithGiven operation or its without given pair, the with_given_without_given_name_pair is set. Additionally, the with given flag of the WithGiven operation is set to true.

Redirect and post functions are created for all operations belonging to universal constructions (e.g. `KernelLift`) which are not a WithGiven operation.

Prepare functions

a function Given a non-CAP-conform function for any of the categorical operations, i.e., a function that computes the direct sum of two objects instead of a list of objects, this function wraps the function with a wrapper function to fit in the CAP context. For the mentioned binary direct sum one can call this function with "BinaryDirectSumToDirectSum" as prepare_function, the category, and the binary direct sum function. The function then returns a function that can be used for the direct sum categorical operation.

Note that func is not handled by the CAP caching mechanism and that the use of prepare functions is incompatible with WithGiven operations. Thus, one has to ensure manually that the equality and typing specifications are fulfilled. Adds a prepare function to the list of CAP's prepare functions. The first argument is the prepare function itself. It should always be a function that takes a category and a function and returns a function. The argument name is the name of the prepare function, which is used in CAPOperationPrepareFunction. The argument doc_string should be a short string describing the functions. The optional argument precondition_list can describe preconditions for the prepare function to work, i.e., if the category does need to have PreCompose computable. This information is also recovered automatically from the prepare function itself, so the precondition_list is only necessary if the function needed is not explicitly used in the prepare function, e.g., if you use + instead of AdditionForMorphisms. Lists all prepare functions.
Available Add functions nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `AdditionForMorphisms`. F: ( a, b ) \mapsto \mathtt{AdditionForMorphisms}(a, b). 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 `AdditiveGenerators`. F: ( ) \mapsto \mathtt{AdditiveGenerators}(). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `AdditiveInverseForMorphisms`. F: ( a ) \mapsto \mathtt{AdditiveInverseForMorphisms}(a). 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 \mathtt{AstrictionToCoimage}(alpha). 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 `AstrictionToCoimageWithGivenCoimageObject`. F: ( alpha, C ) \mapsto \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `BasisOfExternalHom`. F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3). 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 \mathtt{CanonicalIdentificationFromCoimageToImageObject}(alpha). 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 \mathtt{CanonicalIdentificationFromImageObjectToCoimage}(alpha). 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 \mathtt{CoastrictionToImage}(alpha). 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 \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I). 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 `CoefficientsOfMorphism`. F: ( arg2 ) \mapsto \mathtt{CoefficientsOfMorphism}(arg2). 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: ( arg2, arg3 ) \mapsto \mathtt{Coequalizer}(arg2, arg3). 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 `CoequalizerFunctorial`. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp). 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: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp). 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 `CoimageObject`. F: ( arg2 ) \mapsto \mathtt{CoimageObject}(arg2). 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 `CoimageObjectFunctorial`. F: ( alpha, mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap). 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 `CoimageObjectFunctorialWithGivenCoimageObjects`. F: ( C, alpha, mu, alphap, Cp ) \mapsto \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C, alpha, mu, alphap, Cp). 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 \mathtt{CoimageProjection}(alpha). 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 `CoimageProjectionWithGivenCoimageObject`. F: ( alpha, C ) \mapsto \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C). 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 `CokernelColift`. F: ( alpha, T, tau ) \mapsto \mathtt{CokernelColift}(alpha, T, tau). 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 `CokernelColiftWithGivenCokernelObject`. F: ( alpha, T, tau, P ) \mapsto \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P). 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: ( arg2 ) \mapsto \mathtt{CokernelObject}(arg2). 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 `CokernelObjectFunctorial`. F: ( alpha, mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap). 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: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp). 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 \mathtt{CokernelProjection}(alpha). 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 `CokernelProjectionWithGivenCokernelObject`. F: ( alpha, P ) \mapsto \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `Colift`. F: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `ColiftAlongEpimorphism`. F: ( epsilon, tau ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau). 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 `ColiftOrFail`. F: ( alpha, beta ) \mapsto \mathtt{ColiftOrFail}(alpha, beta). 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, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i). 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, S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i). 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: ( arg2 ) \mapsto \mathtt{Coproduct}(arg2). 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 `CoproductFunctorial`. F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp). 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: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp). 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: ( arg2 ) \mapsto \mathtt{DirectProduct}(arg2). 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 `DirectProductFunctorial`. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp). 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: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp). 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: ( arg2 ) \mapsto \mathtt{DirectSum}(arg2). 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 \mathtt{DirectSumCodiagonalDifference}(D). 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 \mathtt{DirectSumDiagonalDifference}(D). 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 `DirectSumFunctorial`. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp). 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: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp). 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: ( D ) \mapsto \mathtt{DirectSumProjectionInPushout}(D). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `DistinguishedObjectOfHomomorphismStructure`. F: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}(). 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: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms). 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: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P). 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 `EpimorphismFromProjectiveCoverObject`. F: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A). 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 `EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject`. F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P). 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 `EpimorphismFromSomeProjectiveObject`. F: ( A ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A). 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 `EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject`. F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P). 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: ( arg2, arg3 ) \mapsto \mathtt{Equalizer}(arg2, arg3). 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 `EqualizerFunctorial`. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp). 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: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp). 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: ( arg2 ) \mapsto \mathtt{FiberProduct}(arg2). 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: ( D ) \mapsto \mathtt{FiberProductEmbeddingInDirectSum}(D). 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 `FiberProductFunctorial`. F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp). 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: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp). 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 \mathtt{HomologyObject}(alpha, beta). 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 `HomologyObjectFunctorialWithGivenHomologyObjects`. F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2). 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 `HomomorphismStructureOnMorphisms`. F: ( alpha, beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `HomomorphismStructureOnMorphismsWithGivenObjects`. F: ( source, alpha, beta, range ) \mapsto \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source, alpha, beta, range). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `HomomorphismStructureOnObjects`. F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3). 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 `HorizontalPostCompose`. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3). 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 `HorizontalPreCompose`. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IdentityMorphism`. F: ( a ) \mapsto \mathtt{IdentityMorphism}(a). 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 `IdentityTwoCell`. F: ( arg2 ) \mapsto \mathtt{IdentityTwoCell}(arg2). 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 \mathtt{ImageEmbedding}(alpha). 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 \mathtt{ImageEmbeddingWithGivenImageObject}(alpha, I). 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: ( arg2 ) \mapsto \mathtt{ImageObject}(arg2). 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 `ImageObjectFunctorial`. F: ( alpha, nu, alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap). 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 `ImageObjectFunctorialWithGivenImageObjects`. F: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip). 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 `IndecomposableInjectiveObjects`. F: ( ) \mapsto \mathtt{IndecomposableInjectiveObjects}(). 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 `IndecomposableProjectiveObjects`. F: ( ) \mapsto \mathtt{IndecomposableProjectiveObjects}(). 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 \mathtt{InitialObject}(). 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: ( ) \mapsto \mathtt{InitialObjectFunctorial}(). 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 `InitialObjectFunctorialWithGivenInitialObjects`. F: ( P, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp). 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: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k). 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: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P). 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: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k). 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: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P). 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: ( morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k). 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: ( morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P). 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 `InjectiveColift`. F: ( alpha, beta ) \mapsto \mathtt{InjectiveColift}(alpha, beta). 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 `InjectiveDimension`. F: ( arg2 ) \mapsto \mathtt{InjectiveDimension}(arg2). 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 `InjectiveEnvelopeObject`. F: ( arg2 ) \mapsto \mathtt{InjectiveEnvelopeObject}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure`. F: ( alpha ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha). 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 `InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects`. F: ( source, alpha, range ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source, alpha, range). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism`. F: ( source, range, alpha ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source, range, alpha). 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 `InverseForMorphisms`. F: ( alpha ) \mapsto \mathtt{InverseForMorphisms}(alpha). 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 `InverseMorphismFromCoimageToImageWithGivenObjects`. F: ( C, alpha, I ) \mapsto \mathtt{InverseMorphismFromCoimageToImageWithGivenObjects}(C, alpha, I). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsAutomorphism`. F: ( arg2 ) \mapsto \mathtt{IsAutomorphism}(arg2). 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 `IsBijectiveObject`. F: ( arg2 ) \mapsto \mathtt{IsBijectiveObject}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsCodominating`. F: ( arg2, arg3 ) \mapsto \mathtt{IsCodominating}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsColiftable`. F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftable}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsColiftableAlongEpimorphism`. F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsCongruentForMorphisms`. F: ( arg2, arg3 ) \mapsto \mathtt{IsCongruentForMorphisms}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsDominating`. F: ( arg2, arg3 ) \mapsto \mathtt{IsDominating}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEndomorphism`. F: ( arg2 ) \mapsto \mathtt{IsEndomorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEpimorphism`. F: ( arg2 ) \mapsto \mathtt{IsEpimorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualAsFactorobjects`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsFactorobjects}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualAsSubobjects`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsSubobjects}(arg2, arg3). 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 `IsEqualForCacheForMorphisms`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3). 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 `IsEqualForCacheForObjects`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualForMorphisms`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphisms}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsEqualForMorphismsOnMor`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphismsOnMor}(arg2, arg3). 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 `IsEqualForObjects`. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForObjects}(arg2, arg3). 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 `IsEqualToIdentityMorphism`. F: ( arg2 ) \mapsto \mathtt{IsEqualToIdentityMorphism}(arg2). 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 `IsEqualToZeroMorphism`. F: ( arg2 ) \mapsto \mathtt{IsEqualToZeroMorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsHomSetInhabited`. F: ( arg2, arg3 ) \mapsto \mathtt{IsHomSetInhabited}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIdempotent`. F: ( arg2 ) \mapsto \mathtt{IsIdempotent}(arg2). 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 `IsInitial`. F: ( arg2 ) \mapsto \mathtt{IsInitial}(arg2). 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 `IsInjective`. F: ( arg2 ) \mapsto \mathtt{IsInjective}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsIsomorphism`. F: ( arg2 ) \mapsto \mathtt{IsIsomorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsLiftable`. F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftable}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsLiftableAlongMonomorphism`. F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsMonomorphism`. F: ( arg2 ) \mapsto \mathtt{IsMonomorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsOne`. F: ( arg2 ) \mapsto \mathtt{IsOne}(arg2). 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 `IsProjective`. F: ( arg2 ) \mapsto \mathtt{IsProjective}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsSplitEpimorphism`. F: ( arg2 ) \mapsto \mathtt{IsSplitEpimorphism}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsSplitMonomorphism`. F: ( arg2 ) \mapsto \mathtt{IsSplitMonomorphism}(arg2). 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 `IsTerminal`. F: ( arg2 ) \mapsto \mathtt{IsTerminal}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsWellDefinedForMorphisms`. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForMorphisms}(arg2). 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 `IsWellDefinedForObjects`. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForObjects}(arg2). 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 `IsWellDefinedForTwoCells`. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForTwoCells}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `IsZeroForMorphisms`. F: ( arg2 ) \mapsto \mathtt{IsZeroForMorphisms}(arg2). 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 `IsZeroForObjects`. F: ( arg2 ) \mapsto \mathtt{IsZeroForObjects}(arg2). 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: ( D ) \mapsto \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D). 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 \mathtt{IsomorphismFromCoimageToCokernelOfKernel}(alpha). 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: ( D ) \mapsto \mathtt{IsomorphismFromCokernelOfDiagonalDifferenceToPushout}(D). 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 \mathtt{IsomorphismFromCokernelOfKernelToCoimage}(alpha). 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 \mathtt{IsomorphismFromCoproductToDirectSum}(D). 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 \mathtt{IsomorphismFromDirectProductToDirectSum}(D). 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 \mathtt{IsomorphismFromDirectSumToCoproduct}(D). 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 \mathtt{IsomorphismFromDirectSumToDirectProduct}(D). 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: ( D ) \mapsto \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D). 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: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D). 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: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToKernelOfDiagonalDifference}(D). 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 `IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject`. F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha, beta). 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 \mathtt{IsomorphismFromImageObjectToKernelOfCokernel}(alpha). 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 \mathtt{IsomorphismFromInitialObjectToZeroObject}(). 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 `IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject`. F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha, beta). 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 \mathtt{IsomorphismFromKernelOfCokernelToImageObject}(alpha). 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: ( D ) \mapsto \mathtt{IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct}(D). 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: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D). 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: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCokernelOfDiagonalDifference}(D). 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 \mathtt{IsomorphismFromTerminalObjectToZeroObject}(). 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 \mathtt{IsomorphismFromZeroObjectToInitialObject}(). 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 \mathtt{IsomorphismFromZeroObjectToTerminalObject}(). 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 \mathtt{KernelEmbedding}(alpha). 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, P ) \mapsto \mathtt{KernelEmbeddingWithGivenKernelObject}(alpha, P). 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, T, tau ) \mapsto \mathtt{KernelLift}(alpha, T, tau). 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, T, tau, P ) \mapsto \mathtt{KernelLiftWithGivenKernelObject}(alpha, T, tau, P). 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: ( arg2 ) \mapsto \mathtt{KernelObject}(arg2). 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 `KernelObjectFunctorial`. F: ( alpha, mu, alphap ) \mapsto \mathtt{KernelObjectFunctorial}(alpha, mu, alphap). 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: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `Lift`. F: ( alpha, beta ) \mapsto \mathtt{Lift}(alpha, beta). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `LiftAlongMonomorphism`. F: ( iota, tau ) \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau). 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 `LiftOrFail`. F: ( alpha, beta ) \mapsto \mathtt{LiftOrFail}(alpha, beta). 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 `MereExistenceOfSolutionOfLinearSystemInAbCategory`. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4). 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 `MonomorphismIntoInjectiveEnvelopeObject`. F: ( A ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObject}(A). 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 `MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject`. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I). 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 `MonomorphismIntoSomeInjectiveObject`. F: ( A ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObject}(A). 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 `MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject`. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I). 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: ( source_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram). 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 `MorphismBetweenDirectSumsWithGivenDirectSums`. F: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T). 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 `MorphismConstructor`. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4). 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 `MorphismDatum`. F: ( arg2 ) \mapsto \mathtt{MorphismDatum}(arg2). 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 \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I). 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: ( Y, morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms). 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: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P). 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: ( morphisms ) \mapsto \mathtt{MorphismFromFiberProductToSink}(morphisms). 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: ( morphisms, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P). 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 \mathtt{MorphismFromKernelObjectToSink}(alpha). 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, P ) \mapsto \mathtt{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P). 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: ( Y, morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms). 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: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P). 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 \mathtt{MorphismFromSourceToCokernelObject}(alpha). 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, P ) \mapsto \mathtt{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha, P). 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: ( morphisms ) \mapsto \mathtt{MorphismFromSourceToPushout}(morphisms). 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: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `MultiplyWithElementOfCommutativeRingForMorphisms`. F: ( r, a ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, a). 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 `ObjectConstructor`. F: ( arg2 ) \mapsto \mathtt{ObjectConstructor}(arg2). 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 `ObjectDatum`. F: ( arg2 ) \mapsto \mathtt{ObjectDatum}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `PostCompose`. F: ( beta, alpha ) \mapsto \mathtt{PostCompose}(beta, alpha). 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 `PostComposeList`. F: ( list_of_morphisms ) \mapsto \mathtt{PostComposeList}(list_of_morphisms). 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 `PostInverseForMorphisms`. F: ( alpha ) \mapsto \mathtt{PostInverseForMorphisms}(alpha). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `PreCompose`. F: ( alpha, beta ) \mapsto \mathtt{PreCompose}(alpha, beta). 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 `PreComposeList`. F: ( list_of_morphisms ) \mapsto \mathtt{PreComposeList}(list_of_morphisms). 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 `PreInverseForMorphisms`. F: ( alpha ) \mapsto \mathtt{PreInverseForMorphisms}(alpha). 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: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k). 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: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k, P). 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: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k). 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: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P). 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: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k). 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: ( morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k, P). 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: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms). 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: ( Y, morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P). 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 `ProjectiveCoverObject`. F: ( arg2 ) \mapsto \mathtt{ProjectiveCoverObject}(arg2). 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 `ProjectiveDimension`. F: ( arg2 ) \mapsto \mathtt{ProjectiveDimension}(arg2). 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 `ProjectiveLift`. F: ( alpha, beta ) \mapsto \mathtt{ProjectiveLift}(alpha, beta). 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: ( arg2 ) \mapsto \mathtt{Pushout}(arg2). 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: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial}(morphisms, L, morphismsp). 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 `PushoutFunctorialWithGivenPushouts`. F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P, morphisms, L, morphismsp, Pp). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismByInteger`. F: ( n ) \mapsto \mathtt{RandomMorphismByInteger}(n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismByList`. F: ( L ) \mapsto \mathtt{RandomMorphismByList}(L). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedRangeByInteger`. F: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedRangeByList`. F: ( B, L ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceAndRangeByInteger`. F: ( A, B, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByInteger}(A, B, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceAndRangeByList`. F: ( A, B, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByList}(A, B, L). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceByInteger`. F: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `RandomMorphismWithFixedSourceByList`. F: ( A, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L). 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 `RandomObjectByInteger`. F: ( n ) \mapsto \mathtt{RandomObjectByInteger}(n). 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 `RandomObjectByList`. F: ( L ) \mapsto \mathtt{RandomObjectByList}(L). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo`. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo_IsoFromInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyEndo_IsoToInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyMorphism`. F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n). 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 `SimplifyObject`. F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n). 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 `SimplifyObject_IsoFromInputObject`. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n). 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 `SimplifyObject_IsoToInputObject`. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange`. F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange_IsoFromInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifyRange_IsoToInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource`. F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange`. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoFromInputRange`. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoFromInputSource`. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoToInputRange`. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySourceAndRange_IsoToInputSource`. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource_IsoFromInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SimplifySource_IsoToInputObject`. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n). 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 `SolveLinearSystemInAbCategory`. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4). 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 `SolveLinearSystemInAbCategoryOrFail`. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategoryOrFail}(arg2, arg3, arg4). 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 `SomeInjectiveObject`. F: ( arg2 ) \mapsto \mathtt{SomeInjectiveObject}(arg2). 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 `SomeProjectiveObject`. F: ( arg2 ) \mapsto \mathtt{SomeProjectiveObject}(arg2). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand`. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand}(alpha). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand_MorphismFromInputRange`. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismFromInputRange}(alpha). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SomeReductionBySplitEpiSummand_MorphismToInputRange`. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `SubtractionForMorphisms`. F: ( a, b ) \mapsto \mathtt{SubtractionForMorphisms}(a, b). 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 `SumOfMorphisms`. F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range). 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 \mathtt{TerminalObject}(). 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 \mathtt{TerminalObjectFunctorial}(). 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 `TerminalObjectFunctorialWithGivenTerminalObjects`. F: ( P, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp). 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: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau). 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: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y, morphisms, T, tau, P). 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: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau). 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: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P). 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: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau). 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: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P). 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 \mathtt{UniversalMorphismFromImage}(alpha, tau). 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 \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I). 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: ( T ) \mapsto \mathtt{UniversalMorphismFromInitialObject}(T). 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: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P). 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: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau). 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 `UniversalMorphismFromPushoutWithGivenPushout`. F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P). 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: ( T ) \mapsto \mathtt{UniversalMorphismFromZeroObject}(T). 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: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P). 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 \mathtt{UniversalMorphismIntoCoimage}(alpha, tau). 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 `UniversalMorphismIntoCoimageWithGivenCoimageObject`. F: ( alpha, tau, C ) \mapsto \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C). 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: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau). 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: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P). 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: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau). 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: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P). 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: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau). 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: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P). 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: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau). 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: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P). 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: ( T ) \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T). 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: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P). 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: ( T ) \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T). 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: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P). 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 `VerticalPostCompose`. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPostCompose}(arg2, arg3). 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 `VerticalPreCompose`. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPreCompose}(arg2, arg3). nothing The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation `ZeroMorphism`. F: ( a, b ) \mapsto \mathtt{ZeroMorphism}(a, b). 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 \mathtt{ZeroObject}(). 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 \mathtt{ZeroObjectFunctorial}(). 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 `ZeroObjectFunctorialWithGivenZeroObjects`. F: ( P, Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P, Pp).