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

### 7 Add Functions

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

• Addfunction

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

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

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

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

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

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

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

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

#### 7.2 Add Method

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

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

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

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

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

#### 7.3 InstallAdd Function

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:

    [
"filter_list",
"input_arguments_names",
"return_type",
"output_source_getter_string",
"output_source_getter_preconditions",
"output_range_getter_string",
"output_range_getter_preconditions",
"with_given_object_position",
"dual_operation",
"dual_arguments_reversed",
"dual_with_given_objects_reversed",
"dual_preprocessor_func",
"dual_preprocessor_func_string",
"dual_postprocessor_func",
"dual_postprocessor_func_string",
"functorial",
"compatible_with_congruence_of_morphisms",
"redirect_function",
"pre_function",
"pre_function_full",
"post_function",
]

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

• category,

• object,

• morphism,

• twocell,

• object_in_range_category_of_homomorphism_structure,

• morphism_in_range_category_of_homomorphism_structure,

• list_of_objects,

• list_of_morphisms,

• list_of_twocells.

• 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",
"list_of_objects",
"list_of_morphisms",
"list_of_morphisms_or_fail",
"list_of_lists_of_morphisms",
"object_datum",
"morphism_datum",
"nonneg_integer_or_infinity",
"list_of_elements_of_commutative_ring_of_linear_structure",
]

• 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_operation (optional): Name of the dual operation.

• 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_objects_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[_string] (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. The function can also be given as a string.

• dual_postprocessor_func[_string] (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. The function can also be given as a string.

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

• output_source_getter_preconditions (optional): Only valid if output_source_getter_string is set: The preconditions of output_source_getter_string in the same form as preconditions of derivations but with the CAP operations given as strings.

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

• output_range_getter_preconditions (optional): Only valid if output_range_getter_string is set: The preconditions of output_range_getter_string in the same form as preconditions of derivations but with the CAP operations given as strings.

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

##### 7.3-1 CapInternalInstallAdd
 ‣ 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.

##### 7.5-2 CAPAddPrepareFunction
 ‣ 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.

#### 7.6 Available Add functions

##### 7.6-1 AddAdditionForMorphisms
 ‣ 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: ( alpha, beta ) \mapsto \mathtt{AdditionForMorphisms}(alpha, beta).

##### 7.6-2 AddAdditiveGenerators
 ‣ 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}().

##### 7.6-3 AddAdditiveInverseForMorphisms
 ‣ 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: ( alpha ) \mapsto \mathtt{AdditiveInverseForMorphisms}(alpha).

##### 7.6-4 AddAstrictionToCoimage
 ‣ AddAstrictionToCoimage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-5 AddAstrictionToCoimageWithGivenCoimageObject
 ‣ 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).

##### 7.6-6 AddBasisOfExternalHom
 ‣ 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).

##### 7.6-7 AddCoastrictionToImage
 ‣ AddCoastrictionToImage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-8 AddCoastrictionToImageWithGivenImageObject
 ‣ AddCoastrictionToImageWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-9 AddCoefficientsOfMorphism
 ‣ 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).

##### 7.6-10 AddCoequalizer
 ‣ AddCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-11 AddCoequalizerFunctorial
 ‣ 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).

##### 7.6-12 AddCoequalizerFunctorialWithGivenCoequalizers
 ‣ AddCoequalizerFunctorialWithGivenCoequalizers( C, F ) ( operation )

Returns: nothing

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

##### 7.6-13 AddCoimageObject
 ‣ 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).

##### 7.6-14 AddCoimageObjectFunctorial
 ‣ 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).

##### 7.6-15 AddCoimageObjectFunctorialWithGivenCoimageObjects
 ‣ 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).

##### 7.6-16 AddCoimageProjection
 ‣ AddCoimageProjection( C, F ) ( operation )

Returns: nothing

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

##### 7.6-17 AddCoimageProjectionWithGivenCoimageObject
 ‣ 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).

##### 7.6-18 AddCokernelColift
 ‣ AddCokernelColift( C, F ) ( operation )

Returns: nothing

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

