GAP (CAP) - Chapter 7: Add Functions

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

7 Add Functions
7.1 Functions Installed by Add
7.2 Add Method
7.3 InstallAdd Function
7.3-1 CapInternalInstallAdd
7.4 Enhancing the method name record
7.5 Prepare functions
7.5-1 CAPOperationPrepareFunction
7.5-2 CAPAddPrepareFunction
7.5-3 ListCAPPrepareFunctions
7.6 Available Add functions
7.6-1 AddAdditionForMorphisms
7.6-2 AddAdditiveGenerators
7.6-3 AddAdditiveInverseForMorphisms
7.6-4 AddAstrictionToCoimage
7.6-5 AddAstrictionToCoimageWithGivenCoimageObject
7.6-6 AddBasisOfExternalHom
7.6-7 AddCanonicalIdentificationFromCoimageToImageObject
7.6-8 AddCanonicalIdentificationFromImageObjectToCoimage
7.6-9 AddCoastrictionToImage
7.6-10 AddCoastrictionToImageWithGivenImageObject
7.6-11 AddCoefficientsOfMorphism
7.6-12 AddCoequalizer
7.6-13 AddCoequalizerFunctorial
7.6-14 AddCoequalizerFunctorialWithGivenCoequalizers
7.6-15 AddCoimageObject
7.6-16 AddCoimageObjectFunctorial
7.6-17 AddCoimageObjectFunctorialWithGivenCoimageObjects
7.6-18 AddCoimageProjection
7.6-19 AddCoimageProjectionWithGivenCoimageObject
7.6-20 AddCokernelColift
7.6-21 AddCokernelColiftWithGivenCokernelObject
7.6-22 AddCokernelObject
7.6-23 AddCokernelObjectFunctorial
7.6-24 AddCokernelObjectFunctorialWithGivenCokernelObjects
7.6-25 AddCokernelProjection
7.6-26 AddCokernelProjectionWithGivenCokernelObject
7.6-27 AddColift
7.6-28 AddColiftAlongEpimorphism
7.6-29 AddColiftOrFail
7.6-30 AddComponentOfMorphismFromDirectSum
7.6-31 AddComponentOfMorphismIntoDirectSum
7.6-32 AddCoproduct
7.6-33 AddCoproductFunctorial
7.6-34 AddCoproductFunctorialWithGivenCoproducts
7.6-35 AddDirectProduct
7.6-36 AddDirectProductFunctorial
7.6-37 AddDirectProductFunctorialWithGivenDirectProducts
7.6-38 AddDirectSum
7.6-39 AddDirectSumCodiagonalDifference
7.6-40 AddDirectSumDiagonalDifference
7.6-41 AddDirectSumFunctorial
7.6-42 AddDirectSumFunctorialWithGivenDirectSums
7.6-43 AddDirectSumProjectionInPushout
7.6-44 AddDistinguishedObjectOfHomomorphismStructure
7.6-45 AddEmbeddingOfEqualizer
7.6-46 AddEmbeddingOfEqualizerWithGivenEqualizer
7.6-47 AddEpimorphismFromProjectiveCoverObject
7.6-48 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject
7.6-49 AddEpimorphismFromSomeProjectiveObject
7.6-50 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
7.6-51 AddEqualizer
7.6-52 AddEqualizerFunctorial
7.6-53 AddEqualizerFunctorialWithGivenEqualizers
7.6-54 AddFiberProduct
7.6-55 AddFiberProductEmbeddingInDirectSum
7.6-56 AddFiberProductFunctorial
7.6-57 AddFiberProductFunctorialWithGivenFiberProducts
7.6-58 AddHomologyObject
7.6-59 AddHomologyObjectFunctorialWithGivenHomologyObjects
7.6-60 AddHomomorphismStructureOnMorphisms
7.6-61 AddHomomorphismStructureOnMorphismsWithGivenObjects
7.6-62 AddHomomorphismStructureOnObjects
7.6-63 AddHorizontalPostCompose
7.6-64 AddHorizontalPreCompose
7.6-65 AddIdentityMorphism
7.6-66 AddIdentityTwoCell
7.6-67 AddImageEmbedding
7.6-68 AddImageEmbeddingWithGivenImageObject
7.6-69 AddImageObject
7.6-70 AddImageObjectFunctorial
7.6-71 AddImageObjectFunctorialWithGivenImageObjects
7.6-72 AddIndecomposableInjectiveObjects
7.6-73 AddIndecomposableProjectiveObjects
7.6-74 AddInitialObject
7.6-75 AddInitialObjectFunctorial
7.6-76 AddInitialObjectFunctorialWithGivenInitialObjects
7.6-77 AddInjectionOfCofactorOfCoproduct
7.6-78 AddInjectionOfCofactorOfCoproductWithGivenCoproduct
7.6-79 AddInjectionOfCofactorOfDirectSum
7.6-80 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum
7.6-81 AddInjectionOfCofactorOfPushout
7.6-82 AddInjectionOfCofactorOfPushoutWithGivenPushout
7.6-83 AddInjectiveColift
7.6-84 AddInjectiveDimension
7.6-85 AddInjectiveEnvelopeObject
7.6-86 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure
7.6-87 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects
7.6-88 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
7.6-89 AddInverseForMorphisms
7.6-90 AddInverseMorphismFromCoimageToImageWithGivenObjects
7.6-91 AddIsAutomorphism
7.6-92 AddIsBijectiveObject
7.6-93 AddIsCodominating
7.6-94 AddIsColiftable
7.6-95 AddIsColiftableAlongEpimorphism
7.6-96 AddIsCongruentForMorphisms
7.6-97 AddIsDominating
7.6-98 AddIsEndomorphism
7.6-99 AddIsEpimorphism
7.6-100 AddIsEqualAsFactorobjects
7.6-101 AddIsEqualAsSubobjects
7.6-102 AddIsEqualForCacheForMorphisms
7.6-103 AddIsEqualForCacheForObjects
7.6-104 AddIsEqualForMorphisms
7.6-105 AddIsEqualForMorphismsOnMor
7.6-106 AddIsEqualForObjects
7.6-107 AddIsEqualToIdentityMorphism
7.6-108 AddIsEqualToZeroMorphism
7.6-109 AddIsHomSetInhabited
7.6-110 AddIsIdempotent
7.6-111 AddIsInitial
7.6-112 AddIsInjective
7.6-113 AddIsIsomorphism
7.6-114 AddIsLiftable
7.6-115 AddIsLiftableAlongMonomorphism
7.6-116 AddIsMonomorphism
7.6-117 AddIsOne
7.6-118 AddIsProjective
7.6-119 AddIsSplitEpimorphism
7.6-120 AddIsSplitMonomorphism
7.6-121 AddIsTerminal
7.6-122 AddIsWellDefinedForMorphisms
7.6-123 AddIsWellDefinedForObjects
7.6-124 AddIsWellDefinedForTwoCells
7.6-125 AddIsZeroForMorphisms
7.6-126 AddIsZeroForObjects
7.6-127 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout
7.6-128 AddIsomorphismFromCoimageToCokernelOfKernel
7.6-129 AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout
7.6-130 AddIsomorphismFromCokernelOfKernelToCoimage
7.6-131 AddIsomorphismFromCoproductToDirectSum
7.6-132 AddIsomorphismFromDirectProductToDirectSum
7.6-133 AddIsomorphismFromDirectSumToCoproduct
7.6-134 AddIsomorphismFromDirectSumToDirectProduct
7.6-135 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct
7.6-136 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram
7.6-137 AddIsomorphismFromFiberProductToKernelOfDiagonalDifference
7.6-138 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject
7.6-139 AddIsomorphismFromImageObjectToKernelOfCokernel
7.6-140 AddIsomorphismFromInitialObjectToZeroObject
7.6-141 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject
7.6-142 AddIsomorphismFromKernelOfCokernelToImageObject
7.6-143 AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct
7.6-144 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram
7.6-145 AddIsomorphismFromPushoutToCokernelOfDiagonalDifference
7.6-146 AddIsomorphismFromTerminalObjectToZeroObject
7.6-147 AddIsomorphismFromZeroObjectToInitialObject
7.6-148 AddIsomorphismFromZeroObjectToTerminalObject
7.6-149 AddKernelEmbedding
7.6-150 AddKernelEmbeddingWithGivenKernelObject
7.6-151 AddKernelLift
7.6-152 AddKernelLiftWithGivenKernelObject
7.6-153 AddKernelObject
7.6-154 AddKernelObjectFunctorial
7.6-155 AddKernelObjectFunctorialWithGivenKernelObjects
7.6-156 AddLift
7.6-157 AddLiftAlongMonomorphism
7.6-158 AddLiftOrFail
7.6-159 AddMereExistenceOfSolutionOfLinearSystemInAbCategory
7.6-160 AddMonomorphismIntoInjectiveEnvelopeObject
7.6-161 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject
7.6-162 AddMonomorphismIntoSomeInjectiveObject
7.6-163 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject
7.6-164 AddMorphismBetweenDirectSums
7.6-165 AddMorphismBetweenDirectSumsWithGivenDirectSums
7.6-166 AddMorphismConstructor
7.6-167 AddMorphismDatum
7.6-168 AddMorphismFromCoimageToImageWithGivenObjects
7.6-169 AddMorphismFromEqualizerToSink
7.6-170 AddMorphismFromEqualizerToSinkWithGivenEqualizer
7.6-171 AddMorphismFromFiberProductToSink
7.6-172 AddMorphismFromFiberProductToSinkWithGivenFiberProduct
7.6-173 AddMorphismFromKernelObjectToSink
7.6-174 AddMorphismFromKernelObjectToSinkWithGivenKernelObject
7.6-175 AddMorphismFromSourceToCoequalizer
7.6-176 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer
7.6-177 AddMorphismFromSourceToCokernelObject
7.6-178 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject
7.6-179 AddMorphismFromSourceToPushout
7.6-180 AddMorphismFromSourceToPushoutWithGivenPushout
7.6-181 AddMultiplyWithElementOfCommutativeRingForMorphisms
7.6-182 AddObjectConstructor
7.6-183 AddObjectDatum
7.6-184 AddPostCompose
7.6-185 AddPostComposeList
7.6-186 AddPostInverseForMorphisms
7.6-187 AddPreCompose
7.6-188 AddPreComposeList
7.6-189 AddPreInverseForMorphisms
7.6-190 AddProjectionInFactorOfDirectProduct
7.6-191 AddProjectionInFactorOfDirectProductWithGivenDirectProduct
7.6-192 AddProjectionInFactorOfDirectSum
7.6-193 AddProjectionInFactorOfDirectSumWithGivenDirectSum
7.6-194 AddProjectionInFactorOfFiberProduct
7.6-195 AddProjectionInFactorOfFiberProductWithGivenFiberProduct
7.6-196 AddProjectionOntoCoequalizer
7.6-197 AddProjectionOntoCoequalizerWithGivenCoequalizer
7.6-198 AddProjectiveCoverObject
7.6-199 AddProjectiveDimension
7.6-200 AddProjectiveLift
7.6-201 AddPushout
7.6-202 AddPushoutFunctorial
7.6-203 AddPushoutFunctorialWithGivenPushouts
7.6-204 AddRandomMorphismByInteger
7.6-205 AddRandomMorphismByList
7.6-206 AddRandomMorphismWithFixedRangeByInteger
7.6-207 AddRandomMorphismWithFixedRangeByList
7.6-208 AddRandomMorphismWithFixedSourceAndRangeByInteger
7.6-209 AddRandomMorphismWithFixedSourceAndRangeByList
7.6-210 AddRandomMorphismWithFixedSourceByInteger
7.6-211 AddRandomMorphismWithFixedSourceByList
7.6-212 AddRandomObjectByInteger
7.6-213 AddRandomObjectByList
7.6-214 AddSimplifyEndo
7.6-215 AddSimplifyEndo_IsoFromInputObject
7.6-216 AddSimplifyEndo_IsoToInputObject
7.6-217 AddSimplifyMorphism
7.6-218 AddSimplifyObject
7.6-219 AddSimplifyObject_IsoFromInputObject
7.6-220 AddSimplifyObject_IsoToInputObject
7.6-221 AddSimplifyRange
7.6-222 AddSimplifyRange_IsoFromInputObject
7.6-223 AddSimplifyRange_IsoToInputObject
7.6-224 AddSimplifySource
7.6-225 AddSimplifySourceAndRange
7.6-226 AddSimplifySourceAndRange_IsoFromInputRange
7.6-227 AddSimplifySourceAndRange_IsoFromInputSource
7.6-228 AddSimplifySourceAndRange_IsoToInputRange
7.6-229 AddSimplifySourceAndRange_IsoToInputSource
7.6-230 AddSimplifySource_IsoFromInputObject
7.6-231 AddSimplifySource_IsoToInputObject
7.6-232 AddSolveLinearSystemInAbCategory
7.6-233 AddSolveLinearSystemInAbCategoryOrFail
7.6-234 AddSomeInjectiveObject
7.6-235 AddSomeProjectiveObject
7.6-236 AddSomeReductionBySplitEpiSummand
7.6-237 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange
7.6-238 AddSomeReductionBySplitEpiSummand_MorphismToInputRange
7.6-239 AddSubtractionForMorphisms
7.6-240 AddSumOfMorphisms
7.6-241 AddTerminalObject
7.6-242 AddTerminalObjectFunctorial
7.6-243 AddTerminalObjectFunctorialWithGivenTerminalObjects
7.6-244 AddUniversalMorphismFromCoequalizer
7.6-245 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer
7.6-246 AddUniversalMorphismFromCoproduct
7.6-247 AddUniversalMorphismFromCoproductWithGivenCoproduct
7.6-248 AddUniversalMorphismFromDirectSum
7.6-249 AddUniversalMorphismFromDirectSumWithGivenDirectSum
7.6-250 AddUniversalMorphismFromImage
7.6-251 AddUniversalMorphismFromImageWithGivenImageObject
7.6-252 AddUniversalMorphismFromInitialObject
7.6-253 AddUniversalMorphismFromInitialObjectWithGivenInitialObject
7.6-254 AddUniversalMorphismFromPushout
7.6-255 AddUniversalMorphismFromPushoutWithGivenPushout
7.6-256 AddUniversalMorphismFromZeroObject
7.6-257 AddUniversalMorphismFromZeroObjectWithGivenZeroObject
7.6-258 AddUniversalMorphismIntoCoimage
7.6-259 AddUniversalMorphismIntoCoimageWithGivenCoimageObject
7.6-260 AddUniversalMorphismIntoDirectProduct
7.6-261 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct
7.6-262 AddUniversalMorphismIntoDirectSum
7.6-263 AddUniversalMorphismIntoDirectSumWithGivenDirectSum
7.6-264 AddUniversalMorphismIntoEqualizer
7.6-265 AddUniversalMorphismIntoEqualizerWithGivenEqualizer
7.6-266 AddUniversalMorphismIntoFiberProduct
7.6-267 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct
7.6-268 AddUniversalMorphismIntoTerminalObject
7.6-269 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject
7.6-270 AddUniversalMorphismIntoZeroObject
7.6-271 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject
7.6-272 AddVerticalPostCompose
7.6-273 AddVerticalPreCompose
7.6-274 AddZeroMorphism
7.6-275 AddZeroObject
7.6-276 AddZeroObjectFunctorial
7.6-277 AddZeroObjectFunctorialWithGivenZeroObjects

