GAP (CAP) - Chapter 7: Add Functions

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

[MathJax off]

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

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

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

- Option check: There are two possible options for every add method: `SetPrimitive` and `IsDerivation`.

  - `SetPrimitive` should be a boolean, the default is true. If `SetPrimitive` is false, then the current call of this add will not set the installed function to be primitive. This is used for derivations.

  - `IsDerivation` should be a boolean, default is false. If it is true, the add method assumes that the given function is a derivation and does not try to install a corresponding pair (See below).

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

- Checking for pairs: If the function is part of a with given pair, we check if the weight of the with given operation is less than or equal to the weight of the without given operation. If this is the case, the redirect function for the without given operation is enabled, else disabled.

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

- SetPrimitive: If the set primitive flag is true, it is set as primitive in the weight list of the category.

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

#### 7.3 InstallAdd Function

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

    DeclareOperation( "CapInternalInstallAdd",
                      [ IsRecord ] );

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

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

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

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

- pre_function_full (optional): A function which is used as the full prefunction of the installed methods, as described above.

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

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

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

  - `category`,

  - `cell`,

  - `object`,

  - `morphism`,

  - `twocell`,

  - `object_in_range_category_of_homomorphism_structure`,

  - `morphism_in_range_category_of_homomorphism_structure`,

  - `other_category`,

  - `other_cell`,

  - `other_object`,

  - `other_morphism`,

  - `other_twocell`,

  - `list_of_objects`,

  - `list_of_morphisms`,

  - `list_of_twocells`.

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

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

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

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

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

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

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

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

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

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

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

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

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

- 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 Install All Adds

The function CAP_INTERNAL_INSTALL_ALL_ADDS does not take any arguments. It is an auxiliary function which first applies CAP_INTERNAL_ENHANCE_NAME_RECORD to CAP_INTERNAL_METHOD_NAME_RECORD. Afterwards it iterates over CAP_INTERNAL_METHOD_NAME_RECORD and calls the CapInternalInstallAdd with the corresponding method record entry except if the no_install component of the record is set to true.

#### 7.6 Prepare functions

##### 7.6-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.6-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.6-3 ListCAPPrepareFunctions

`‣ ListCAPPrepareFunctions`( arg ) | ( function )

Lists all prepare functions.

#### 7.7 Available Add functions

##### 7.7-1 AddAdditionForMorphisms

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

Returns: nothing

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

##### 7.7-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.7-3 AddAdditiveInverseForMorphisms

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

Returns: nothing

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

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

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

Returns: nothing

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

##### 7.7-8 AddCanonicalIdentificationFromImageObjectToCoimage

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

Returns: nothing

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

##### 7.7-9 AddCoastrictionToImage

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

Returns: nothing

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

##### 7.7-10 AddCoastrictionToImageWithGivenImageObject

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

Returns: nothing

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

##### 7.7-11 AddCoefficientsOfMorphismWithGivenBasisOfExternalHom

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

Returns: nothing

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

##### 7.7-12 AddCoequalizer

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

Returns: nothing

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

##### 7.7-13 AddCoequalizerFunctorial

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

Returns: nothing

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

##### 7.7-14 AddCoequalizerFunctorialWithGivenCoequalizers

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

Returns: nothing

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

##### 7.7-15 AddCoimageObject

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

Returns: nothing

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

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

##### 7.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-28 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.7-29 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.7-30 AddCoproduct

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

Returns: nothing

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

##### 7.7-31 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.7-32 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.7-33 AddDirectProduct

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

Returns: nothing

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

##### 7.7-34 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.7-35 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.7-36 AddDirectSum

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

Returns: nothing

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

##### 7.7-37 AddDirectSumCodiagonalDifference

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

Returns: nothing

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

##### 7.7-38 AddDirectSumDiagonalDifference

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

Returns: nothing

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

##### 7.7-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.7-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.7-41 AddDirectSumProjectionInPushout

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

Returns: nothing

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

##### 7.7-42 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.7-43 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: ( morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(morphisms)\).

##### 7.7-44 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: ( morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(morphisms, P)\).

##### 7.7-45 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.7-46 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.7-47 AddEqualizer

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

Returns: nothing

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

##### 7.7-48 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.7-49 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.7-50 AddFiberProduct

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

Returns: nothing

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

##### 7.7-51 AddFiberProductEmbeddingInDirectSum

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

Returns: nothing

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

