Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Ind

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

#### 7.1 Functions Installed by Add

Add functions have the following syntax:

DeclareOperation( "AddSomeFunc",
[ IsCapCategory, IsList, IsInt ] );


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

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 EnableAddForCategoricalOperations (1.12-1).

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.

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

DeclareOperation( "CapInternalInstallAdd",
[ IsRecord ] );


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.

    [
"object",
"object_or_fail",
"morphism",
"morphism_or_fail",
"twocell",
"object_in_range_category_of_homomorphism_structure",
"morphism_in_range_category_of_homomorphism_structure",
"bool",
"other_object",
"other_morphism",
"list_of_objects",
"list_of_morphisms",
"list_of_morphisms_or_fail",
"object_datum",
"morphism_datum",
"nonneg_integer_or_infinity",
]

• 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.

 ‣ CapInternalInstallAdd( record ) ( function )

See 7.3.

#### 7.4 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.

#### 7.5 Prepare functions

##### 7.5-1 CAPOperationPrepareFunction
 ‣ CAPOperationPrepareFunction( prepare_function, category, func ) ( function )

Returns: 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.

 ‣ CAPAddPrepareFunction( prepare_function, name, doc_string[, precondition_list] ) ( function )

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.

##### 7.5-3 ListCAPPrepareFunctions
 ‣ ListCAPPrepareFunctions( arg ) ( function )

Lists all prepare functions.

 ‣ AddAdditionForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddAdditiveGenerators( C, F ) ( operation )

Returns: nothing

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

 ‣ AddAdditiveInverseForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddAstrictionToCoimage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddBasisOfExternalHom( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BasisOfExternalHom. F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3).

 ‣ AddCanonicalIdentificationFromCoimageToImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCanonicalIdentificationFromImageObjectToCoimage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoastrictionToImage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoastrictionToImageWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoefficientsOfMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Coequalizer. F: ( arg2, arg3 ) \mapsto \mathtt{Coequalizer}(arg2, arg3).

 ‣ AddCoequalizerFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorial. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp).

 ‣ AddCoequalizerFunctorialWithGivenCoequalizers( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorialWithGivenCoequalizers. F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp).

 ‣ AddCoimageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoimageObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoimageProjection( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoimageProjectionWithGivenCoimageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelColift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelColiftWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelObjectFunctorialWithGivenCokernelObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObjectFunctorialWithGivenCokernelObjects. F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp).

 ‣ AddCokernelProjection( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCokernelProjectionWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddColift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddColiftAlongEpimorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddColiftOrFail( C, F ) ( operation )

Returns: nothing

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

 ‣ AddComponentOfMorphismFromDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddComponentOfMorphismIntoDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoproduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddCoproductFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp).

 ‣ AddCoproductFunctorialWithGivenCoproducts( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorialWithGivenCoproducts. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp).

 ‣ AddDirectProduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddDirectProductFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp).

 ‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorialWithGivenDirectProducts. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp).

 ‣ AddDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddDirectSumCodiagonalDifference( C, F ) ( operation )

Returns: nothing

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

 ‣ AddDirectSumDiagonalDifference( C, F ) ( operation )

Returns: nothing

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

 ‣ AddDirectSumFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp).

 ‣ AddDirectSumFunctorialWithGivenDirectSums( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorialWithGivenDirectSums. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp).

 ‣ AddDirectSumProjectionInPushout( C, F ) ( operation )

Returns: nothing

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

 ‣ AddDistinguishedObjectOfHomomorphismStructure( C, F ) ( operation )

Returns: nothing

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

 ‣ AddEmbeddingOfEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizer. F: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms).

 ‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizerWithGivenEqualizer. F: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P).

 ‣ AddEpimorphismFromProjectiveCoverObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject. F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P).

 ‣ AddEpimorphismFromSomeProjectiveObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject. F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P).

 ‣ AddEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Equalizer. F: ( arg2, arg3 ) \mapsto \mathtt{Equalizer}(arg2, arg3).

 ‣ AddEqualizerFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorial. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp).

 ‣ AddEqualizerFunctorialWithGivenEqualizers( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorialWithGivenEqualizers. F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp).

 ‣ AddFiberProduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddFiberProductEmbeddingInDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddFiberProductFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorial. F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp).

 ‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorialWithGivenFiberProducts. F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp).

 ‣ AddHomologyObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomologyObjectFunctorialWithGivenHomologyObjects. F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2).

 ‣ AddHomomorphismStructureOnMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddHomomorphismStructureOnObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnObjects. F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3).

 ‣ AddHorizontalPostCompose( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPostCompose. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3).

 ‣ AddHorizontalPreCompose( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPreCompose. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3).

 ‣ AddIdentityMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIdentityTwoCell( C, F ) ( operation )