### 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, most of which can be set in the method name record, used as described:

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

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

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

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

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

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

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

  - `category`,

  - `object`,

  - `morphism`,

  - `twocell`,

  - `object_in_range_category_of_homomorphism_structure`,

  - `morphism_in_range_category_of_homomorphism_structure`,

  - `other_category`,

  - `other_object`,

  - `other_morphism`,

  - `other_twocell`,

  - `list_of_objects`,

  - `list_of_morphisms`,

  - `list_of_twocells`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

##### 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: ( a, b ) \mapsto \mathtt{AdditionForMorphisms}(a, b)\).

##### 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: ( a ) \mapsto \mathtt{AdditiveInverseForMorphisms}(a)\).

##### 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 AddCanonicalIdentificationFromCoimageToImageObject

`‣ AddCanonicalIdentificationFromCoimageToImageObject`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-8 AddCanonicalIdentificationFromImageObjectToCoimage

`‣ AddCanonicalIdentificationFromImageObjectToCoimage`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-9 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-10 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-11 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-12 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: ( arg2, arg3 ) \mapsto \mathtt{Coequalizer}(arg2, arg3)\).

##### 7.6-13 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-14 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-15 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-16 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-17 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-18 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-19 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-20 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-21 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-22 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: ( arg2 ) \mapsto \mathtt{CokernelObject}(arg2)\).

