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

7 Add Functions
 7.1 Functions Installed by Add
 7.2 Add Method
 7.3 Method name record entries
 7.4 Enhancing the method name record
 7.5 Prepare functions
 7.6 Available Add functions

  7.6-1 AddAdditionForMorphisms

  7.6-2 AddAdditiveGenerators

  7.6-3 AddAdditiveInverseForMorphisms

  7.6-4 AddAstrictionToCoimage

  7.6-5 AddAstrictionToCoimageWithGivenCoimageObject

  7.6-6 AddBasisOfExternalHom

  7.6-7 AddCoastrictionToImage

  7.6-8 AddCoastrictionToImageWithGivenImageObject

  7.6-9 AddCoefficientsOfMorphism

  7.6-10 AddCoequalizer

  7.6-11 AddCoequalizerFunctorial

  7.6-12 AddCoequalizerFunctorialWithGivenCoequalizers

  7.6-13 AddCoimageObject

  7.6-14 AddCoimageObjectFunctorial

  7.6-15 AddCoimageObjectFunctorialWithGivenCoimageObjects

  7.6-16 AddCoimageProjection

  7.6-17 AddCoimageProjectionWithGivenCoimageObject

  7.6-18 AddCokernelColift

  7.6-19 AddCokernelColiftWithGivenCokernelObject

  7.6-20 AddCokernelObject

  7.6-21 AddCokernelObjectFunctorial

  7.6-22 AddCokernelObjectFunctorialWithGivenCokernelObjects

  7.6-23 AddCokernelProjection

  7.6-24 AddCokernelProjectionWithGivenCokernelObject

  7.6-25 AddColift

  7.6-26 AddColiftAlongEpimorphism

  7.6-27 AddComponentOfMorphismFromCoproduct

  7.6-28 AddComponentOfMorphismFromDirectSum

  7.6-29 AddComponentOfMorphismIntoDirectProduct

  7.6-30 AddComponentOfMorphismIntoDirectSum

  7.6-31 AddCoproduct

  7.6-32 AddCoproductFunctorial

  7.6-33 AddCoproductFunctorialWithGivenCoproducts

  7.6-34 AddDirectProduct

  7.6-35 AddDirectProductFunctorial

  7.6-36 AddDirectProductFunctorialWithGivenDirectProducts

  7.6-37 AddDirectSum

  7.6-38 AddDirectSumFunctorial

  7.6-39 AddDirectSumFunctorialWithGivenDirectSums

  7.6-40 AddDistinguishedObjectOfHomomorphismStructure

  7.6-41 AddEmbeddingOfEqualizer

  7.6-42 AddEmbeddingOfEqualizerWithGivenEqualizer

  7.6-43 AddEpimorphismFromProjectiveCoverObject

  7.6-44 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject

  7.6-45 AddEpimorphismFromSomeProjectiveObject

  7.6-46 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject

  7.6-47 AddEqualizer

  7.6-48 AddEqualizerFunctorial

  7.6-49 AddEqualizerFunctorialWithGivenEqualizers

  7.6-50 AddFiberProduct

  7.6-51 AddFiberProductFunctorial

  7.6-52 AddFiberProductFunctorialWithGivenFiberProducts

  7.6-53 AddHomologyObject

  7.6-54 AddHomologyObjectFunctorialWithGivenHomologyObjects

  7.6-55 AddHomomorphismStructureOnMorphisms

  7.6-56 AddHomomorphismStructureOnMorphismsWithGivenObjects

  7.6-57 AddHomomorphismStructureOnObjects

  7.6-58 AddHorizontalPostCompose

  7.6-59 AddHorizontalPreCompose

  7.6-60 AddIdentityMorphism

  7.6-61 AddIdentityTwoCell

  7.6-62 AddImageEmbedding

  7.6-63 AddImageEmbeddingWithGivenImageObject

  7.6-64 AddImageObject

  7.6-65 AddImageObjectFunctorial

  7.6-66 AddImageObjectFunctorialWithGivenImageObjects

  7.6-67 AddIndecomposableInjectiveObjects

  7.6-68 AddIndecomposableProjectiveObjects

  7.6-69 AddInitialObject

  7.6-70 AddInitialObjectFunctorial

  7.6-71 AddInitialObjectFunctorialWithGivenInitialObjects

  7.6-72 AddInjectionOfCofactorOfCoproduct

  7.6-73 AddInjectionOfCofactorOfCoproductWithGivenCoproduct

  7.6-74 AddInjectionOfCofactorOfDirectSum

  7.6-75 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum

  7.6-76 AddInjectionOfCofactorOfPushout

  7.6-77 AddInjectionOfCofactorOfPushoutWithGivenPushout

  7.6-78 AddInjectiveColift

  7.6-79 AddInjectiveDimension

  7.6-80 AddInjectiveEnvelopeObject

  7.6-81 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure

  7.6-82 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects

  7.6-83 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism

  7.6-84 AddInverseForMorphisms

  7.6-85 AddInverseOfMorphismFromCoimageToImage

  7.6-86 AddInverseOfMorphismFromCoimageToImageWithGivenObjects

  7.6-87 AddIsAutomorphism

  7.6-88 AddIsBijectiveObject

  7.6-89 AddIsCodominating

  7.6-90 AddIsColiftable

  7.6-91 AddIsColiftableAlongEpimorphism

  7.6-92 AddIsCongruentForMorphisms

  7.6-93 AddIsDominating

  7.6-94 AddIsEndomorphism

  7.6-95 AddIsEpimorphism

  7.6-96 AddIsEqualAsFactorobjects

  7.6-97 AddIsEqualAsSubobjects

  7.6-98 AddIsEqualForCacheForMorphisms

  7.6-99 AddIsEqualForCacheForObjects

  7.6-100 AddIsEqualForMorphisms

  7.6-101 AddIsEqualForMorphismsOnMor

  7.6-102 AddIsEqualForObjects

  7.6-103 AddIsEqualToIdentityMorphism

  7.6-104 AddIsEqualToZeroMorphism

  7.6-105 AddIsHomSetInhabited

  7.6-106 AddIsIdempotent

  7.6-107 AddIsInitial

  7.6-108 AddIsInjective

  7.6-109 AddIsIsomorphicForObjects

  7.6-110 AddIsIsomorphism

  7.6-111 AddIsLiftable

  7.6-112 AddIsLiftableAlongMonomorphism

  7.6-113 AddIsMonomorphism

  7.6-114 AddIsOne

  7.6-115 AddIsProjective

  7.6-116 AddIsSplitEpimorphism

  7.6-117 AddIsSplitMonomorphism

  7.6-118 AddIsTerminal

  7.6-119 AddIsWellDefinedForMorphisms

  7.6-120 AddIsWellDefinedForMorphismsWithGivenSourceAndRange

  7.6-121 AddIsWellDefinedForObjects

  7.6-122 AddIsWellDefinedForTwoCells

  7.6-123 AddIsZeroForMorphisms

  7.6-124 AddIsZeroForObjects

  7.6-125 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout

  7.6-126 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct

  7.6-127 AddIsomorphismFromCoimageToCokernelOfKernel

  7.6-128 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer

  7.6-129 AddIsomorphismFromCokernelOfKernelToCoimage

  7.6-130 AddIsomorphismFromCoproductToDirectSum

  7.6-131 AddIsomorphismFromDirectProductToDirectSum

  7.6-132 AddIsomorphismFromDirectSumToCoproduct

  7.6-133 AddIsomorphismFromDirectSumToDirectProduct

  7.6-134 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct

  7.6-135 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct

  7.6-136 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram

  7.6-137 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject

  7.6-138 AddIsomorphismFromImageObjectToKernelOfCokernel

  7.6-139 AddIsomorphismFromInitialObjectToZeroObject

  7.6-140 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject

  7.6-141 AddIsomorphismFromKernelOfCokernelToImageObject

  7.6-142 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer

  7.6-143 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram

  7.6-144 AddIsomorphismFromTerminalObjectToZeroObject

  7.6-145 AddIsomorphismFromZeroObjectToInitialObject

  7.6-146 AddIsomorphismFromZeroObjectToTerminalObject

  7.6-147 AddJointPairwiseDifferencesOfMorphismsFromCoproduct

  7.6-148 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct

  7.6-149 AddKernelEmbedding

  7.6-150 AddKernelEmbeddingWithGivenKernelObject

  7.6-151 AddKernelLift

  7.6-152 AddKernelLiftWithGivenKernelObject

  7.6-153 AddKernelObject

  7.6-154 AddKernelObjectFunctorial

  7.6-155 AddKernelObjectFunctorialWithGivenKernelObjects

  7.6-156 AddLift

  7.6-157 AddLiftAlongMonomorphism

  7.6-158 AddLinearCombinationOfMorphisms

  7.6-159 AddMereExistenceOfSolutionOfLinearSystemInAbCategory

  7.6-160 AddMonomorphismIntoInjectiveEnvelopeObject

  7.6-161 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject

  7.6-162 AddMonomorphismIntoSomeInjectiveObject

  7.6-163 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject

  7.6-164 AddMorphismBetweenDirectSums

  7.6-165 AddMorphismBetweenDirectSumsWithGivenDirectSums

  7.6-166 AddMorphismConstructor

  7.6-167 AddMorphismDatum

  7.6-168 AddMorphismFromCoimageToImage

  7.6-169 AddMorphismFromCoimageToImageWithGivenObjects

  7.6-170 AddMorphismFromEqualizerToSink

  7.6-171 AddMorphismFromEqualizerToSinkWithGivenEqualizer

  7.6-172 AddMorphismFromFiberProductToSink

  7.6-173 AddMorphismFromFiberProductToSinkWithGivenFiberProduct

  7.6-174 AddMorphismFromKernelObjectToSink

  7.6-175 AddMorphismFromKernelObjectToSinkWithGivenKernelObject

  7.6-176 AddMorphismFromSourceToCoequalizer

  7.6-177 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer

  7.6-178 AddMorphismFromSourceToCokernelObject

  7.6-179 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject

  7.6-180 AddMorphismFromSourceToPushout

  7.6-181 AddMorphismFromSourceToPushoutWithGivenPushout

  7.6-182 AddMorphismsOfExternalHom

  7.6-183 AddMultiplyWithElementOfCommutativeRingForMorphisms

  7.6-184 AddObjectConstructor

  7.6-185 AddObjectDatum

  7.6-186 AddPostCompose

  7.6-187 AddPostComposeList

  7.6-188 AddPostInverseForMorphisms

  7.6-189 AddPreCompose

  7.6-190 AddPreComposeList

  7.6-191 AddPreInverseForMorphisms

  7.6-192 AddProjectionInFactorOfDirectProduct

  7.6-193 AddProjectionInFactorOfDirectProductWithGivenDirectProduct

  7.6-194 AddProjectionInFactorOfDirectSum

  7.6-195 AddProjectionInFactorOfDirectSumWithGivenDirectSum

  7.6-196 AddProjectionInFactorOfFiberProduct

  7.6-197 AddProjectionInFactorOfFiberProductWithGivenFiberProduct

  7.6-198 AddProjectionOntoCoequalizer

  7.6-199 AddProjectionOntoCoequalizerWithGivenCoequalizer

  7.6-200 AddProjectiveCoverObject

  7.6-201 AddProjectiveDimension

  7.6-202 AddProjectiveLift

  7.6-203 AddPushout

  7.6-204 AddPushoutFunctorial

  7.6-205 AddPushoutFunctorialWithGivenPushouts

  7.6-206 AddRandomMorphismByInteger

  7.6-207 AddRandomMorphismByList

  7.6-208 AddRandomMorphismWithFixedRangeByInteger

  7.6-209 AddRandomMorphismWithFixedRangeByList

  7.6-210 AddRandomMorphismWithFixedSourceAndRangeByInteger

  7.6-211 AddRandomMorphismWithFixedSourceAndRangeByList

  7.6-212 AddRandomMorphismWithFixedSourceByInteger

  7.6-213 AddRandomMorphismWithFixedSourceByList

  7.6-214 AddRandomObjectByInteger

  7.6-215 AddRandomObjectByList

  7.6-216 AddSimplifyEndo

  7.6-217 AddSimplifyEndo_IsoFromInputObject

  7.6-218 AddSimplifyEndo_IsoToInputObject

  7.6-219 AddSimplifyMorphism

  7.6-220 AddSimplifyObject

  7.6-221 AddSimplifyObject_IsoFromInputObject

  7.6-222 AddSimplifyObject_IsoToInputObject

  7.6-223 AddSimplifyRange

  7.6-224 AddSimplifyRange_IsoFromInputObject

  7.6-225 AddSimplifyRange_IsoToInputObject

  7.6-226 AddSimplifySource

  7.6-227 AddSimplifySourceAndRange

  7.6-228 AddSimplifySourceAndRange_IsoFromInputRange

  7.6-229 AddSimplifySourceAndRange_IsoFromInputSource

  7.6-230 AddSimplifySourceAndRange_IsoToInputRange

  7.6-231 AddSimplifySourceAndRange_IsoToInputSource

  7.6-232 AddSimplifySource_IsoFromInputObject

  7.6-233 AddSimplifySource_IsoToInputObject

  7.6-234 AddSolveLinearSystemInAbCategory

  7.6-235 AddSomeInjectiveObject

  7.6-236 AddSomeIsomorphismBetweenObjects

  7.6-237 AddSomeProjectiveObject

  7.6-238 AddSomeReductionBySplitEpiSummand

  7.6-239 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange

  7.6-240 AddSomeReductionBySplitEpiSummand_MorphismToInputRange

  7.6-241 AddSubtractionForMorphisms

  7.6-242 AddSumOfMorphisms

  7.6-243 AddTerminalObject

  7.6-244 AddTerminalObjectFunctorial

  7.6-245 AddTerminalObjectFunctorialWithGivenTerminalObjects

  7.6-246 AddUniversalMorphismFromCoequalizer

  7.6-247 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer

  7.6-248 AddUniversalMorphismFromCoproduct

  7.6-249 AddUniversalMorphismFromCoproductWithGivenCoproduct

  7.6-250 AddUniversalMorphismFromDirectSum

  7.6-251 AddUniversalMorphismFromDirectSumWithGivenDirectSum

  7.6-252 AddUniversalMorphismFromImage

  7.6-253 AddUniversalMorphismFromImageWithGivenImageObject

  7.6-254 AddUniversalMorphismFromInitialObject

  7.6-255 AddUniversalMorphismFromInitialObjectWithGivenInitialObject

  7.6-256 AddUniversalMorphismFromPushout

  7.6-257 AddUniversalMorphismFromPushoutWithGivenPushout

  7.6-258 AddUniversalMorphismFromZeroObject

  7.6-259 AddUniversalMorphismFromZeroObjectWithGivenZeroObject

  7.6-260 AddUniversalMorphismIntoCoimage

  7.6-261 AddUniversalMorphismIntoCoimageWithGivenCoimageObject

  7.6-262 AddUniversalMorphismIntoDirectProduct

  7.6-263 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct

  7.6-264 AddUniversalMorphismIntoDirectSum

  7.6-265 AddUniversalMorphismIntoDirectSumWithGivenDirectSum

  7.6-266 AddUniversalMorphismIntoEqualizer

  7.6-267 AddUniversalMorphismIntoEqualizerWithGivenEqualizer

  7.6-268 AddUniversalMorphismIntoFiberProduct

  7.6-269 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct

  7.6-270 AddUniversalMorphismIntoTerminalObject

  7.6-271 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject

  7.6-272 AddUniversalMorphismIntoZeroObject

  7.6-273 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject

  7.6-274 AddVerticalPostCompose

  7.6-275 AddVerticalPreCompose

  7.6-276 AddZeroMorphism

  7.6-277 AddZeroObject

  7.6-278 AddZeroObjectFunctorial

  7.6-279 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:

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

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:

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 Method name record entries