##### 7.6-19 AddCokernelColiftWithGivenCokernelObject
 ‣ AddCokernelColiftWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-20 AddCokernelObject
 ‣ AddCokernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-21 AddCokernelObjectFunctorial
 ‣ 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).

##### 7.6-22 AddCokernelObjectFunctorialWithGivenCokernelObjects
 ‣ AddCokernelObjectFunctorialWithGivenCokernelObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-23 AddCokernelProjection
 ‣ AddCokernelProjection( C, F ) ( operation )

Returns: nothing

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

##### 7.6-24 AddCokernelProjectionWithGivenCokernelObject
 ‣ AddCokernelProjectionWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-25 AddColift
 ‣ 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).

##### 7.6-26 AddColiftAlongEpimorphism
 ‣ 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).

##### 7.6-27 AddColiftOrFail
 ‣ 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).

##### 7.6-28 AddComponentOfMorphismFromCoproduct
 ‣ AddComponentOfMorphismFromCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-29 AddComponentOfMorphismFromDirectSum
 ‣ AddComponentOfMorphismFromDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-30 AddComponentOfMorphismIntoDirectProduct
 ‣ AddComponentOfMorphismIntoDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-31 AddComponentOfMorphismIntoDirectSum
 ‣ AddComponentOfMorphismIntoDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-32 AddCoproduct
 ‣ AddCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-33 AddCoproductFunctorial
 ‣ 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).

##### 7.6-34 AddCoproductFunctorialWithGivenCoproducts
 ‣ AddCoproductFunctorialWithGivenCoproducts( C, F ) ( operation )

Returns: nothing

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

##### 7.6-35 AddDirectProduct
 ‣ AddDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-36 AddDirectProductFunctorial
 ‣ 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).

##### 7.6-37 AddDirectProductFunctorialWithGivenDirectProducts
 ‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F ) ( operation )

Returns: nothing

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

##### 7.6-38 AddDirectSum
 ‣ AddDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-39 AddDirectSumFunctorial
 ‣ 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).

##### 7.6-40 AddDirectSumFunctorialWithGivenDirectSums
 ‣ AddDirectSumFunctorialWithGivenDirectSums( C, F ) ( operation )

Returns: nothing

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

##### 7.6-41 AddDistinguishedObjectOfHomomorphismStructure
 ‣ 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}().

##### 7.6-42 AddEmbeddingOfEqualizer
 ‣ AddEmbeddingOfEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-43 AddEmbeddingOfEqualizerWithGivenEqualizer
 ‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-44 AddEpimorphismFromProjectiveCoverObject
 ‣ 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).

##### 7.6-45 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject
 ‣ 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).

##### 7.6-46 AddEpimorphismFromSomeProjectiveObject
 ‣ 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).

##### 7.6-47 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
 ‣ 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).

##### 7.6-48 AddEqualizer
 ‣ AddEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-49 AddEqualizerFunctorial
 ‣ 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).

##### 7.6-50 AddEqualizerFunctorialWithGivenEqualizers
 ‣ AddEqualizerFunctorialWithGivenEqualizers( C, F ) ( operation )

Returns: nothing

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

##### 7.6-51 AddFiberProduct
 ‣ AddFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-52 AddFiberProductFunctorial
 ‣ 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).

##### 7.6-53 AddFiberProductFunctorialWithGivenFiberProducts
 ‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F ) ( operation )

Returns: nothing

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

##### 7.6-54 AddHomologyObject
 ‣ AddHomologyObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-55 AddHomologyObjectFunctorialWithGivenHomologyObjects
 ‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-56 AddHomomorphismStructureOnMorphisms
 ‣ 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).

##### 7.6-57 AddHomomorphismStructureOnMorphismsWithGivenObjects
 ‣ 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).

##### 7.6-58 AddHomomorphismStructureOnObjects
 ‣ 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).

##### 7.6-59 AddHorizontalPostCompose
 ‣ 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).

##### 7.6-60 AddHorizontalPreCompose
 ‣ 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).

##### 7.6-61 AddIdentityMorphism
 ‣ 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).