##### 7.6-23 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-24 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-25 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-26 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-27 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-28 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-29 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-30 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-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: ( arg2 ) \mapsto \mathtt{Coproduct}(arg2)\).

##### 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: ( arg2 ) \mapsto \mathtt{DirectProduct}(arg2)\).

##### 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: ( arg2 ) \mapsto \mathtt{DirectSum}(arg2)\).

##### 7.6-39 AddDirectSumCodiagonalDifference

`‣ AddDirectSumCodiagonalDifference`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-40 AddDirectSumDiagonalDifference

`‣ AddDirectSumDiagonalDifference`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-41 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-42 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-43 AddDirectSumProjectionInPushout

`‣ AddDirectSumProjectionInPushout`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-44 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-45 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-46 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-47 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-48 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-49 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-50 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-51 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: ( arg2, arg3 ) \mapsto \mathtt{Equalizer}(arg2, arg3)\).

##### 7.6-52 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-53 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-54 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: ( arg2 ) \mapsto \mathtt{FiberProduct}(arg2)\).

##### 7.6-55 AddFiberProductEmbeddingInDirectSum

`‣ AddFiberProductEmbeddingInDirectSum`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-56 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-57 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-58 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-59 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-60 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-61 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-62 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-63 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-64 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-65 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-66 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-67 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-68 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-69 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-70 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-71 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-72 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-73 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-74 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-75 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-76 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-77 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-78 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-79 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-80 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-81 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-82 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-83 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-84 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-85 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-86 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-87 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-88 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-89 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-90 AddInverseMorphismFromCoimageToImageWithGivenObjects