The entries of method name records can have the following components:

    [
        "filter_list",
        "input_arguments_names",
        "return_type",
        "output_source_getter_string",
        "output_source_getter_preconditions",
        "output_range_getter_string",
        "output_range_getter_preconditions",
        "with_given_object_position",
        "dual_operation",
        "dual_arguments_reversed",
        "dual_with_given_objects_reversed",
        "dual_preprocessor_func",
        "dual_preprocessor_func_string",
        "dual_postprocessor_func",
        "dual_postprocessor_func_string",
        "functorial",
        "compatible_with_congruence_of_morphisms",
        "redirect_function",
        "pre_function",
        "pre_function_full",
        "post_function",
    ]
    [
        "object",
        "morphism",
        "twocell",
        "object_in_range_category_of_homomorphism_structure",
        "morphism_in_range_category_of_homomorphism_structure",
        "bool",
        "list_of_objects",
        "list_of_morphisms",
        "list_of_lists_of_morphisms",
        "object_datum",
        "morphism_datum",
        "nonneg_integer_or_infinity",
        "list_of_elements_of_commutative_ring_of_linear_structure",
    ]

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:

7.5 Prepare functions

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

Returns: a function

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

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

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

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

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

Lists all prepare functions.

7.6 Available Add functions

7.6-1 AddAdditionForMorphisms
‣ AddAdditionForMorphisms( C, F )( operation )
‣ AddAdditionForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{AdditionForMorphisms}(alpha, beta)\).