##### 7.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-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.7-66 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.7-67 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.7-68 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.7-69 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.7-70 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.7-71 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.7-72 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.7-73 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.7-74 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.7-75 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.7-76 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.7-77 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.7-78 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.7-79 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: ( arg2, arg3, arg4 ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(arg2, arg3, arg4)\).

##### 7.7-80 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.7-81 AddInverseMorphismFromCoimageToImageWithGivenObjects

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

Returns: nothing

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

##### 7.7-82 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.7-83 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.7-84 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.7-85 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.7-86 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.7-87 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.7-88 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.7-89 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.7-90 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.7-91 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.7-92 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.7-93 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.7-94 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.7-95 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.7-96 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.7-97 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.7-98 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.7-99 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.7-100 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.7-101 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.7-102 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.7-103 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.7-104 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.7-105 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.7-106 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.7-107 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.7-108 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.7-109 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.7-110 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.7-111 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.7-112 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.7-113 AddIsWellDefinedForMorphisms

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

Returns: nothing

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

##### 7.7-114 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.7-115 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.7-116 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.7-117 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.7-118 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.7-119 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.7-120 AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout

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

Returns: nothing

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

##### 7.7-121 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.7-122 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.7-123 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.7-124 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.7-125 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.7-126 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.7-127 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.7-128 AddIsomorphismFromFiberProductToKernelOfDiagonalDifference

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

Returns: nothing

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

##### 7.7-129 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.7-130 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.7-131 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.7-132 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.7-133 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.7-134 AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct

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

Returns: nothing

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

##### 7.7-135 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.7-136 AddIsomorphismFromPushoutToCokernelOfDiagonalDifference

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

Returns: nothing

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

##### 7.7-137 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.7-138 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.7-139 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.7-140 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.7-141 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.7-142 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.7-143 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.7-144 AddKernelObject

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

Returns: nothing

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

##### 7.7-145 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.7-146 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.7-147 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.7-148 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.7-149 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.7-150 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.7-151 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.7-152 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.7-153 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.7-154 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.7-155 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.7-156 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.7-157 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.7-158 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: ( morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(morphisms)\).

##### 7.7-159 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: ( morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(morphisms, P)\).

##### 7.7-160 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.7-161 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.7-162 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.7-163 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.7-164 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: ( morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(morphisms)\).

##### 7.7-165 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: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(morphisms, P)\).

##### 7.7-166 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.7-167 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.7-168 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.7-169 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.7-170 AddMultiplyWithElementOfCommutativeRingForMorphisms

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

Returns: nothing

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

##### 7.7-171 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.7-172 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.7-173 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.7-174 AddPostComposeList

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

Returns: nothing

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

##### 7.7-175 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.7-176 AddPreComposeList

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

Returns: nothing

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

##### 7.7-177 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.7-178 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.7-179 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.7-180 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.7-181 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.7-182 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.7-183 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: ( morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(morphisms)\).

##### 7.7-184 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: ( morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(morphisms, P)\).

##### 7.7-185 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.7-186 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.7-187 AddPushout

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

Returns: nothing

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

##### 7.7-188 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.7-189 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.7-190 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.7-191 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.7-192 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.7-193 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.7-194 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.7-195 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.7-196 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.7-197 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.7-198 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.7-199 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.7-200 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.7-201 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.7-202 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.7-203 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.7-204 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.7-205 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.7-206 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.7-207 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.7-208 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.7-209 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.7-210 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.7-211 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.7-212 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.7-213 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.7-214 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.7-215 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.7-216 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.7-217 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.7-218 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.7-219 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.7-220 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.7-221 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.7-222 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.7-223 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.7-224 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.7-225 AddSubtractionForMorphisms

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

Returns: nothing

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

##### 7.7-226 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.7-227 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.7-228 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.7-229 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: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(morphisms, T, tau)\).

##### 7.7-230 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: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(morphisms, T, tau, P)\).

##### 7.7-231 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.7-232 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.7-233 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.7-234 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.7-235 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.7-236 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.7-237 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.7-238 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.7-239 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.7-240 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.7-241 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.7-242 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.7-243 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.7-244 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.7-245 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.7-246 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.7-247 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.7-248 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.7-249 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: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(morphisms, T, tau)\).

##### 7.7-250 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: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(morphisms, T, tau, P)\).

##### 7.7-251 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.7-252 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.7-253 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.7-254 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.7-255 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.7-256 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.7-257 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.7-258 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.7-259 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.7-260 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.7-261 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.7-262 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 Ind

generated by GAPDoc2HTML