`‣ AddInverseMorphismFromCoimageToImageWithGivenObjects`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-91 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-92 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-93 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-94 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-95 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-96 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-97 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-98 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-99 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-100 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-101 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-102 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-103 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-104 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-105 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-106 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-107 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-108 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-109 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-110 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-111 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-112 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-113 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-114 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-115 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-116 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-117 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-118 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-119 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-120 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-121 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-122 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: ( arg2 ) \mapsto \mathtt{IsWellDefinedForMorphisms}(arg2)\).

##### 7.6-123 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-124 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-125 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-126 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-127 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-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 AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout

`‣ AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout`( C, F ) | ( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation `IsomorphismFromCokernelOfDiagonalDifferenceToPushout`. \(F: ( D ) \mapsto \mathtt{IsomorphismFromCokernelOfDiagonalDifferenceToPushout}(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 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-137 AddIsomorphismFromFiberProductToKernelOfDiagonalDifference

`‣ AddIsomorphismFromFiberProductToKernelOfDiagonalDifference`( C, F ) | ( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation `IsomorphismFromFiberProductToKernelOfDiagonalDifference`. \(F: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToKernelOfDiagonalDifference}(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 AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct

`‣ AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct`( C, F ) | ( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation `IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct`. \(F: ( D ) \mapsto \mathtt{IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct}(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 AddIsomorphismFromPushoutToCokernelOfDiagonalDifference

`‣ AddIsomorphismFromPushoutToCokernelOfDiagonalDifference`( C, F ) | ( operation )

Returns: nothing

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

##### 7.6-146 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-147 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-148 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-149 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-150 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-151 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-152 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-153 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: ( arg2 ) \mapsto \mathtt{KernelObject}(arg2)\).

##### 7.6-154 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-155 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-156 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-157 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-158 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-159 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-160 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-161 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-162 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-163 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-164 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-165 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-166 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-167 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-168 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-169 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-170 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-171 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-172 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-173 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-174 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-175 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-176 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-177 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-178 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-179 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-180 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-181 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, a ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, a)\).

##### 7.6-182 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-183 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-184 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-185 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: ( list_of_morphisms ) \mapsto \mathtt{PostComposeList}(list_of_morphisms)\).

##### 7.6-186 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-187 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-188 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: ( list_of_morphisms ) \mapsto \mathtt{PreComposeList}(list_of_morphisms)\).

##### 7.6-189 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-190 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-191 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-192 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-193 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-194 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-195 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-196 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-197 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-198 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-199 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-200 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-201 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: ( arg2 ) \mapsto \mathtt{Pushout}(arg2)\).

##### 7.6-202 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-203 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-204 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-205 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-206 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-207 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-208 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-209 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-210 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-211 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-212 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-213 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-214 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-215 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-216 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-217 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-218 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-219 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-220 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-221 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-222 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-223 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-224 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-225 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-226 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-227 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-228 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-229 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-230 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-231 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-232 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-233 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-234 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-235 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-236 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-237 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-238 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-239 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: ( a, b ) \mapsto \mathtt{SubtractionForMorphisms}(a, b)\).

##### 7.6-240 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-241 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-242 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-243 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-244 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-245 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-246 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-247 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-248 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-249 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-250 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-251 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-252 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-253 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-254 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-255 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-256 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-257 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-258 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-259 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-260 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-261 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-262 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-263 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-264 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-265 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-266 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-267 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-268 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-269 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-270 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-271 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-272 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-273 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-274 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-275 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-276 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-277 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)\).

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Ind

generated by GAPDoc2HTML