7.6-2 AddAdditiveGenerators
‣ AddAdditiveGenerators( C, F )( operation )
‣ AddAdditiveGenerators( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{AdditiveGenerators}()\).

7.6-3 AddAdditiveInverseForMorphisms
‣ AddAdditiveInverseForMorphisms( C, F )( operation )
‣ AddAdditiveInverseForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{AdditiveInverseForMorphisms}(alpha)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{AstrictionToCoimage}(alpha)\).

7.6-5 AddAstrictionToCoimageWithGivenCoimageObject
‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F )( operation )
‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, C ) \mapsto \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C)\).

7.6-6 AddBasisOfExternalHom
‣ AddBasisOfExternalHom( C, F )( operation )
‣ AddBasisOfExternalHom( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{CoastrictionToImage}(alpha)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, I ) \mapsto \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I)\).

7.6-9 AddCoefficientsOfMorphism
‣ AddCoefficientsOfMorphism( C, F )( operation )
‣ AddCoefficientsOfMorphism( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation CoefficientsOfMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{CoefficientsOfMorphism}(arg2)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{Coequalizer}(Y, morphisms)\).

7.6-11 AddCoequalizerFunctorial
‣ AddCoequalizerFunctorial( C, F )( operation )
‣ AddCoequalizerFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp)\).

7.6-13 AddCoimageObject
‣ AddCoimageObject( C, F )( operation )
‣ AddCoimageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{CoimageObject}(arg2)\).

7.6-14 AddCoimageObjectFunctorial
‣ AddCoimageObjectFunctorial( C, F )( operation )
‣ AddCoimageObjectFunctorial( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation CoimageObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap)\).

7.6-15 AddCoimageObjectFunctorialWithGivenCoimageObjects
‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F )( operation )
‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation CoimageObjectFunctorialWithGivenCoimageObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( C, alpha, mu, alphap, Cp ) \mapsto \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C, alpha, mu, alphap, Cp)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{CoimageProjection}(alpha)\).

7.6-17 AddCoimageProjectionWithGivenCoimageObject
‣ AddCoimageProjectionWithGivenCoimageObject( C, F )( operation )
‣ AddCoimageProjectionWithGivenCoimageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, C ) \mapsto \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, T, tau ) \mapsto \mathtt{CokernelColift}(alpha, T, tau)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, T, tau, P ) \mapsto \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{CokernelObject}(alpha)\).

7.6-21 AddCokernelObjectFunctorial
‣ AddCokernelObjectFunctorial( C, F )( operation )
‣ AddCokernelObjectFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{CokernelProjection}(alpha)\).

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

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, P ) \mapsto \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P)\).

7.6-25 AddColift
‣ AddColift( C, F )( operation )
‣ AddColift( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta)\).

7.6-26 AddColiftAlongEpimorphism
‣ AddColiftAlongEpimorphism( C, F )( operation )
‣ AddColiftAlongEpimorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( epsilon, tau ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau)\).

7.6-27 AddComponentOfMorphismFromCoproduct
‣ AddComponentOfMorphismFromCoproduct( C, F )( operation )
‣ AddComponentOfMorphismFromCoproduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation ComponentOfMorphismFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, I, i ) \mapsto \mathtt{ComponentOfMorphismFromCoproduct}(alpha, I, i)\).

7.6-28 AddComponentOfMorphismFromDirectSum
‣ AddComponentOfMorphismFromDirectSum( C, F )( operation )
‣ AddComponentOfMorphismFromDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i)\).

7.6-29 AddComponentOfMorphismIntoDirectProduct
‣ AddComponentOfMorphismIntoDirectProduct( C, F )( operation )
‣ AddComponentOfMorphismIntoDirectProduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation ComponentOfMorphismIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, P, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectProduct}(alpha, P, i)\).

7.6-30 AddComponentOfMorphismIntoDirectSum
‣ AddComponentOfMorphismIntoDirectSum( C, F )( operation )
‣ AddComponentOfMorphismIntoDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i)\).

7.6-31 AddCoproduct
‣ AddCoproduct( C, F )( operation )
‣ AddCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects ) \mapsto \mathtt{Coproduct}(objects)\).

7.6-32 AddCoproductFunctorial
‣ AddCoproductFunctorial( C, F )( operation )
‣ AddCoproductFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp)\).

7.6-33 AddCoproductFunctorialWithGivenCoproducts
‣ AddCoproductFunctorialWithGivenCoproducts( C, F )( operation )
‣ AddCoproductFunctorialWithGivenCoproducts( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp)\).

7.6-34 AddDirectProduct
‣ AddDirectProduct( C, F )( operation )
‣ AddDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects ) \mapsto \mathtt{DirectProduct}(objects)\).

7.6-35 AddDirectProductFunctorial
‣ AddDirectProductFunctorial( C, F )( operation )
‣ AddDirectProductFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp)\).

7.6-36 AddDirectProductFunctorialWithGivenDirectProducts
‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F )( operation )
‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp)\).

7.6-37 AddDirectSum
‣ AddDirectSum( C, F )( operation )
‣ AddDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects ) \mapsto \mathtt{DirectSum}(objects)\).

7.6-38 AddDirectSumFunctorial
‣ AddDirectSumFunctorial( C, F )( operation )
‣ AddDirectSumFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp)\).

7.6-39 AddDirectSumFunctorialWithGivenDirectSums
‣ AddDirectSumFunctorialWithGivenDirectSums( C, F )( operation )
‣ AddDirectSumFunctorialWithGivenDirectSums( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp)\).

7.6-40 AddDistinguishedObjectOfHomomorphismStructure
‣ AddDistinguishedObjectOfHomomorphismStructure( C, F )( operation )
‣ AddDistinguishedObjectOfHomomorphismStructure( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}()\).

7.6-41 AddEmbeddingOfEqualizer
‣ AddEmbeddingOfEqualizer( C, F )( operation )
‣ AddEmbeddingOfEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms)\).

7.6-42 AddEmbeddingOfEqualizerWithGivenEqualizer
‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F )( operation )
‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P)\).

7.6-43 AddEpimorphismFromProjectiveCoverObject
‣ AddEpimorphismFromProjectiveCoverObject( C, F )( operation )
‣ AddEpimorphismFromProjectiveCoverObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation EpimorphismFromProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A)\).

7.6-44 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject
‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F )( operation )
‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P)\).

7.6-45 AddEpimorphismFromSomeProjectiveObject
‣ AddEpimorphismFromSomeProjectiveObject( C, F )( operation )
‣ AddEpimorphismFromSomeProjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A)\).

7.6-46 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F )( operation )
‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P)\).

7.6-47 AddEqualizer
‣ AddEqualizer( C, F )( operation )
‣ AddEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{Equalizer}(Y, morphisms)\).

7.6-48 AddEqualizerFunctorial
‣ AddEqualizerFunctorial( C, F )( operation )
‣ AddEqualizerFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp)\).

7.6-49 AddEqualizerFunctorialWithGivenEqualizers
‣ AddEqualizerFunctorialWithGivenEqualizers( C, F )( operation )
‣ AddEqualizerFunctorialWithGivenEqualizers( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp)\).

7.6-50 AddFiberProduct
‣ AddFiberProduct( C, F )( operation )
‣ AddFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms ) \mapsto \mathtt{FiberProduct}(morphisms)\).