##### 7.6-62 AddIdentityTwoCell
 ‣ 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).

##### 7.6-63 AddImageEmbedding
 ‣ AddImageEmbedding( C, F ) ( operation )

Returns: nothing

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

##### 7.6-64 AddImageEmbeddingWithGivenImageObject
 ‣ AddImageEmbeddingWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-65 AddImageObject
 ‣ AddImageObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-66 AddImageObjectFunctorial
 ‣ 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).

##### 7.6-67 AddImageObjectFunctorialWithGivenImageObjects
 ‣ 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).

##### 7.6-68 AddIndecomposableInjectiveObjects
 ‣ 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}().

##### 7.6-69 AddIndecomposableProjectiveObjects
 ‣ 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}().

##### 7.6-70 AddInitialObject
 ‣ AddInitialObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-71 AddInitialObjectFunctorial
 ‣ AddInitialObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

##### 7.6-72 AddInitialObjectFunctorialWithGivenInitialObjects
 ‣ 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).

##### 7.6-73 AddInjectionOfCofactorOfCoproduct
 ‣ AddInjectionOfCofactorOfCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-74 AddInjectionOfCofactorOfCoproductWithGivenCoproduct
 ‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-75 AddInjectionOfCofactorOfDirectSum
 ‣ AddInjectionOfCofactorOfDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-76 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum
 ‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-77 AddInjectionOfCofactorOfPushout
 ‣ AddInjectionOfCofactorOfPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-78 AddInjectionOfCofactorOfPushoutWithGivenPushout
 ‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-79 AddInjectiveColift
 ‣ 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).

##### 7.6-80 AddInjectiveDimension
 ‣ 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).

##### 7.6-81 AddInjectiveEnvelopeObject
 ‣ 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).

##### 7.6-82 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure
 ‣ 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).

##### 7.6-83 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects
 ‣ 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).

##### 7.6-84 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
 ‣ 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).

##### 7.6-85 AddInverseForMorphisms
 ‣ 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).

##### 7.6-86 AddInverseOfMorphismFromCoimageToImage
 ‣ AddInverseOfMorphismFromCoimageToImage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-87 AddInverseOfMorphismFromCoimageToImageWithGivenObjects
 ‣ AddInverseOfMorphismFromCoimageToImageWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-88 AddIsAutomorphism
 ‣ 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).

##### 7.6-89 AddIsBijectiveObject
 ‣ 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).

##### 7.6-90 AddIsCodominating
 ‣ 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).

##### 7.6-91 AddIsColiftable
 ‣ 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).

##### 7.6-92 AddIsColiftableAlongEpimorphism
 ‣ 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).

##### 7.6-93 AddIsCongruentForMorphisms
 ‣ 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).

##### 7.6-94 AddIsDominating
 ‣ 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).

##### 7.6-95 AddIsEndomorphism
 ‣ 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).

##### 7.6-96 AddIsEpimorphism
 ‣ 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).

##### 7.6-97 AddIsEqualAsFactorobjects
 ‣ 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).

##### 7.6-98 AddIsEqualAsSubobjects
 ‣ 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).

##### 7.6-99 AddIsEqualForCacheForMorphisms
 ‣ 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).

##### 7.6-100 AddIsEqualForCacheForObjects
 ‣ 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).

##### 7.6-101 AddIsEqualForMorphisms
 ‣ 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).

##### 7.6-102 AddIsEqualForMorphismsOnMor
 ‣ 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).

##### 7.6-103 AddIsEqualForObjects
 ‣ 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).

##### 7.6-104 AddIsEqualToIdentityMorphism
 ‣ 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).

##### 7.6-105 AddIsEqualToZeroMorphism
 ‣ 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).

##### 7.6-106 AddIsHomSetInhabited
 ‣ 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).

##### 7.6-107 AddIsIdempotent
 ‣ 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).

##### 7.6-108 AddIsInitial
 ‣ 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).

##### 7.6-109 AddIsInjective
 ‣ 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).

##### 7.6-110 AddIsIsomorphicForObjects
 ‣ AddIsIsomorphicForObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-111 AddIsIsomorphism
 ‣ 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).