Returns: nothing

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

 ‣ AddImageEmbedding( C, F ) ( operation )

Returns: nothing

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

 ‣ AddImageEmbeddingWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddImageObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddImageObjectFunctorialWithGivenImageObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObjectFunctorialWithGivenImageObjects. F: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip).

 ‣ AddIndecomposableInjectiveObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIndecomposableProjectiveObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInitialObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInitialObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObjectFunctorialWithGivenInitialObjects. F: ( P, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp).

 ‣ AddInjectionOfCofactorOfCoproduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproduct. F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k).

 ‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproductWithGivenCoproduct. F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P).

 ‣ AddInjectionOfCofactorOfDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSum. F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k).

 ‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSumWithGivenDirectSum. F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P).

 ‣ AddInjectionOfCofactorOfPushout( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushout. F: ( morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k).

 ‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushoutWithGivenPushout. F: ( morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P).

 ‣ AddInjectiveColift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInjectiveDimension( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInjectiveEnvelopeObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInverseForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddInverseMorphismFromCoimageToImageWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsAutomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsBijectiveObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsCodominating( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsColiftable( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsColiftableAlongEpimorphism( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsColiftableAlongEpimorphism. F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3).

 ‣ AddIsCongruentForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsDominating( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEndomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEpimorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualAsFactorobjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualAsSubobjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualForCacheForMorphisms( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForMorphisms. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3).

 ‣ AddIsEqualForCacheForObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForObjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3).

 ‣ AddIsEqualForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualForMorphismsOnMor( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualForObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForObjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForObjects}(arg2, arg3).

 ‣ AddIsEqualToIdentityMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsEqualToZeroMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsHomSetInhabited( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsHomSetInhabited. F: ( arg2, arg3 ) \mapsto \mathtt{IsHomSetInhabited}(arg2, arg3).

 ‣ AddIsIdempotent( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsInitial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsInjective( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsIsomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsLiftable( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsLiftableAlongMonomorphism( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsLiftableAlongMonomorphism. F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3).

 ‣ AddIsMonomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsOne( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsProjective( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsSplitEpimorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsSplitMonomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsTerminal( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsWellDefinedForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsWellDefinedForObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsWellDefinedForTwoCells( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsZeroForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsZeroForObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromCoproductToDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromDirectProductToDirectSum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromDirectSumToCoproduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromDirectSumToDirectProduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromFiberProductToKernelOfDiagonalDifference( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromInitialObjectToZeroObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromPushoutToCokernelOfDiagonalDifference( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromZeroObjectToInitialObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelEmbedding( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelEmbeddingWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelLift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelLiftWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObjectFunctorialWithGivenKernelObjects. F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp).

 ‣ AddLift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddLiftAlongMonomorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddLiftOrFail( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MereExistenceOfSolutionOfLinearSystemInAbCategory. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4).

 ‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I).

 ‣ AddMonomorphismIntoSomeInjectiveObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I).

 ‣ AddMorphismBetweenDirectSums( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSums. F: ( source_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram).

 ‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSumsWithGivenDirectSums. F: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T).

 ‣ AddMorphismConstructor( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismConstructor. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4).

 ‣ AddMorphismDatum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromEqualizerToSink( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSink. F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms).

 ‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSinkWithGivenEqualizer. F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P).

 ‣ AddMorphismFromFiberProductToSink( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromFiberProductToSinkWithGivenFiberProduct. F: ( morphisms, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P).

 ‣ AddMorphismFromKernelObjectToSink( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromSourceToCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizer. F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms).

 ‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P).

 ‣ AddMorphismFromSourceToCokernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromSourceToPushout( C, F ) ( operation )

Returns: nothing

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

 ‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToPushoutWithGivenPushout. F: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P).

 ‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddObjectConstructor( C, F ) ( operation )

Returns: nothing

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

 ‣ AddObjectDatum( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPostCompose( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPostComposeList( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPostInverseForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPreCompose( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPreComposeList( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPreInverseForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddProjectionInFactorOfDirectProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProduct. F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k).

 ‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProductWithGivenDirectProduct. F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k, P).

 ‣ AddProjectionInFactorOfDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSum. F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k).

 ‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSumWithGivenDirectSum. F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P).

 ‣ AddProjectionInFactorOfFiberProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProduct. F: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k).

 ‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProductWithGivenFiberProduct. F: ( morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k, P).

 ‣ AddProjectionOntoCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizer. F: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms).

 ‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P).

 ‣ AddProjectiveCoverObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddProjectiveDimension( C, F ) ( operation )

Returns: nothing

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

 ‣ AddProjectiveLift( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPushout( C, F ) ( operation )

Returns: nothing

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

 ‣ AddPushoutFunctorial( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorial. F: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial}(morphisms, L, morphismsp).

 ‣ AddPushoutFunctorialWithGivenPushouts( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorialWithGivenPushouts. F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P, morphisms, L, morphismsp, Pp).

 ‣ AddRandomMorphismByInteger( C, F ) ( operation )

Returns: nothing

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

 ‣ AddRandomMorphismByList( C, F ) ( operation )

Returns: nothing

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

 ‣ AddRandomMorphismWithFixedRangeByInteger( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByInteger. F: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n).

 ‣ AddRandomMorphismWithFixedRangeByList( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByList. F: ( B, L ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L).

 ‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F ) ( operation )

Returns: nothing

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

 ‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F ) ( operation )

Returns: nothing

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

 ‣ AddRandomMorphismWithFixedSourceByInteger( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByInteger. F: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n).

 ‣ AddRandomMorphismWithFixedSourceByList( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByList. F: ( A, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L).

 ‣ AddRandomObjectByInteger( C, F ) ( operation )

Returns: nothing

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

 ‣ AddRandomObjectByList( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSimplifyEndo( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo}(mor, n).

 ‣ AddSimplifyEndo_IsoFromInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n).

 ‣ AddSimplifyEndo_IsoToInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n).

 ‣ AddSimplifyMorphism( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyMorphism. F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n).

 ‣ AddSimplifyObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n).

 ‣ AddSimplifyObject_IsoFromInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoFromInputObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n).

 ‣ AddSimplifyObject_IsoToInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoToInputObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n).

 ‣ AddSimplifyRange( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange. F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n).

 ‣ AddSimplifyRange_IsoFromInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n).

 ‣ AddSimplifyRange_IsoToInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n).

 ‣ AddSimplifySource( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource. F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n).

 ‣ AddSimplifySourceAndRange( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange}(mor, n).

 ‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor, n).

 ‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputSource. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n).

 ‣ AddSimplifySourceAndRange_IsoToInputRange( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor, n).

 ‣ AddSimplifySourceAndRange_IsoToInputSource( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputSource. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n).

 ‣ AddSimplifySource_IsoFromInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n).

 ‣ AddSimplifySource_IsoToInputObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n).

 ‣ AddSolveLinearSystemInAbCategory( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SolveLinearSystemInAbCategory. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4).

 ‣ AddSolveLinearSystemInAbCategoryOrFail( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SolveLinearSystemInAbCategoryOrFail. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategoryOrFail}(arg2, arg3, arg4).

 ‣ AddSomeInjectiveObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSomeProjectiveObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSomeReductionBySplitEpiSummand( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSubtractionForMorphisms( C, F ) ( operation )

Returns: nothing

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

 ‣ AddSumOfMorphisms( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SumOfMorphisms. F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range).

 ‣ AddTerminalObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddTerminalObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObjectFunctorialWithGivenTerminalObjects. F: ( P, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp).

 ‣ AddUniversalMorphismFromCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizer. F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau).

 ‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y, morphisms, T, tau, P).

 ‣ AddUniversalMorphismFromCoproduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproduct. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau).

 ‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproductWithGivenCoproduct. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P).

 ‣ AddUniversalMorphismFromDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSum. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau).

 ‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSumWithGivenDirectSum. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P).

 ‣ AddUniversalMorphismFromImage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismFromInitialObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromInitialObjectWithGivenInitialObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P).

 ‣ AddUniversalMorphismFromPushout( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushout. F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau).

 ‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushoutWithGivenPushout. F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P).

 ‣ AddUniversalMorphismFromZeroObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromZeroObjectWithGivenZeroObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P).

 ‣ AddUniversalMorphismIntoCoimage( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismIntoDirectProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProduct. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau).

 ‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProductWithGivenDirectProduct. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P).

 ‣ AddUniversalMorphismIntoDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSum. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau).

 ‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSumWithGivenDirectSum. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P).

 ‣ AddUniversalMorphismIntoEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizer. F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau).

 ‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizerWithGivenEqualizer. F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P).

 ‣ AddUniversalMorphismIntoFiberProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProduct. F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau).

 ‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProductWithGivenFiberProduct. F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P).

 ‣ AddUniversalMorphismIntoTerminalObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoTerminalObjectWithGivenTerminalObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P).

 ‣ AddUniversalMorphismIntoZeroObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoZeroObjectWithGivenZeroObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P).

 ‣ AddVerticalPostCompose( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPostCompose. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPostCompose}(arg2, arg3).

 ‣ AddVerticalPreCompose( C, F ) ( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPreCompose. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPreCompose}(arg2, arg3).

 ‣ AddZeroMorphism( C, F ) ( operation )

Returns: nothing

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

 ‣ AddZeroObject( C, F ) ( operation )

Returns: nothing

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

 ‣ AddZeroObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

 ‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F ) ( operation )
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).