7.6-51 AddFiberProductFunctorial
‣ AddFiberProductFunctorial( C, F )( operation )
‣ AddFiberProductFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp)\).

7.6-52 AddFiberProductFunctorialWithGivenFiberProducts
‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F )( operation )
‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp)\).

7.6-53 AddHomologyObject
‣ AddHomologyObject( C, F )( operation )
‣ AddHomologyObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{HomologyObject}(alpha, beta)\).

7.6-54 AddHomologyObjectFunctorialWithGivenHomologyObjects
‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F )( operation )
‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2)\).

7.6-55 AddHomomorphismStructureOnMorphisms
‣ AddHomomorphismStructureOnMorphisms( C, F )( operation )
‣ AddHomomorphismStructureOnMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta)\).

7.6-56 AddHomomorphismStructureOnMorphismsWithGivenObjects
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F )( operation )
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, alpha, beta, range ) \mapsto \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source, alpha, beta, range)\).

7.6-57 AddHomomorphismStructureOnObjects
‣ AddHomomorphismStructureOnObjects( C, F )( operation )
‣ AddHomomorphismStructureOnObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3)\).

7.6-58 AddHorizontalPostCompose
‣ AddHorizontalPostCompose( C, F )( operation )
‣ AddHorizontalPostCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3)\).

7.6-59 AddHorizontalPreCompose
‣ AddHorizontalPreCompose( C, F )( operation )
‣ AddHorizontalPreCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3)\).

7.6-60 AddIdentityMorphism
‣ AddIdentityMorphism( C, F )( operation )
‣ AddIdentityMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( a ) \mapsto \mathtt{IdentityMorphism}(a)\).

7.6-61 AddIdentityTwoCell
‣ AddIdentityTwoCell( C, F )( operation )
‣ AddIdentityTwoCell( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IdentityTwoCell}(arg2)\).

7.6-62 AddImageEmbedding
‣ AddImageEmbedding( C, F )( operation )
‣ AddImageEmbedding( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{ImageEmbedding}(alpha)\).

7.6-63 AddImageEmbeddingWithGivenImageObject
‣ AddImageEmbeddingWithGivenImageObject( C, F )( operation )
‣ AddImageEmbeddingWithGivenImageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, I ) \mapsto \mathtt{ImageEmbeddingWithGivenImageObject}(alpha, I)\).

7.6-64 AddImageObject
‣ AddImageObject( C, F )( operation )
‣ AddImageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{ImageObject}(arg2)\).

7.6-65 AddImageObjectFunctorial
‣ AddImageObjectFunctorial( C, F )( operation )
‣ AddImageObjectFunctorial( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation ImageObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, nu, alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap)\).

7.6-66 AddImageObjectFunctorialWithGivenImageObjects
‣ AddImageObjectFunctorialWithGivenImageObjects( C, F )( operation )
‣ AddImageObjectFunctorialWithGivenImageObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation ImageObjectFunctorialWithGivenImageObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip)\).

7.6-67 AddIndecomposableInjectiveObjects
‣ AddIndecomposableInjectiveObjects( C, F )( operation )
‣ AddIndecomposableInjectiveObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IndecomposableInjectiveObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IndecomposableInjectiveObjects}()\).

7.6-68 AddIndecomposableProjectiveObjects
‣ AddIndecomposableProjectiveObjects( C, F )( operation )
‣ AddIndecomposableProjectiveObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IndecomposableProjectiveObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IndecomposableProjectiveObjects}()\).

7.6-69 AddInitialObject
‣ AddInitialObject( C, F )( operation )
‣ AddInitialObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{InitialObject}()\).

7.6-70 AddInitialObjectFunctorial
‣ AddInitialObjectFunctorial( C, F )( operation )
‣ AddInitialObjectFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{InitialObjectFunctorial}()\).

7.6-71 AddInitialObjectFunctorialWithGivenInitialObjects
‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F )( operation )
‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp)\).

7.6-72 AddInjectionOfCofactorOfCoproduct
‣ AddInjectionOfCofactorOfCoproduct( C, F )( operation )
‣ AddInjectionOfCofactorOfCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k)\).

7.6-73 AddInjectionOfCofactorOfCoproductWithGivenCoproduct
‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F )( operation )
‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P)\).

7.6-74 AddInjectionOfCofactorOfDirectSum
‣ AddInjectionOfCofactorOfDirectSum( C, F )( operation )
‣ AddInjectionOfCofactorOfDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k)\).

7.6-75 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum
‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F )( operation )
‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P)\).

7.6-76 AddInjectionOfCofactorOfPushout
‣ AddInjectionOfCofactorOfPushout( C, F )( operation )
‣ AddInjectionOfCofactorOfPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k)\).

7.6-77 AddInjectionOfCofactorOfPushoutWithGivenPushout
‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F )( operation )
‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P)\).

7.6-78 AddInjectiveColift
‣ AddInjectiveColift( C, F )( operation )
‣ AddInjectiveColift( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{InjectiveColift}(alpha, beta)\).

7.6-79 AddInjectiveDimension
‣ AddInjectiveDimension( C, F )( operation )
‣ AddInjectiveDimension( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{InjectiveDimension}(arg2)\).

7.6-80 AddInjectiveEnvelopeObject
‣ AddInjectiveEnvelopeObject( C, F )( operation )
‣ AddInjectiveEnvelopeObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation InjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{InjectiveEnvelopeObject}(arg2)\).

7.6-81 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F )( operation )
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha)\).

7.6-82 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F )( operation )
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, alpha, range ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source, alpha, range)\).

7.6-83 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism
‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F )( operation )
‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, range, alpha ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source, range, alpha)\).

7.6-84 AddInverseForMorphisms
‣ AddInverseForMorphisms( C, F )( operation )
‣ AddInverseForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{InverseForMorphisms}(alpha)\).

7.6-85 AddInverseOfMorphismFromCoimageToImage
‣ AddInverseOfMorphismFromCoimageToImage( C, F )( operation )
‣ AddInverseOfMorphismFromCoimageToImage( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation InverseOfMorphismFromCoimageToImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImage}(alpha)\).

7.6-86 AddInverseOfMorphismFromCoimageToImageWithGivenObjects
‣ AddInverseOfMorphismFromCoimageToImageWithGivenObjects( C, F )( operation )
‣ AddInverseOfMorphismFromCoimageToImageWithGivenObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation InverseOfMorphismFromCoimageToImageWithGivenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( I, alpha, C ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImageWithGivenObjects}(I, alpha, C)\).

7.6-87 AddIsAutomorphism
‣ AddIsAutomorphism( C, F )( operation )
‣ AddIsAutomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsAutomorphism}(arg2)\).

7.6-88 AddIsBijectiveObject
‣ AddIsBijectiveObject( C, F )( operation )
‣ AddIsBijectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsBijectiveObject}(arg2)\).

7.6-89 AddIsCodominating
‣ AddIsCodominating( C, F )( operation )
‣ AddIsCodominating( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsCodominating}(arg2, arg3)\).

7.6-90 AddIsColiftable
‣ AddIsColiftable( C, F )( operation )
‣ AddIsColiftable( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftable}(arg2, arg3)\).

7.6-91 AddIsColiftableAlongEpimorphism
‣ AddIsColiftableAlongEpimorphism( C, F )( operation )
‣ AddIsColiftableAlongEpimorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3)\).

7.6-92 AddIsCongruentForMorphisms
‣ AddIsCongruentForMorphisms( C, F )( operation )
‣ AddIsCongruentForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsCongruentForMorphisms}(arg2, arg3)\).

7.6-93 AddIsDominating
‣ AddIsDominating( C, F )( operation )
‣ AddIsDominating( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsDominating}(arg2, arg3)\).

7.6-94 AddIsEndomorphism
‣ AddIsEndomorphism( C, F )( operation )
‣ AddIsEndomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsEndomorphism}(arg2)\).

7.6-95 AddIsEpimorphism
‣ AddIsEpimorphism( C, F )( operation )
‣ AddIsEpimorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsEpimorphism}(arg2)\).

7.6-96 AddIsEqualAsFactorobjects
‣ AddIsEqualAsFactorobjects( C, F )( operation )
‣ AddIsEqualAsFactorobjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsFactorobjects}(arg2, arg3)\).