##### 7.6-112 AddIsLiftable
 ‣ 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).

##### 7.6-113 AddIsLiftableAlongMonomorphism
 ‣ 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).

##### 7.6-114 AddIsMonomorphism
 ‣ 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).

##### 7.6-115 AddIsOne
 ‣ 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).

##### 7.6-116 AddIsProjective
 ‣ 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).

##### 7.6-117 AddIsSplitEpimorphism
 ‣ 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).

##### 7.6-118 AddIsSplitMonomorphism
 ‣ 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).

##### 7.6-119 AddIsTerminal
 ‣ 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).

##### 7.6-120 AddIsWellDefinedForMorphisms
 ‣ 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: ( alpha ) \mapsto \mathtt{IsWellDefinedForMorphisms}(alpha).

##### 7.6-121 AddIsWellDefinedForMorphismsWithGivenSourceAndRange
 ‣ AddIsWellDefinedForMorphismsWithGivenSourceAndRange( C, F ) ( operation )

Returns: nothing

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

##### 7.6-122 AddIsWellDefinedForObjects
 ‣ 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).

##### 7.6-123 AddIsWellDefinedForTwoCells
 ‣ 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).

##### 7.6-124 AddIsZeroForMorphisms
 ‣ 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).

##### 7.6-125 AddIsZeroForObjects
 ‣ 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).

##### 7.6-126 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout
 ‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-127 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct
 ‣ AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-128 AddIsomorphismFromCoimageToCokernelOfKernel
 ‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F ) ( operation )

Returns: nothing

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

##### 7.6-129 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer
 ‣ AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-130 AddIsomorphismFromCokernelOfKernelToCoimage
 ‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-131 AddIsomorphismFromCoproductToDirectSum
 ‣ AddIsomorphismFromCoproductToDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-132 AddIsomorphismFromDirectProductToDirectSum
 ‣ AddIsomorphismFromDirectProductToDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-133 AddIsomorphismFromDirectSumToCoproduct
 ‣ AddIsomorphismFromDirectSumToCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-134 AddIsomorphismFromDirectSumToDirectProduct
 ‣ AddIsomorphismFromDirectSumToDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-135 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct
 ‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-136 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct
 ‣ AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-137 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram
 ‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F ) ( operation )

Returns: nothing

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

##### 7.6-138 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject
 ‣ 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).

##### 7.6-139 AddIsomorphismFromImageObjectToKernelOfCokernel
 ‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F ) ( operation )

Returns: nothing

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

##### 7.6-140 AddIsomorphismFromInitialObjectToZeroObject
 ‣ AddIsomorphismFromInitialObjectToZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-141 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject
 ‣ 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).

##### 7.6-142 AddIsomorphismFromKernelOfCokernelToImageObject
 ‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-143 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer
 ‣ AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-144 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram
 ‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F ) ( operation )

Returns: nothing

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

##### 7.6-145 AddIsomorphismFromTerminalObjectToZeroObject
 ‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-146 AddIsomorphismFromZeroObjectToInitialObject
 ‣ AddIsomorphismFromZeroObjectToInitialObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-147 AddIsomorphismFromZeroObjectToTerminalObject
 ‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-148 AddJointPairwiseDifferencesOfMorphismsFromCoproduct
 ‣ AddJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-149 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct
 ‣ AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-150 AddKernelEmbedding
 ‣ AddKernelEmbedding( C, F ) ( operation )

Returns: nothing

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

##### 7.6-151 AddKernelEmbeddingWithGivenKernelObject
 ‣ AddKernelEmbeddingWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-152 AddKernelLift
 ‣ AddKernelLift( C, F ) ( operation )

Returns: nothing

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

##### 7.6-153 AddKernelLiftWithGivenKernelObject
 ‣ AddKernelLiftWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-154 AddKernelObject
 ‣ AddKernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-155 AddKernelObjectFunctorial
 ‣ 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).

##### 7.6-156 AddKernelObjectFunctorialWithGivenKernelObjects
 ‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-157 AddLift
 ‣ 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).

