GAP (CAP) - Chapter 7: Add Functions

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

[MathJax on]

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

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

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

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

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

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

- filter_list: A list containing the basic filters for the methods installed by the add methods. Possible entries are filters, or the strings listed below, which will be replaced by appropriate filters at the time the add method is called. The first entry of `filter_list` must be the string `category`. If the category can be inferred from the remaining arguments, a convenience method without the category as the first argument is installed automatically.

  - `category`,

  - `object`,

  - `morphism`,

  - `twocell`,

  - `object_in_range_category_of_homomorphism_structure`,

  - `morphism_in_range_category_of_homomorphism_structure`,

  - `list_of_objects`,

  - `list_of_morphisms`,

  - `list_of_twocells`.

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

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

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

- dual_operation (optional): Name of the dual operation.

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

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

- dual_preprocessor_func[_string] (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the arguments given to g are preprocessed by this given function. The function can also be given as a string.

- dual_postprocessor_func[_string] (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the computed value of f is postprocessed by the given function. The function can also be given as a string.

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

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

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

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

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

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

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

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

##### 7.3-1 CapInternalInstallAdd

`‣ CapInternalInstallAdd`( record ) | ( function )

See 7.3.

#### 7.4 Enhancing the method name record

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

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

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

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

#### 7.5 Prepare functions

##### 7.5-1 CAPOperationPrepareFunction

`‣ CAPOperationPrepareFunction`( prepare_function, category, func ) | ( function )

Returns: a function

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

Note that func is not handled by the CAP caching mechanism and that the use of prepare functions is incompatible with `WithGiven` operations. Thus, one has to ensure manually that the equality and typing specifications are fulfilled.

##### 7.5-2 CAPAddPrepareFunction

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

Adds a prepare function to the list of CAP's prepare functions. The first argument is the prepare function itself. It should always be a function that takes a category and a function and returns a function. The argument name is the name of the prepare function, which is used in `CAPOperationPrepareFunction`. The argument doc_string should be a short string describing the functions. The optional argument precondition_list can describe preconditions for the prepare function to work, i.e., if the category does need to have PreCompose computable. This information is also recovered automatically from the prepare function itself, so the precondition_list is only necessary if the function needed is not explicitly used in the prepare function, e.g., if you use `+` instead of `AdditionForMorphisms`.

##### 7.5-3 ListCAPPrepareFunctions

`‣ ListCAPPrepareFunctions`( arg ) | ( function )

Lists all prepare functions.

#### 7.6 Available Add functions

##### 7.6-1 AddAdditionForMorphisms

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

Returns: nothing

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

##### 7.6-2 AddAdditiveGenerators

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

Returns: nothing

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

##### 7.6-3 AddAdditiveInverseForMorphisms

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

Returns: nothing

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

##### 7.6-4 AddAstrictionToCoimage

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

Returns: nothing

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

##### 7.6-5 AddAstrictionToCoimageWithGivenCoimageObject

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

Returns: nothing

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

##### 7.6-6 AddBasisOfExternalHom

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

Returns: nothing

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

##### 7.6-7 AddCoastrictionToImage

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

Returns: nothing

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

##### 7.6-8 AddCoastrictionToImageWithGivenImageObject

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

Returns: nothing

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

##### 7.6-9 AddCoefficientsOfMorphism

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

Returns: nothing

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

##### 7.6-10 AddCoequalizer

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

Returns: nothing

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

##### 7.6-11 AddCoequalizerFunctorial

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

Returns: nothing

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

##### 7.6-12 AddCoequalizerFunctorialWithGivenCoequalizers

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

Returns: nothing

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

##### 7.6-13 AddCoimageObject

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

Returns: nothing

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

##### 7.6-14 AddCoimageObjectFunctorial

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

Returns: nothing

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

##### 7.6-15 AddCoimageObjectFunctorialWithGivenCoimageObjects

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

Returns: nothing

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

##### 7.6-16 AddCoimageProjection

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

Returns: nothing

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

##### 7.6-17 AddCoimageProjectionWithGivenCoimageObject

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

Returns: nothing

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

##### 7.6-18 AddCokernelColift

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

Returns: nothing

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

##### 7.6-19 AddCokernelColiftWithGivenCokernelObject

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

Returns: nothing

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

##### 7.6-20 AddCokernelObject

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

Returns: nothing

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

##### 7.6-21 AddCokernelObjectFunctorial

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

Returns: nothing

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

##### 7.6-22 AddCokernelObjectFunctorialWithGivenCokernelObjects

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

Returns: nothing

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

##### 7.6-23 AddCokernelProjection

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

Returns: nothing

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

##### 7.6-24 AddCokernelProjectionWithGivenCokernelObject

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

Returns: nothing

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

##### 7.6-25 AddColift

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

Returns: nothing

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

##### 7.6-26 AddColiftAlongEpimorphism

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

Returns: nothing

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

##### 7.6-27 AddColiftOrFail

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

Returns: nothing

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

##### 7.6-28 AddComponentOfMorphismFromCoproduct

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

Returns: nothing

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

##### 7.6-29 AddComponentOfMorphismFromDirectSum

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

Returns: nothing

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

##### 7.6-30 AddComponentOfMorphismIntoDirectProduct

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

Returns: nothing

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

##### 7.6-31 AddComponentOfMorphismIntoDirectSum

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

Returns: nothing

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

##### 7.6-32 AddCoproduct

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

Returns: nothing

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

##### 7.6-33 AddCoproductFunctorial

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

Returns: nothing

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

##### 7.6-34 AddCoproductFunctorialWithGivenCoproducts

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

Returns: nothing

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

##### 7.6-35 AddDirectProduct

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

Returns: nothing

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

##### 7.6-36 AddDirectProductFunctorial

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

Returns: nothing

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

##### 7.6-37 AddDirectProductFunctorialWithGivenDirectProducts

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

Returns: nothing

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

##### 7.6-38 AddDirectSum

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

Returns: nothing

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

##### 7.6-39 AddDirectSumFunctorial

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

Returns: nothing

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

##### 7.6-40 AddDirectSumFunctorialWithGivenDirectSums

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

Returns: nothing

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

##### 7.6-41 AddDistinguishedObjectOfHomomorphismStructure

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

Returns: nothing

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

##### 7.6-42 AddEmbeddingOfEqualizer

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

Returns: nothing

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

##### 7.6-43 AddEmbeddingOfEqualizerWithGivenEqualizer

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

Returns: nothing

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

##### 7.6-44 AddEpimorphismFromProjectiveCoverObject

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

Returns: nothing

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

##### 7.6-45 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject

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

Returns: nothing

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

##### 7.6-46 AddEpimorphismFromSomeProjectiveObject

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

Returns: nothing

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

##### 7.6-47 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject

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

Returns: nothing

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

##### 7.6-48 AddEqualizer

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

Returns: nothing

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

##### 7.6-49 AddEqualizerFunctorial

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

Returns: nothing

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

##### 7.6-50 AddEqualizerFunctorialWithGivenEqualizers

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

Returns: nothing

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

##### 7.6-51 AddFiberProduct

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

Returns: nothing

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

##### 7.6-52 AddFiberProductFunctorial

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

Returns: nothing

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

##### 7.6-53 AddFiberProductFunctorialWithGivenFiberProducts

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

Returns: nothing

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

##### 7.6-54 AddHomologyObject

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

Returns: nothing

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

##### 7.6-55 AddHomologyObjectFunctorialWithGivenHomologyObjects

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

Returns: nothing

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

##### 7.6-56 AddHomomorphismStructureOnMorphisms

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

Returns: nothing

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

##### 7.6-57 AddHomomorphismStructureOnMorphismsWithGivenObjects

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

Returns: nothing

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

##### 7.6-58 AddHomomorphismStructureOnObjects

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

Returns: nothing

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

##### 7.6-59 AddHorizontalPostCompose

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

Returns: nothing

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

##### 7.6-60 AddHorizontalPreCompose

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

Returns: nothing

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

##### 7.6-61 AddIdentityMorphism

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

Returns: nothing

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

##### 7.6-62 AddIdentityTwoCell

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

Returns: nothing

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

##### 7.6-63 AddImageEmbedding

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

Returns: nothing

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

##### 7.6-64 AddImageEmbeddingWithGivenImageObject

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

Returns: nothing

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

##### 7.6-65 AddImageObject

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

Returns: nothing

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

##### 7.6-66 AddImageObjectFunctorial

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

Returns: nothing

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

##### 7.6-67 AddImageObjectFunctorialWithGivenImageObjects

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

Returns: nothing

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

##### 7.6-68 AddIndecomposableInjectiveObjects

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

Returns: nothing

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

##### 7.6-69 AddIndecomposableProjectiveObjects

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

Returns: nothing

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

##### 7.6-70 AddInitialObject

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

Returns: nothing

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

##### 7.6-71 AddInitialObjectFunctorial

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

Returns: nothing

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

##### 7.6-72 AddInitialObjectFunctorialWithGivenInitialObjects

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

Returns: nothing

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

##### 7.6-73 AddInjectionOfCofactorOfCoproduct

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

Returns: nothing

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

##### 7.6-74 AddInjectionOfCofactorOfCoproductWithGivenCoproduct

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

Returns: nothing

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

##### 7.6-75 AddInjectionOfCofactorOfDirectSum

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

Returns: nothing

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

##### 7.6-76 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum

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

Returns: nothing

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

##### 7.6-77 AddInjectionOfCofactorOfPushout

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

Returns: nothing

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

##### 7.6-78 AddInjectionOfCofactorOfPushoutWithGivenPushout

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

Returns: nothing

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

##### 7.6-79 AddInjectiveColift

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

Returns: nothing

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

##### 7.6-80 AddInjectiveDimension

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

Returns: nothing

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

##### 7.6-81 AddInjectiveEnvelopeObject

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

Returns: nothing

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

##### 7.6-82 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure

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

Returns: nothing

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

##### 7.6-83 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects

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

Returns: nothing

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

##### 7.6-84 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism

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

Returns: nothing

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

##### 7.6-85 AddInverseForMorphisms

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

Returns: nothing

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

##### 7.6-86 AddInverseOfMorphismFromCoimageToImage

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

Returns: nothing

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

##### 7.6-87 AddInverseOfMorphismFromCoimageToImageWithGivenObjects

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

Returns: nothing

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

##### 7.6-88 AddIsAutomorphism

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

Returns: nothing

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

##### 7.6-89 AddIsBijectiveObject

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

Returns: nothing

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

##### 7.6-90 AddIsCodominating

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

Returns: nothing

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

##### 7.6-91 AddIsColiftable

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

Returns: nothing

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

##### 7.6-92 AddIsColiftableAlongEpimorphism

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

Returns: nothing

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

##### 7.6-93 AddIsCongruentForMorphisms

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

Returns: nothing

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

##### 7.6-94 AddIsDominating

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

Returns: nothing

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

##### 7.6-95 AddIsEndomorphism

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

Returns: nothing

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

##### 7.6-96 AddIsEpimorphism

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

Returns: nothing

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

##### 7.6-97 AddIsEqualAsFactorobjects

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

Returns: nothing

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

##### 7.6-98 AddIsEqualAsSubobjects

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

Returns: nothing

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

##### 7.6-99 AddIsEqualForCacheForMorphisms

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

Returns: nothing

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

##### 7.6-100 AddIsEqualForCacheForObjects

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

Returns: nothing

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

##### 7.6-101 AddIsEqualForMorphisms

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

Returns: nothing

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

##### 7.6-102 AddIsEqualForMorphismsOnMor

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

Returns: nothing

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

##### 7.6-103 AddIsEqualForObjects

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

Returns: nothing

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

##### 7.6-104 AddIsEqualToIdentityMorphism

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

Returns: nothing

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

##### 7.6-105 AddIsEqualToZeroMorphism

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

Returns: nothing

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

##### 7.6-106 AddIsHomSetInhabited

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

Returns: nothing

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

##### 7.6-107 AddIsIdempotent

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

Returns: nothing

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

##### 7.6-108 AddIsInitial

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

Returns: nothing

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

##### 7.6-109 AddIsInjective

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

Returns: nothing

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

##### 7.6-110 AddIsIsomorphicForObjects

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

Returns: nothing

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

##### 7.6-111 AddIsIsomorphism

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

Returns: nothing

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

##### 7.6-112 AddIsLiftable

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

Returns: nothing

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

##### 7.6-113 AddIsLiftableAlongMonomorphism

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

Returns: nothing

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

##### 7.6-114 AddIsMonomorphism

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

Returns: nothing

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

##### 7.6-115 AddIsOne

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

Returns: nothing

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

##### 7.6-116 AddIsProjective

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

Returns: nothing

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

##### 7.6-117 AddIsSplitEpimorphism

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

Returns: nothing

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

##### 7.6-118 AddIsSplitMonomorphism

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

Returns: nothing

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

##### 7.6-119 AddIsTerminal

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

Returns: nothing

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

##### 7.6-120 AddIsWellDefinedForMorphisms

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

Returns: nothing

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

##### 7.6-121 AddIsWellDefinedForMorphismsWithGivenSourceAndRange

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

Returns: nothing

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

##### 7.6-122 AddIsWellDefinedForObjects

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

Returns: nothing

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

##### 7.6-123 AddIsWellDefinedForTwoCells

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

Returns: nothing

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

##### 7.6-124 AddIsZeroForMorphisms

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

Returns: nothing

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

##### 7.6-125 AddIsZeroForObjects

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

Returns: nothing

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

##### 7.6-126 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout

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

Returns: nothing

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

##### 7.6-127 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct

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

Returns: nothing

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

##### 7.6-128 AddIsomorphismFromCoimageToCokernelOfKernel

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

Returns: nothing

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

##### 7.6-129 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer

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

Returns: nothing

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

##### 7.6-130 AddIsomorphismFromCokernelOfKernelToCoimage

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

Returns: nothing

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

##### 7.6-131 AddIsomorphismFromCoproductToDirectSum

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

Returns: nothing

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

##### 7.6-132 AddIsomorphismFromDirectProductToDirectSum

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

Returns: nothing

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

##### 7.6-133 AddIsomorphismFromDirectSumToCoproduct

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

Returns: nothing

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

##### 7.6-134 AddIsomorphismFromDirectSumToDirectProduct

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

Returns: nothing

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

##### 7.6-135 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct

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

Returns: nothing

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

##### 7.6-136 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct

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

Returns: nothing

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

##### 7.6-137 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram

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

Returns: nothing

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

##### 7.6-138 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject

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

Returns: nothing

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

##### 7.6-139 AddIsomorphismFromImageObjectToKernelOfCokernel

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

Returns: nothing

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

##### 7.6-140 AddIsomorphismFromInitialObjectToZeroObject

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

Returns: nothing

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

##### 7.6-141 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject

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

Returns: nothing

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

##### 7.6-142 AddIsomorphismFromKernelOfCokernelToImageObject

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

Returns: nothing

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

##### 7.6-143 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer

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

Returns: nothing

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

##### 7.6-144 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram

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

Returns: nothing

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

##### 7.6-145 AddIsomorphismFromTerminalObjectToZeroObject

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

Returns: nothing

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

##### 7.6-146 AddIsomorphismFromZeroObjectToInitialObject

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

Returns: nothing

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

##### 7.6-147 AddIsomorphismFromZeroObjectToTerminalObject

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

Returns: nothing

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

##### 7.6-148 AddJointPairwiseDifferencesOfMorphismsFromCoproduct

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

Returns: nothing

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

##### 7.6-149 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct

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

Returns: nothing

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

##### 7.6-150 AddKernelEmbedding

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

Returns: nothing

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

##### 7.6-151 AddKernelEmbeddingWithGivenKernelObject

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

Returns: nothing

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

##### 7.6-152 AddKernelLift

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

Returns: nothing

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

##### 7.6-153 AddKernelLiftWithGivenKernelObject

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

Returns: nothing

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

##### 7.6-154 AddKernelObject

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

Returns: nothing

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

##### 7.6-155 AddKernelObjectFunctorial

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

Returns: nothing

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

##### 7.6-156 AddKernelObjectFunctorialWithGivenKernelObjects

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

Returns: nothing

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

##### 7.6-157 AddLift

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

Returns: nothing

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

##### 7.6-158 AddLiftAlongMonomorphism

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

Returns: nothing

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

##### 7.6-159 AddLiftOrFail

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

Returns: nothing

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

##### 7.6-160 AddLinearCombinationOfMorphisms

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

Returns: nothing

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

##### 7.6-161 AddMereExistenceOfSolutionOfLinearSystemInAbCategory

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

Returns: nothing

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

##### 7.6-162 AddMonomorphismIntoInjectiveEnvelopeObject

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

Returns: nothing

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

##### 7.6-163 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject

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

Returns: nothing

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

##### 7.6-164 AddMonomorphismIntoSomeInjectiveObject

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

Returns: nothing

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

##### 7.6-165 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject

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

Returns: nothing

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

##### 7.6-166 AddMorphismBetweenDirectSums

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

Returns: nothing

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

##### 7.6-167 AddMorphismBetweenDirectSumsWithGivenDirectSums

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

Returns: nothing

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

##### 7.6-168 AddMorphismConstructor

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

Returns: nothing

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

##### 7.6-169 AddMorphismDatum

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

Returns: nothing

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

##### 7.6-170 AddMorphismFromCoimageToImage

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

Returns: nothing

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

##### 7.6-171 AddMorphismFromCoimageToImageWithGivenObjects

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

Returns: nothing

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

##### 7.6-172 AddMorphismFromEqualizerToSink

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

Returns: nothing

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

##### 7.6-173 AddMorphismFromEqualizerToSinkWithGivenEqualizer

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

Returns: nothing

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

##### 7.6-174 AddMorphismFromFiberProductToSink

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

Returns: nothing

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

##### 7.6-175 AddMorphismFromFiberProductToSinkWithGivenFiberProduct

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

Returns: nothing

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

##### 7.6-176 AddMorphismFromKernelObjectToSink

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

Returns: nothing

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

##### 7.6-177 AddMorphismFromKernelObjectToSinkWithGivenKernelObject

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

Returns: nothing

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

##### 7.6-178 AddMorphismFromSourceToCoequalizer

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

Returns: nothing

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

##### 7.6-179 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer

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

Returns: nothing

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

##### 7.6-180 AddMorphismFromSourceToCokernelObject

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

Returns: nothing

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

##### 7.6-181 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject

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

Returns: nothing

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

##### 7.6-182 AddMorphismFromSourceToPushout

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

Returns: nothing

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

##### 7.6-183 AddMorphismFromSourceToPushoutWithGivenPushout

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

Returns: nothing

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

##### 7.6-184 AddMorphismsOfExternalHom

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

Returns: nothing

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

##### 7.6-185 AddMultiplyWithElementOfCommutativeRingForMorphisms

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

Returns: nothing

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

##### 7.6-186 AddObjectConstructor

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

Returns: nothing

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

##### 7.6-187 AddObjectDatum

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

Returns: nothing

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

##### 7.6-188 AddPostCompose

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

Returns: nothing

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

##### 7.6-189 AddPostComposeList

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

Returns: nothing

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

##### 7.6-190 AddPostInverseForMorphisms

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

Returns: nothing

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

##### 7.6-191 AddPreCompose

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

Returns: nothing

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

##### 7.6-192 AddPreComposeList

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

Returns: nothing

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

##### 7.6-193 AddPreInverseForMorphisms

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

Returns: nothing

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

##### 7.6-194 AddProjectionInFactorOfDirectProduct

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

Returns: nothing

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

##### 7.6-195 AddProjectionInFactorOfDirectProductWithGivenDirectProduct

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

Returns: nothing

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

##### 7.6-196 AddProjectionInFactorOfDirectSum

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

Returns: nothing

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

##### 7.6-197 AddProjectionInFactorOfDirectSumWithGivenDirectSum

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

Returns: nothing

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

##### 7.6-198 AddProjectionInFactorOfFiberProduct

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

Returns: nothing

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

##### 7.6-199 AddProjectionInFactorOfFiberProductWithGivenFiberProduct

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

Returns: nothing

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

##### 7.6-200 AddProjectionOntoCoequalizer

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

Returns: nothing

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

##### 7.6-201 AddProjectionOntoCoequalizerWithGivenCoequalizer

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

Returns: nothing

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

##### 7.6-202 AddProjectiveCoverObject

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

Returns: nothing

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

##### 7.6-203 AddProjectiveDimension

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

Returns: nothing

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

##### 7.6-204 AddProjectiveLift

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

Returns: nothing

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

##### 7.6-205 AddPushout

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

Returns: nothing

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

##### 7.6-206 AddPushoutFunctorial

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

Returns: nothing

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

##### 7.6-207 AddPushoutFunctorialWithGivenPushouts

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

Returns: nothing

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

##### 7.6-208 AddRandomMorphismByInteger

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

Returns: nothing

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

##### 7.6-209 AddRandomMorphismByList

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

Returns: nothing

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

##### 7.6-210 AddRandomMorphismWithFixedRangeByInteger

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

Returns: nothing

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

##### 7.6-211 AddRandomMorphismWithFixedRangeByList

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

Returns: nothing

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

##### 7.6-212 AddRandomMorphismWithFixedSourceAndRangeByInteger

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

Returns: nothing

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

##### 7.6-213 AddRandomMorphismWithFixedSourceAndRangeByList

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

Returns: nothing

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

##### 7.6-214 AddRandomMorphismWithFixedSourceByInteger

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

Returns: nothing

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

##### 7.6-215 AddRandomMorphismWithFixedSourceByList

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

Returns: nothing

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

##### 7.6-216 AddRandomObjectByInteger

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

Returns: nothing

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

##### 7.6-217 AddRandomObjectByList

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

Returns: nothing

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

##### 7.6-218 AddSimplifyEndo

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

Returns: nothing

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

##### 7.6-219 AddSimplifyEndo_IsoFromInputObject

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

Returns: nothing

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

##### 7.6-220 AddSimplifyEndo_IsoToInputObject

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

Returns: nothing

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

##### 7.6-221 AddSimplifyMorphism

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

Returns: nothing

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

##### 7.6-222 AddSimplifyObject

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

Returns: nothing

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

##### 7.6-223 AddSimplifyObject_IsoFromInputObject

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

Returns: nothing

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

##### 7.6-224 AddSimplifyObject_IsoToInputObject

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

Returns: nothing

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

##### 7.6-225 AddSimplifyRange

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

Returns: nothing

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

##### 7.6-226 AddSimplifyRange_IsoFromInputObject

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

Returns: nothing

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

##### 7.6-227 AddSimplifyRange_IsoToInputObject

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

Returns: nothing

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

##### 7.6-228 AddSimplifySource

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

Returns: nothing

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

##### 7.6-229 AddSimplifySourceAndRange

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

Returns: nothing

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

##### 7.6-230 AddSimplifySourceAndRange_IsoFromInputRange

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

Returns: nothing

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

##### 7.6-231 AddSimplifySourceAndRange_IsoFromInputSource

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

Returns: nothing

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

##### 7.6-232 AddSimplifySourceAndRange_IsoToInputRange

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

Returns: nothing

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

##### 7.6-233 AddSimplifySourceAndRange_IsoToInputSource

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

Returns: nothing

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

##### 7.6-234 AddSimplifySource_IsoFromInputObject

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

Returns: nothing

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

##### 7.6-235 AddSimplifySource_IsoToInputObject

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

Returns: nothing

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

##### 7.6-236 AddSolveLinearSystemInAbCategory

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

Returns: nothing

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

##### 7.6-237 AddSolveLinearSystemInAbCategoryOrFail

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

Returns: nothing

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

##### 7.6-238 AddSomeInjectiveObject

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

Returns: nothing

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

##### 7.6-239 AddSomeIsomorphismBetweenObjects

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

Returns: nothing

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

##### 7.6-240 AddSomeProjectiveObject

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

Returns: nothing

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

##### 7.6-241 AddSomeReductionBySplitEpiSummand

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

Returns: nothing

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

##### 7.6-242 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange

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

Returns: nothing

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

##### 7.6-243 AddSomeReductionBySplitEpiSummand_MorphismToInputRange

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

Returns: nothing

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

##### 7.6-244 AddSubtractionForMorphisms

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

Returns: nothing

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

##### 7.6-245 AddSumOfMorphisms

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

Returns: nothing

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

##### 7.6-246 AddTerminalObject

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

Returns: nothing

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

##### 7.6-247 AddTerminalObjectFunctorial

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

Returns: nothing

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

##### 7.6-248 AddTerminalObjectFunctorialWithGivenTerminalObjects

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

Returns: nothing

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

##### 7.6-249 AddUniversalMorphismFromCoequalizer

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

Returns: nothing

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

##### 7.6-250 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer

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

Returns: nothing

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

##### 7.6-251 AddUniversalMorphismFromCoproduct

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

Returns: nothing

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

##### 7.6-252 AddUniversalMorphismFromCoproductWithGivenCoproduct

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

Returns: nothing

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

##### 7.6-253 AddUniversalMorphismFromDirectSum

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

Returns: nothing

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

##### 7.6-254 AddUniversalMorphismFromDirectSumWithGivenDirectSum

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

Returns: nothing

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

##### 7.6-255 AddUniversalMorphismFromImage

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

Returns: nothing

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

##### 7.6-256 AddUniversalMorphismFromImageWithGivenImageObject

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

Returns: nothing

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

##### 7.6-257 AddUniversalMorphismFromInitialObject

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

Returns: nothing

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

##### 7.6-258 AddUniversalMorphismFromInitialObjectWithGivenInitialObject

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

Returns: nothing

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

##### 7.6-259 AddUniversalMorphismFromPushout

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

Returns: nothing

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

##### 7.6-260 AddUniversalMorphismFromPushoutWithGivenPushout

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

Returns: nothing

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

##### 7.6-261 AddUniversalMorphismFromZeroObject

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

Returns: nothing

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

##### 7.6-262 AddUniversalMorphismFromZeroObjectWithGivenZeroObject

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

Returns: nothing

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

##### 7.6-263 AddUniversalMorphismIntoCoimage

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

Returns: nothing

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

##### 7.6-264 AddUniversalMorphismIntoCoimageWithGivenCoimageObject

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

Returns: nothing

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

##### 7.6-265 AddUniversalMorphismIntoDirectProduct

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

Returns: nothing

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

##### 7.6-266 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct

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

Returns: nothing

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

##### 7.6-267 AddUniversalMorphismIntoDirectSum

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

Returns: nothing

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

##### 7.6-268 AddUniversalMorphismIntoDirectSumWithGivenDirectSum

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

Returns: nothing

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

##### 7.6-269 AddUniversalMorphismIntoEqualizer

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

Returns: nothing

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

##### 7.6-270 AddUniversalMorphismIntoEqualizerWithGivenEqualizer

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

Returns: nothing

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

##### 7.6-271 AddUniversalMorphismIntoFiberProduct

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

Returns: nothing

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

##### 7.6-272 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct

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

Returns: nothing

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

##### 7.6-273 AddUniversalMorphismIntoTerminalObject

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

Returns: nothing

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

##### 7.6-274 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject

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

Returns: nothing

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

##### 7.6-275 AddUniversalMorphismIntoZeroObject

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

Returns: nothing

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

##### 7.6-276 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject

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

Returns: nothing

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

##### 7.6-277 AddVerticalPostCompose

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

Returns: nothing

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

##### 7.6-278 AddVerticalPreCompose

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

Returns: nothing

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

##### 7.6-279 AddZeroMorphism

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

Returns: nothing

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

##### 7.6-280 AddZeroObject

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

Returns: nothing

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

##### 7.6-281 AddZeroObjectFunctorial

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

Returns: nothing

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

##### 7.6-282 AddZeroObjectFunctorialWithGivenZeroObjects

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

Returns: nothing

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

[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 16 Ind

generated by GAPDoc2HTML