7.6-97 AddIsEqualAsSubobjects
‣ AddIsEqualAsSubobjects( C, F )( operation )
‣ AddIsEqualAsSubobjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsSubobjects}(arg2, arg3)\).

7.6-98 AddIsEqualForCacheForMorphisms
‣ AddIsEqualForCacheForMorphisms( C, F )( operation )
‣ AddIsEqualForCacheForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3)\).

7.6-99 AddIsEqualForCacheForObjects
‣ AddIsEqualForCacheForObjects( C, F )( operation )
‣ AddIsEqualForCacheForObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3)\).

7.6-100 AddIsEqualForMorphisms
‣ AddIsEqualForMorphisms( C, F )( operation )
‣ AddIsEqualForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphisms}(arg2, arg3)\).

7.6-101 AddIsEqualForMorphismsOnMor
‣ AddIsEqualForMorphismsOnMor( C, F )( operation )
‣ AddIsEqualForMorphismsOnMor( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphismsOnMor}(arg2, arg3)\).

7.6-102 AddIsEqualForObjects
‣ AddIsEqualForObjects( C, F )( operation )
‣ AddIsEqualForObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForObjects}(arg2, arg3)\).

7.6-103 AddIsEqualToIdentityMorphism
‣ AddIsEqualToIdentityMorphism( C, F )( operation )
‣ AddIsEqualToIdentityMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsEqualToIdentityMorphism}(arg2)\).

7.6-104 AddIsEqualToZeroMorphism
‣ AddIsEqualToZeroMorphism( C, F )( operation )
‣ AddIsEqualToZeroMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsEqualToZeroMorphism}(arg2)\).

7.6-105 AddIsHomSetInhabited
‣ AddIsHomSetInhabited( C, F )( operation )
‣ AddIsHomSetInhabited( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsHomSetInhabited}(arg2, arg3)\).

7.6-106 AddIsIdempotent
‣ AddIsIdempotent( C, F )( operation )
‣ AddIsIdempotent( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsIdempotent}(arg2)\).

7.6-107 AddIsInitial
‣ AddIsInitial( C, F )( operation )
‣ AddIsInitial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsInitial}(arg2)\).

7.6-108 AddIsInjective
‣ AddIsInjective( C, F )( operation )
‣ AddIsInjective( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsInjective}(arg2)\).

7.6-109 AddIsIsomorphicForObjects
‣ AddIsIsomorphicForObjects( C, F )( operation )
‣ AddIsIsomorphicForObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsIsomorphicForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( object_1, object_2 ) \mapsto \mathtt{IsIsomorphicForObjects}(object_1, object_2)\).

7.6-110 AddIsIsomorphism
‣ AddIsIsomorphism( C, F )( operation )
‣ AddIsIsomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsIsomorphism}(arg2)\).

7.6-111 AddIsLiftable
‣ AddIsLiftable( C, F )( operation )
‣ AddIsLiftable( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftable}(arg2, arg3)\).

7.6-112 AddIsLiftableAlongMonomorphism
‣ AddIsLiftableAlongMonomorphism( C, F )( operation )
‣ AddIsLiftableAlongMonomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3)\).

7.6-113 AddIsMonomorphism
‣ AddIsMonomorphism( C, F )( operation )
‣ AddIsMonomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsMonomorphism}(arg2)\).

7.6-114 AddIsOne
‣ AddIsOne( C, F )( operation )
‣ AddIsOne( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsOne}(arg2)\).

7.6-115 AddIsProjective
‣ AddIsProjective( C, F )( operation )
‣ AddIsProjective( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsProjective}(arg2)\).

7.6-116 AddIsSplitEpimorphism
‣ AddIsSplitEpimorphism( C, F )( operation )
‣ AddIsSplitEpimorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsSplitEpimorphism}(arg2)\).

7.6-117 AddIsSplitMonomorphism
‣ AddIsSplitMonomorphism( C, F )( operation )
‣ AddIsSplitMonomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsSplitMonomorphism}(arg2)\).

7.6-118 AddIsTerminal
‣ AddIsTerminal( C, F )( operation )
‣ AddIsTerminal( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsTerminal}(arg2)\).

7.6-119 AddIsWellDefinedForMorphisms
‣ AddIsWellDefinedForMorphisms( C, F )( operation )
‣ AddIsWellDefinedForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{IsWellDefinedForMorphisms}(alpha)\).

7.6-120 AddIsWellDefinedForMorphismsWithGivenSourceAndRange
‣ AddIsWellDefinedForMorphismsWithGivenSourceAndRange( C, F )( operation )
‣ AddIsWellDefinedForMorphismsWithGivenSourceAndRange( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsWellDefinedForMorphismsWithGivenSourceAndRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, alpha, range ) \mapsto \mathtt{IsWellDefinedForMorphismsWithGivenSourceAndRange}(source, alpha, range)\).

7.6-121 AddIsWellDefinedForObjects
‣ AddIsWellDefinedForObjects( C, F )( operation )
‣ AddIsWellDefinedForObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForObjects}(arg2)\).

7.6-122 AddIsWellDefinedForTwoCells
‣ AddIsWellDefinedForTwoCells( C, F )( operation )
‣ AddIsWellDefinedForTwoCells( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForTwoCells}(arg2)\).

7.6-123 AddIsZeroForMorphisms
‣ AddIsZeroForMorphisms( C, F )( operation )
‣ AddIsZeroForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsZeroForMorphisms}(arg2)\).

7.6-124 AddIsZeroForObjects
‣ AddIsZeroForObjects( C, F )( operation )
‣ AddIsZeroForObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{IsZeroForObjects}(arg2)\).

7.6-125 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout
‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F )( operation )
‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D)\).

7.6-126 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct
‣ AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F )( operation )
‣ AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D)\).

7.6-127 AddIsomorphismFromCoimageToCokernelOfKernel
‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F )( operation )
‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{IsomorphismFromCoimageToCokernelOfKernel}(alpha)\).

7.6-128 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer
‣ AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( C, F )( operation )
‣ AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer}(A, D)\).

7.6-129 AddIsomorphismFromCokernelOfKernelToCoimage
‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F )( operation )
‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{IsomorphismFromCokernelOfKernelToCoimage}(alpha)\).

7.6-130 AddIsomorphismFromCoproductToDirectSum
‣ AddIsomorphismFromCoproductToDirectSum( C, F )( operation )
‣ AddIsomorphismFromCoproductToDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromCoproductToDirectSum}(D)\).

7.6-131 AddIsomorphismFromDirectProductToDirectSum
‣ AddIsomorphismFromDirectProductToDirectSum( C, F )( operation )
‣ AddIsomorphismFromDirectProductToDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromDirectProductToDirectSum}(D)\).

7.6-132 AddIsomorphismFromDirectSumToCoproduct
‣ AddIsomorphismFromDirectSumToCoproduct( C, F )( operation )
‣ AddIsomorphismFromDirectSumToCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToCoproduct}(D)\).

7.6-133 AddIsomorphismFromDirectSumToDirectProduct
‣ AddIsomorphismFromDirectSumToDirectProduct( C, F )( operation )
‣ AddIsomorphismFromDirectSumToDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToDirectProduct}(D)\).

7.6-134 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct
‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F )( operation )
‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D)\).

7.6-135 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct
‣ AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F )( operation )
‣ AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D)\).

7.6-136 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram
‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F )( operation )
‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D)\).

7.6-137 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject
‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F )( operation )
‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha, beta)\).

7.6-138 AddIsomorphismFromImageObjectToKernelOfCokernel
‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F )( operation )
‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{IsomorphismFromImageObjectToKernelOfCokernel}(alpha)\).

7.6-139 AddIsomorphismFromInitialObjectToZeroObject
‣ AddIsomorphismFromInitialObjectToZeroObject( C, F )( operation )
‣ AddIsomorphismFromInitialObjectToZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IsomorphismFromInitialObjectToZeroObject}()\).

7.6-140 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject
‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F )( operation )
‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha, beta)\).

7.6-141 AddIsomorphismFromKernelOfCokernelToImageObject
‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F )( operation )
‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{IsomorphismFromKernelOfCokernelToImageObject}(alpha)\).

7.6-142 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer
‣ AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( C, F )( operation )
‣ AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer}(A, D)\).