##### 7.6-158 AddLiftAlongMonomorphism
 ‣ 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).

##### 7.6-159 AddLiftOrFail
 ‣ 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).

##### 7.6-160 AddLinearCombinationOfMorphisms
 ‣ AddLinearCombinationOfMorphisms( C, F ) ( operation )

Returns: nothing

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

##### 7.6-161 AddMereExistenceOfSolutionOfLinearSystemInAbCategory
 ‣ 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).

##### 7.6-162 AddMonomorphismIntoInjectiveEnvelopeObject
 ‣ 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).

##### 7.6-163 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject
 ‣ 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).

##### 7.6-164 AddMonomorphismIntoSomeInjectiveObject
 ‣ 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).

##### 7.6-165 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject
 ‣ 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).

##### 7.6-166 AddMorphismBetweenDirectSums
 ‣ AddMorphismBetweenDirectSums( C, F ) ( operation )

Returns: nothing

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

##### 7.6-167 AddMorphismBetweenDirectSumsWithGivenDirectSums
 ‣ 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).

##### 7.6-168 AddMorphismConstructor
 ‣ 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).

##### 7.6-169 AddMorphismDatum
 ‣ 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).

##### 7.6-170 AddMorphismFromCoimageToImage
 ‣ AddMorphismFromCoimageToImage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-171 AddMorphismFromCoimageToImageWithGivenObjects
 ‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-172 AddMorphismFromEqualizerToSink
 ‣ AddMorphismFromEqualizerToSink( C, F ) ( operation )

Returns: nothing

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

##### 7.6-173 AddMorphismFromEqualizerToSinkWithGivenEqualizer
 ‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-174 AddMorphismFromFiberProductToSink
 ‣ AddMorphismFromFiberProductToSink( C, F ) ( operation )

Returns: nothing

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

##### 7.6-175 AddMorphismFromFiberProductToSinkWithGivenFiberProduct
 ‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-176 AddMorphismFromKernelObjectToSink
 ‣ AddMorphismFromKernelObjectToSink( C, F ) ( operation )

Returns: nothing

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

##### 7.6-177 AddMorphismFromKernelObjectToSinkWithGivenKernelObject
 ‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-178 AddMorphismFromSourceToCoequalizer
 ‣ AddMorphismFromSourceToCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-179 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer
 ‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-180 AddMorphismFromSourceToCokernelObject
 ‣ AddMorphismFromSourceToCokernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-181 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject
 ‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-182 AddMorphismFromSourceToPushout
 ‣ AddMorphismFromSourceToPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-183 AddMorphismFromSourceToPushoutWithGivenPushout
 ‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-184 AddMorphismsOfExternalHom
 ‣ AddMorphismsOfExternalHom( C, F ) ( operation )

Returns: nothing

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

##### 7.6-185 AddMultiplyWithElementOfCommutativeRingForMorphisms
 ‣ 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, alpha ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, alpha).

##### 7.6-186 AddObjectConstructor
 ‣ 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).

##### 7.6-187 AddObjectDatum
 ‣ 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).

##### 7.6-188 AddPostCompose
 ‣ 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).

##### 7.6-189 AddPostComposeList
 ‣ 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: ( source, list_of_morphisms, range ) \mapsto \mathtt{PostComposeList}(source, list_of_morphisms, range).

##### 7.6-190 AddPostInverseForMorphisms
 ‣ 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).

##### 7.6-191 AddPreCompose
 ‣ 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).

##### 7.6-192 AddPreComposeList
 ‣ 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: ( source, list_of_morphisms, range ) \mapsto \mathtt{PreComposeList}(source, list_of_morphisms, range).

##### 7.6-193 AddPreInverseForMorphisms
 ‣ 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).