7.6-143 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram
‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F )( operation )
‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D)\).

7.6-144 AddIsomorphismFromTerminalObjectToZeroObject
‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F )( operation )
‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IsomorphismFromTerminalObjectToZeroObject}()\).

7.6-145 AddIsomorphismFromZeroObjectToInitialObject
‣ AddIsomorphismFromZeroObjectToInitialObject( C, F )( operation )
‣ AddIsomorphismFromZeroObjectToInitialObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToInitialObject}()\).

7.6-146 AddIsomorphismFromZeroObjectToTerminalObject
‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F )( operation )
‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToTerminalObject}()\).

7.6-147 AddJointPairwiseDifferencesOfMorphismsFromCoproduct
‣ AddJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F )( operation )
‣ AddJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation JointPairwiseDifferencesOfMorphismsFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D)\).

7.6-148 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct
‣ AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F )( operation )
‣ AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation JointPairwiseDifferencesOfMorphismsIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D)\).

7.6-149 AddKernelEmbedding
‣ AddKernelEmbedding( C, F )( operation )
‣ AddKernelEmbedding( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{KernelEmbedding}(alpha)\).

7.6-150 AddKernelEmbeddingWithGivenKernelObject
‣ AddKernelEmbeddingWithGivenKernelObject( C, F )( operation )
‣ AddKernelEmbeddingWithGivenKernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, P ) \mapsto \mathtt{KernelEmbeddingWithGivenKernelObject}(alpha, P)\).

7.6-151 AddKernelLift
‣ AddKernelLift( C, F )( operation )
‣ AddKernelLift( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, T, tau ) \mapsto \mathtt{KernelLift}(alpha, T, tau)\).

7.6-152 AddKernelLiftWithGivenKernelObject
‣ AddKernelLiftWithGivenKernelObject( C, F )( operation )
‣ AddKernelLiftWithGivenKernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, T, tau, P ) \mapsto \mathtt{KernelLiftWithGivenKernelObject}(alpha, T, tau, P)\).

7.6-153 AddKernelObject
‣ AddKernelObject( C, F )( operation )
‣ AddKernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{KernelObject}(alpha)\).

7.6-154 AddKernelObjectFunctorial
‣ AddKernelObjectFunctorial( C, F )( operation )
‣ AddKernelObjectFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, mu, alphap ) \mapsto \mathtt{KernelObjectFunctorial}(alpha, mu, alphap)\).

7.6-155 AddKernelObjectFunctorialWithGivenKernelObjects
‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F )( operation )
‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp)\).

7.6-156 AddLift
‣ AddLift( C, F )( operation )
‣ AddLift( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{Lift}(alpha, beta)\).

7.6-157 AddLiftAlongMonomorphism
‣ AddLiftAlongMonomorphism( C, F )( operation )
‣ AddLiftAlongMonomorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( iota, tau ) \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau)\).

7.6-158 AddLinearCombinationOfMorphisms
‣ AddLinearCombinationOfMorphisms( C, F )( operation )
‣ AddLinearCombinationOfMorphisms( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation LinearCombinationOfMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, list_of_ring_elements, list_of_morphisms, range ) \mapsto \mathtt{LinearCombinationOfMorphisms}(source, list_of_ring_elements, list_of_morphisms, range)\).

7.6-159 AddMereExistenceOfSolutionOfLinearSystemInAbCategory
‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F )( operation )
‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4)\).

7.6-160 AddMonomorphismIntoInjectiveEnvelopeObject
‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F )( operation )
‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObject}(A)\).

7.6-161 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject
‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F )( operation )
‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I)\).

7.6-162 AddMonomorphismIntoSomeInjectiveObject
‣ AddMonomorphismIntoSomeInjectiveObject( C, F )( operation )
‣ AddMonomorphismIntoSomeInjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObject}(A)\).

7.6-163 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject
‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F )( operation )
‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I)\).

7.6-164 AddMorphismBetweenDirectSums
‣ AddMorphismBetweenDirectSums( C, F )( operation )
‣ AddMorphismBetweenDirectSums( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram)\).

7.6-165 AddMorphismBetweenDirectSumsWithGivenDirectSums
‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F )( operation )
‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T)\).

7.6-166 AddMorphismConstructor
‣ AddMorphismConstructor( C, F )( operation )
‣ AddMorphismConstructor( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4)\).

7.6-167 AddMorphismDatum
‣ AddMorphismDatum( C, F )( operation )
‣ AddMorphismDatum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{MorphismDatum}(arg2)\).

7.6-168 AddMorphismFromCoimageToImage
‣ AddMorphismFromCoimageToImage( C, F )( operation )
‣ AddMorphismFromCoimageToImage( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MorphismFromCoimageToImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{MorphismFromCoimageToImage}(alpha)\).

7.6-169 AddMorphismFromCoimageToImageWithGivenObjects
‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F )( operation )
‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( C, alpha, I ) \mapsto \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I)\).

7.6-170 AddMorphismFromEqualizerToSink
‣ AddMorphismFromEqualizerToSink( C, F )( operation )
‣ AddMorphismFromEqualizerToSink( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms)\).

7.6-171 AddMorphismFromEqualizerToSinkWithGivenEqualizer
‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F )( operation )
‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P)\).

7.6-172 AddMorphismFromFiberProductToSink
‣ AddMorphismFromFiberProductToSink( C, F )( operation )
‣ AddMorphismFromFiberProductToSink( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms ) \mapsto \mathtt{MorphismFromFiberProductToSink}(morphisms)\).

7.6-173 AddMorphismFromFiberProductToSinkWithGivenFiberProduct
‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F )( operation )
‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P)\).

7.6-174 AddMorphismFromKernelObjectToSink
‣ AddMorphismFromKernelObjectToSink( C, F )( operation )
‣ AddMorphismFromKernelObjectToSink( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{MorphismFromKernelObjectToSink}(alpha)\).

7.6-175 AddMorphismFromKernelObjectToSinkWithGivenKernelObject
‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F )( operation )
‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, P ) \mapsto \mathtt{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P)\).

7.6-176 AddMorphismFromSourceToCoequalizer
‣ AddMorphismFromSourceToCoequalizer( C, F )( operation )
‣ AddMorphismFromSourceToCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms)\).

7.6-177 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer
‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F )( operation )
‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P)\).

7.6-178 AddMorphismFromSourceToCokernelObject
‣ AddMorphismFromSourceToCokernelObject( C, F )( operation )
‣ AddMorphismFromSourceToCokernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{MorphismFromSourceToCokernelObject}(alpha)\).

7.6-179 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject
‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F )( operation )
‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, P ) \mapsto \mathtt{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha, P)\).

7.6-180 AddMorphismFromSourceToPushout
‣ AddMorphismFromSourceToPushout( C, F )( operation )
‣ AddMorphismFromSourceToPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms ) \mapsto \mathtt{MorphismFromSourceToPushout}(morphisms)\).

7.6-181 AddMorphismFromSourceToPushoutWithGivenPushout
‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F )( operation )
‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P)\).

7.6-182 AddMorphismsOfExternalHom
‣ AddMorphismsOfExternalHom( C, F )( operation )
‣ AddMorphismsOfExternalHom( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MorphismsOfExternalHom. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{MorphismsOfExternalHom}(arg2, arg3)\).

7.6-183 AddMultiplyWithElementOfCommutativeRingForMorphisms
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F )( operation )
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( r, alpha ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, alpha)\).

7.6-184 AddObjectConstructor
‣ AddObjectConstructor( C, F )( operation )
‣ AddObjectConstructor( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{ObjectConstructor}(arg2)\).

7.6-185 AddObjectDatum
‣ AddObjectDatum( C, F )( operation )
‣ AddObjectDatum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{ObjectDatum}(arg2)\).

7.6-186 AddPostCompose
‣ AddPostCompose( C, F )( operation )
‣ AddPostCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( beta, alpha ) \mapsto \mathtt{PostCompose}(beta, alpha)\).

7.6-187 AddPostComposeList
‣ AddPostComposeList( C, F )( operation )
‣ AddPostComposeList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, list_of_morphisms, range ) \mapsto \mathtt{PostComposeList}(source, list_of_morphisms, range)\).

7.6-188 AddPostInverseForMorphisms
‣ AddPostInverseForMorphisms( C, F )( operation )
‣ AddPostInverseForMorphisms( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation PostInverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{PostInverseForMorphisms}(alpha)\).

7.6-189 AddPreCompose
‣ AddPreCompose( C, F )( operation )
‣ AddPreCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{PreCompose}(alpha, beta)\).

7.6-190 AddPreComposeList
‣ AddPreComposeList( C, F )( operation )
‣ AddPreComposeList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, list_of_morphisms, range ) \mapsto \mathtt{PreComposeList}(source, list_of_morphisms, range)\).

7.6-191 AddPreInverseForMorphisms
‣ AddPreInverseForMorphisms( C, F )( operation )
‣ AddPreInverseForMorphisms( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation PreInverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{PreInverseForMorphisms}(alpha)\).

7.6-192 AddProjectionInFactorOfDirectProduct
‣ AddProjectionInFactorOfDirectProduct( C, F )( operation )
‣ AddProjectionInFactorOfDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k)\).

7.6-193 AddProjectionInFactorOfDirectProductWithGivenDirectProduct
‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F )( operation )
‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k, P)\).

7.6-194 AddProjectionInFactorOfDirectSum
‣ AddProjectionInFactorOfDirectSum( C, F )( operation )
‣ AddProjectionInFactorOfDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k)\).

7.6-195 AddProjectionInFactorOfDirectSumWithGivenDirectSum
‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F )( operation )
‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P)\).

7.6-196 AddProjectionInFactorOfFiberProduct
‣ AddProjectionInFactorOfFiberProduct( C, F )( operation )
‣ AddProjectionInFactorOfFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k)\).

7.6-197 AddProjectionInFactorOfFiberProductWithGivenFiberProduct
‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F )( operation )
‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k, P)\).

7.6-198 AddProjectionOntoCoequalizer
‣ AddProjectionOntoCoequalizer( C, F )( operation )
‣ AddProjectionOntoCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms)\).

7.6-199 AddProjectionOntoCoequalizerWithGivenCoequalizer
‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F )( operation )
‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P)\).

7.6-200 AddProjectiveCoverObject
‣ AddProjectiveCoverObject( C, F )( operation )
‣ AddProjectiveCoverObject( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation ProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{ProjectiveCoverObject}(arg2)\).

7.6-201 AddProjectiveDimension
‣ AddProjectiveDimension( C, F )( operation )
‣ AddProjectiveDimension( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{ProjectiveDimension}(arg2)\).

7.6-202 AddProjectiveLift
‣ AddProjectiveLift( C, F )( operation )
‣ AddProjectiveLift( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{ProjectiveLift}(alpha, beta)\).

7.6-203 AddPushout
‣ AddPushout( C, F )( operation )
‣ AddPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms ) \mapsto \mathtt{Pushout}(morphisms)\).

7.6-204 AddPushoutFunctorial
‣ AddPushoutFunctorial( C, F )( operation )
‣ AddPushoutFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial}(morphisms, L, morphismsp)\).

7.6-205 AddPushoutFunctorialWithGivenPushouts
‣ AddPushoutFunctorialWithGivenPushouts( C, F )( operation )
‣ AddPushoutFunctorialWithGivenPushouts( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P, morphisms, L, morphismsp, Pp)\).

7.6-206 AddRandomMorphismByInteger
‣ AddRandomMorphismByInteger( C, F )( operation )
‣ AddRandomMorphismByInteger( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( n ) \mapsto \mathtt{RandomMorphismByInteger}(n)\).

7.6-207 AddRandomMorphismByList
‣ AddRandomMorphismByList( C, F )( operation )
‣ AddRandomMorphismByList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( L ) \mapsto \mathtt{RandomMorphismByList}(L)\).

7.6-208 AddRandomMorphismWithFixedRangeByInteger
‣ AddRandomMorphismWithFixedRangeByInteger( C, F )( operation )
‣ AddRandomMorphismWithFixedRangeByInteger( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n)\).

7.6-209 AddRandomMorphismWithFixedRangeByList
‣ AddRandomMorphismWithFixedRangeByList( C, F )( operation )
‣ AddRandomMorphismWithFixedRangeByList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( B, L ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L)\).

7.6-210 AddRandomMorphismWithFixedSourceAndRangeByInteger
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F )( operation )
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, B, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByInteger}(A, B, n)\).

7.6-211 AddRandomMorphismWithFixedSourceAndRangeByList
‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F )( operation )
‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, B, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByList}(A, B, L)\).

7.6-212 AddRandomMorphismWithFixedSourceByInteger
‣ AddRandomMorphismWithFixedSourceByInteger( C, F )( operation )
‣ AddRandomMorphismWithFixedSourceByInteger( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n)\).

7.6-213 AddRandomMorphismWithFixedSourceByList
‣ AddRandomMorphismWithFixedSourceByList( C, F )( operation )
‣ AddRandomMorphismWithFixedSourceByList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L)\).

7.6-214 AddRandomObjectByInteger
‣ AddRandomObjectByInteger( C, F )( operation )
‣ AddRandomObjectByInteger( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( n ) \mapsto \mathtt{RandomObjectByInteger}(n)\).

7.6-215 AddRandomObjectByList
‣ AddRandomObjectByList( C, F )( operation )
‣ AddRandomObjectByList( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( L ) \mapsto \mathtt{RandomObjectByList}(L)\).

7.6-216 AddSimplifyEndo
‣ AddSimplifyEndo( C, F )( operation )
‣ AddSimplifyEndo( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyEndo}(mor, n)\).

7.6-217 AddSimplifyEndo_IsoFromInputObject
‣ AddSimplifyEndo_IsoFromInputObject( C, F )( operation )
‣ AddSimplifyEndo_IsoFromInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n)\).

7.6-218 AddSimplifyEndo_IsoToInputObject
‣ AddSimplifyEndo_IsoToInputObject( C, F )( operation )
‣ AddSimplifyEndo_IsoToInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n)\).

7.6-219 AddSimplifyMorphism
‣ AddSimplifyMorphism( C, F )( operation )
‣ AddSimplifyMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n)\).

7.6-220 AddSimplifyObject
‣ AddSimplifyObject( C, F )( operation )
‣ AddSimplifyObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n)\).

7.6-221 AddSimplifyObject_IsoFromInputObject
‣ AddSimplifyObject_IsoFromInputObject( C, F )( operation )
‣ AddSimplifyObject_IsoFromInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n)\).

7.6-222 AddSimplifyObject_IsoToInputObject
‣ AddSimplifyObject_IsoToInputObject( C, F )( operation )
‣ AddSimplifyObject_IsoToInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n)\).

7.6-223 AddSimplifyRange
‣ AddSimplifyRange( C, F )( operation )
‣ AddSimplifyRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n)\).

7.6-224 AddSimplifyRange_IsoFromInputObject
‣ AddSimplifyRange_IsoFromInputObject( C, F )( operation )
‣ AddSimplifyRange_IsoFromInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n)\).

7.6-225 AddSimplifyRange_IsoToInputObject
‣ AddSimplifyRange_IsoToInputObject( C, F )( operation )
‣ AddSimplifyRange_IsoToInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n)\).

7.6-226 AddSimplifySource
‣ AddSimplifySource( C, F )( operation )
‣ AddSimplifySource( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n)\).

7.6-227 AddSimplifySourceAndRange
‣ AddSimplifySourceAndRange( C, F )( operation )
‣ AddSimplifySourceAndRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange}(mor, n)\).

7.6-228 AddSimplifySourceAndRange_IsoFromInputRange
‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F )( operation )
‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor, n)\).

7.6-229 AddSimplifySourceAndRange_IsoFromInputSource
‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F )( operation )
‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n)\).

7.6-230 AddSimplifySourceAndRange_IsoToInputRange
‣ AddSimplifySourceAndRange_IsoToInputRange( C, F )( operation )
‣ AddSimplifySourceAndRange_IsoToInputRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor, n)\).

7.6-231 AddSimplifySourceAndRange_IsoToInputSource
‣ AddSimplifySourceAndRange_IsoToInputSource( C, F )( operation )
‣ AddSimplifySourceAndRange_IsoToInputSource( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n)\).

7.6-232 AddSimplifySource_IsoFromInputObject
‣ AddSimplifySource_IsoFromInputObject( C, F )( operation )
‣ AddSimplifySource_IsoFromInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n)\).