##### 7.6-194 AddProjectionInFactorOfDirectProduct
 ‣ AddProjectionInFactorOfDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-195 AddProjectionInFactorOfDirectProductWithGivenDirectProduct
 ‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-196 AddProjectionInFactorOfDirectSum
 ‣ AddProjectionInFactorOfDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-197 AddProjectionInFactorOfDirectSumWithGivenDirectSum
 ‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-198 AddProjectionInFactorOfFiberProduct
 ‣ AddProjectionInFactorOfFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-199 AddProjectionInFactorOfFiberProductWithGivenFiberProduct
 ‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-200 AddProjectionOntoCoequalizer
 ‣ AddProjectionOntoCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-201 AddProjectionOntoCoequalizerWithGivenCoequalizer
 ‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-202 AddProjectiveCoverObject
 ‣ 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).

##### 7.6-203 AddProjectiveDimension
 ‣ 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).

##### 7.6-204 AddProjectiveLift
 ‣ 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).

##### 7.6-205 AddPushout
 ‣ AddPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-206 AddPushoutFunctorial
 ‣ 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).

##### 7.6-207 AddPushoutFunctorialWithGivenPushouts
 ‣ AddPushoutFunctorialWithGivenPushouts( C, F ) ( operation )

Returns: nothing

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

##### 7.6-208 AddRandomMorphismByInteger
 ‣ 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).

##### 7.6-209 AddRandomMorphismByList
 ‣ 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).

##### 7.6-210 AddRandomMorphismWithFixedRangeByInteger
 ‣ 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).

##### 7.6-211 AddRandomMorphismWithFixedRangeByList
 ‣ 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).

##### 7.6-212 AddRandomMorphismWithFixedSourceAndRangeByInteger
 ‣ 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).

##### 7.6-213 AddRandomMorphismWithFixedSourceAndRangeByList
 ‣ 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).

##### 7.6-214 AddRandomMorphismWithFixedSourceByInteger
 ‣ 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).

##### 7.6-215 AddRandomMorphismWithFixedSourceByList
 ‣ 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).

##### 7.6-216 AddRandomObjectByInteger
 ‣ 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).

##### 7.6-217 AddRandomObjectByList
 ‣ 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).

##### 7.6-218 AddSimplifyEndo
 ‣ 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).

##### 7.6-219 AddSimplifyEndo_IsoFromInputObject
 ‣ 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).

##### 7.6-220 AddSimplifyEndo_IsoToInputObject
 ‣ 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).

##### 7.6-221 AddSimplifyMorphism
 ‣ 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).

##### 7.6-222 AddSimplifyObject
 ‣ 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).

##### 7.6-223 AddSimplifyObject_IsoFromInputObject
 ‣ 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).

##### 7.6-224 AddSimplifyObject_IsoToInputObject
 ‣ 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).

##### 7.6-225 AddSimplifyRange
 ‣ 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).

##### 7.6-226 AddSimplifyRange_IsoFromInputObject
 ‣ 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).

##### 7.6-227 AddSimplifyRange_IsoToInputObject
 ‣ 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).

##### 7.6-228 AddSimplifySource
 ‣ 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).

##### 7.6-229 AddSimplifySourceAndRange
 ‣ 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).

##### 7.6-230 AddSimplifySourceAndRange_IsoFromInputRange
 ‣ 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).

##### 7.6-231 AddSimplifySourceAndRange_IsoFromInputSource
 ‣ 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).

##### 7.6-232 AddSimplifySourceAndRange_IsoToInputRange
 ‣ 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).

##### 7.6-233 AddSimplifySourceAndRange_IsoToInputSource
 ‣ 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).

##### 7.6-234 AddSimplifySource_IsoFromInputObject
 ‣ 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).

##### 7.6-235 AddSimplifySource_IsoToInputObject
 ‣ 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).

##### 7.6-236 AddSolveLinearSystemInAbCategory
 ‣ 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).

##### 7.6-237 AddSolveLinearSystemInAbCategoryOrFail
 ‣ 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).

##### 7.6-238 AddSomeInjectiveObject
 ‣ 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).

##### 7.6-239 AddSomeIsomorphismBetweenObjects
 ‣ AddSomeIsomorphismBetweenObjects( C, F ) ( operation )

Returns: nothing

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

##### 7.6-240 AddSomeProjectiveObject
 ‣ 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).

##### 7.6-241 AddSomeReductionBySplitEpiSummand
 ‣ 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).

##### 7.6-242 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange
 ‣ 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).