7.6-233 AddSimplifySource_IsoToInputObject
‣ AddSimplifySource_IsoToInputObject( C, F )( operation )
‣ AddSimplifySource_IsoToInputObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n)\).

7.6-234 AddSolveLinearSystemInAbCategory
‣ AddSolveLinearSystemInAbCategory( C, F )( operation )
‣ AddSolveLinearSystemInAbCategory( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4)\).

7.6-235 AddSomeInjectiveObject
‣ AddSomeInjectiveObject( C, F )( operation )
‣ AddSomeInjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{SomeInjectiveObject}(arg2)\).

7.6-236 AddSomeIsomorphismBetweenObjects
‣ AddSomeIsomorphismBetweenObjects( C, F )( operation )
‣ AddSomeIsomorphismBetweenObjects( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation SomeIsomorphismBetweenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( object_1, object_2 ) \mapsto \mathtt{SomeIsomorphismBetweenObjects}(object_1, object_2)\).

7.6-237 AddSomeProjectiveObject
‣ AddSomeProjectiveObject( C, F )( operation )
‣ AddSomeProjectiveObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2 ) \mapsto \mathtt{SomeProjectiveObject}(arg2)\).

7.6-238 AddSomeReductionBySplitEpiSummand
‣ AddSomeReductionBySplitEpiSummand( C, F )( operation )
‣ AddSomeReductionBySplitEpiSummand( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand}(alpha)\).

7.6-239 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange
‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F )( operation )
‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismFromInputRange}(alpha)\).

7.6-240 AddSomeReductionBySplitEpiSummand_MorphismToInputRange
‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F )( operation )
‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha)\).

7.6-241 AddSubtractionForMorphisms
‣ AddSubtractionForMorphisms( C, F )( operation )
‣ AddSubtractionForMorphisms( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, beta ) \mapsto \mathtt{SubtractionForMorphisms}(alpha, beta)\).

7.6-242 AddSumOfMorphisms
‣ AddSumOfMorphisms( C, F )( operation )
‣ AddSumOfMorphisms( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation SumOfMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range)\).

7.6-243 AddTerminalObject
‣ AddTerminalObject( C, F )( operation )
‣ AddTerminalObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{TerminalObject}()\).

7.6-244 AddTerminalObjectFunctorial
‣ AddTerminalObjectFunctorial( C, F )( operation )
‣ AddTerminalObjectFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{TerminalObjectFunctorial}()\).

7.6-245 AddTerminalObjectFunctorialWithGivenTerminalObjects
‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F )( operation )
‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp)\).

7.6-246 AddUniversalMorphismFromCoequalizer
‣ AddUniversalMorphismFromCoequalizer( C, F )( operation )
‣ AddUniversalMorphismFromCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau)\).

7.6-247 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer
‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F )( operation )
‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y, morphisms, T, tau, P)\).

7.6-248 AddUniversalMorphismFromCoproduct
‣ AddUniversalMorphismFromCoproduct( C, F )( operation )
‣ AddUniversalMorphismFromCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau)\).

7.6-249 AddUniversalMorphismFromCoproductWithGivenCoproduct
‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F )( operation )
‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P)\).

7.6-250 AddUniversalMorphismFromDirectSum
‣ AddUniversalMorphismFromDirectSum( C, F )( operation )
‣ AddUniversalMorphismFromDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau)\).

7.6-251 AddUniversalMorphismFromDirectSumWithGivenDirectSum
‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F )( operation )
‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P)\).

7.6-252 AddUniversalMorphismFromImage
‣ AddUniversalMorphismFromImage( C, F )( operation )
‣ AddUniversalMorphismFromImage( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismFromImage}(alpha, tau)\).

7.6-253 AddUniversalMorphismFromImageWithGivenImageObject
‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F )( operation )
‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, tau, I ) \mapsto \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I)\).

7.6-254 AddUniversalMorphismFromInitialObject
‣ AddUniversalMorphismFromInitialObject( C, F )( operation )
‣ AddUniversalMorphismFromInitialObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T ) \mapsto \mathtt{UniversalMorphismFromInitialObject}(T)\).

7.6-255 AddUniversalMorphismFromInitialObjectWithGivenInitialObject
‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F )( operation )
‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P)\).

7.6-256 AddUniversalMorphismFromPushout
‣ AddUniversalMorphismFromPushout( C, F )( operation )
‣ AddUniversalMorphismFromPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau)\).

7.6-257 AddUniversalMorphismFromPushoutWithGivenPushout
‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F )( operation )
‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P)\).

7.6-258 AddUniversalMorphismFromZeroObject
‣ AddUniversalMorphismFromZeroObject( C, F )( operation )
‣ AddUniversalMorphismFromZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T ) \mapsto \mathtt{UniversalMorphismFromZeroObject}(T)\).

7.6-259 AddUniversalMorphismFromZeroObjectWithGivenZeroObject
‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F )( operation )
‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P)\).

7.6-260 AddUniversalMorphismIntoCoimage
‣ AddUniversalMorphismIntoCoimage( C, F )( operation )
‣ AddUniversalMorphismIntoCoimage( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismIntoCoimage}(alpha, tau)\).

7.6-261 AddUniversalMorphismIntoCoimageWithGivenCoimageObject
‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F )( operation )
‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( alpha, tau, C ) \mapsto \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C)\).

7.6-262 AddUniversalMorphismIntoDirectProduct
‣ AddUniversalMorphismIntoDirectProduct( C, F )( operation )
‣ AddUniversalMorphismIntoDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau)\).

7.6-263 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct
‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F )( operation )
‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P)\).

7.6-264 AddUniversalMorphismIntoDirectSum
‣ AddUniversalMorphismIntoDirectSum( C, F )( operation )
‣ AddUniversalMorphismIntoDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau)\).

7.6-265 AddUniversalMorphismIntoDirectSumWithGivenDirectSum
‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F )( operation )
‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P)\).

7.6-266 AddUniversalMorphismIntoEqualizer
‣ AddUniversalMorphismIntoEqualizer( C, F )( operation )
‣ AddUniversalMorphismIntoEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau)\).

7.6-267 AddUniversalMorphismIntoEqualizerWithGivenEqualizer
‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F )( operation )
‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P)\).

7.6-268 AddUniversalMorphismIntoFiberProduct
‣ AddUniversalMorphismIntoFiberProduct( C, F )( operation )
‣ AddUniversalMorphismIntoFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau)\).

7.6-269 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct
‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F )( operation )
‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P)\).

7.6-270 AddUniversalMorphismIntoTerminalObject
‣ AddUniversalMorphismIntoTerminalObject( C, F )( operation )
‣ AddUniversalMorphismIntoTerminalObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T ) \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T)\).

7.6-271 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject
‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F )( operation )
‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P)\).

7.6-272 AddUniversalMorphismIntoZeroObject
‣ AddUniversalMorphismIntoZeroObject( C, F )( operation )
‣ AddUniversalMorphismIntoZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T ) \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T)\).

7.6-273 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject
‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F )( operation )
‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P)\).

7.6-274 AddVerticalPostCompose
‣ AddVerticalPostCompose( C, F )( operation )
‣ AddVerticalPostCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPostCompose}(arg2, arg3)\).

7.6-275 AddVerticalPreCompose
‣ AddVerticalPreCompose( C, F )( operation )
‣ AddVerticalPreCompose( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPreCompose}(arg2, arg3)\).

7.6-276 AddZeroMorphism
‣ AddZeroMorphism( C, F )( operation )
‣ AddZeroMorphism( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( a, b ) \mapsto \mathtt{ZeroMorphism}(a, b)\).

7.6-277 AddZeroObject
‣ AddZeroObject( C, F )( operation )
‣ AddZeroObject( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{ZeroObject}()\).

7.6-278 AddZeroObjectFunctorial
‣ AddZeroObjectFunctorial( C, F )( operation )
‣ AddZeroObjectFunctorial( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( ) \mapsto \mathtt{ZeroObjectFunctorial}()\).

7.6-279 AddZeroObjectFunctorialWithGivenZeroObjects
‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F )( operation )
‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F, weight )( operation )

Returns: nothing

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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). \(F: ( P, Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P, Pp)\).

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

generated by GAPDoc2HTML