##### 7.6-243 AddSomeReductionBySplitEpiSummand_MorphismToInputRange
 ‣ 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).

##### 7.6-244 AddSubtractionForMorphisms
 ‣ 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: ( alpha, beta ) \mapsto \mathtt{SubtractionForMorphisms}(alpha, beta).

##### 7.6-245 AddSumOfMorphisms
 ‣ 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).

##### 7.6-246 AddTerminalObject
 ‣ AddTerminalObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-247 AddTerminalObjectFunctorial
 ‣ AddTerminalObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

##### 7.6-248 AddTerminalObjectFunctorialWithGivenTerminalObjects
 ‣ 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).

##### 7.6-249 AddUniversalMorphismFromCoequalizer
 ‣ AddUniversalMorphismFromCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-250 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer
 ‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-251 AddUniversalMorphismFromCoproduct
 ‣ AddUniversalMorphismFromCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-252 AddUniversalMorphismFromCoproductWithGivenCoproduct
 ‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-253 AddUniversalMorphismFromDirectSum
 ‣ AddUniversalMorphismFromDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-254 AddUniversalMorphismFromDirectSumWithGivenDirectSum
 ‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-255 AddUniversalMorphismFromImage
 ‣ AddUniversalMorphismFromImage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-256 AddUniversalMorphismFromImageWithGivenImageObject
 ‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-257 AddUniversalMorphismFromInitialObject
 ‣ AddUniversalMorphismFromInitialObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-258 AddUniversalMorphismFromInitialObjectWithGivenInitialObject
 ‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-259 AddUniversalMorphismFromPushout
 ‣ AddUniversalMorphismFromPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-260 AddUniversalMorphismFromPushoutWithGivenPushout
 ‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F ) ( operation )

Returns: nothing

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

##### 7.6-261 AddUniversalMorphismFromZeroObject
 ‣ AddUniversalMorphismFromZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-262 AddUniversalMorphismFromZeroObjectWithGivenZeroObject
 ‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-263 AddUniversalMorphismIntoCoimage
 ‣ AddUniversalMorphismIntoCoimage( C, F ) ( operation )

Returns: nothing

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

##### 7.6-264 AddUniversalMorphismIntoCoimageWithGivenCoimageObject
 ‣ 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).

##### 7.6-265 AddUniversalMorphismIntoDirectProduct
 ‣ AddUniversalMorphismIntoDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-266 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct
 ‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-267 AddUniversalMorphismIntoDirectSum
 ‣ AddUniversalMorphismIntoDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-268 AddUniversalMorphismIntoDirectSumWithGivenDirectSum
 ‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F ) ( operation )

Returns: nothing

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

##### 7.6-269 AddUniversalMorphismIntoEqualizer
 ‣ AddUniversalMorphismIntoEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-270 AddUniversalMorphismIntoEqualizerWithGivenEqualizer
 ‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F ) ( operation )

Returns: nothing

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

##### 7.6-271 AddUniversalMorphismIntoFiberProduct
 ‣ AddUniversalMorphismIntoFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-272 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct
 ‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F ) ( operation )

Returns: nothing

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

##### 7.6-273 AddUniversalMorphismIntoTerminalObject
 ‣ AddUniversalMorphismIntoTerminalObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-274 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject
 ‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-275 AddUniversalMorphismIntoZeroObject
 ‣ AddUniversalMorphismIntoZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-276 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject
 ‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-277 AddVerticalPostCompose
 ‣ 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).

##### 7.6-278 AddVerticalPreCompose
 ‣ 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).

##### 7.6-279 AddZeroMorphism
 ‣ 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).

##### 7.6-280 AddZeroObject
 ‣ AddZeroObject( C, F ) ( operation )

Returns: nothing

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

##### 7.6-281 AddZeroObjectFunctorial
 ‣ AddZeroObjectFunctorial( C, F ) ( operation )

Returns: nothing

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

##### 7.6-282 AddZeroObjectFunctorialWithGivenZeroObjects
 ‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F ) ( operation )

Returns: nothing

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

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

generated by GAPDoc2HTML