Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 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 AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory

  7.6-8 AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory

  7.6-9 AddCoastrictionToImage

  7.6-10 AddCoastrictionToImageWithGivenImageObject

  7.6-11 AddCoefficientsOfMorphism

  7.6-12 AddCoequalizer

  7.6-13 AddCoequalizerFunctorial

  7.6-14 AddCoequalizerFunctorialWithGivenCoequalizers

  7.6-15 AddCoimageObject

  7.6-16 AddCoimageObjectFunctorial

  7.6-17 AddCoimageObjectFunctorialWithGivenCoimageObjects

  7.6-18 AddCoimageProjection

  7.6-19 AddCoimageProjectionWithGivenCoimageObject

  7.6-20 AddCokernelColift

  7.6-21 AddCokernelColiftWithGivenCokernelObject

  7.6-22 AddCokernelObject

  7.6-23 AddCokernelObjectFunctorial

  7.6-24 AddCokernelObjectFunctorialWithGivenCokernelObjects

  7.6-25 AddCokernelProjection

  7.6-26 AddCokernelProjectionWithGivenCokernelObject

  7.6-27 AddColift

  7.6-28 AddColiftAlongEpimorphism

  7.6-29 AddComponentOfMorphismFromCoproduct

  7.6-30 AddComponentOfMorphismFromDirectSum

  7.6-31 AddComponentOfMorphismIntoDirectProduct

  7.6-32 AddComponentOfMorphismIntoDirectSum

  7.6-33 AddCoproduct

  7.6-34 AddCoproductFunctorial

  7.6-35 AddCoproductFunctorialWithGivenCoproducts

  7.6-36 AddDirectProduct

  7.6-37 AddDirectProductFunctorial

  7.6-38 AddDirectProductFunctorialWithGivenDirectProducts

  7.6-39 AddDirectSum

  7.6-40 AddDirectSumFunctorial

  7.6-41 AddDirectSumFunctorialWithGivenDirectSums

  7.6-42 AddDistinguishedObjectOfHomomorphismStructure

  7.6-43 AddEmbeddingOfEqualizer

  7.6-44 AddEmbeddingOfEqualizerWithGivenEqualizer

  7.6-45 AddEpimorphismFromProjectiveCoverObject

  7.6-46 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject

  7.6-47 AddEpimorphismFromSomeProjectiveObject

  7.6-48 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject

  7.6-49 AddEqualizer

  7.6-50 AddEqualizerFunctorial

  7.6-51 AddEqualizerFunctorialWithGivenEqualizers

  7.6-52 AddFiberProduct

  7.6-53 AddFiberProductFunctorial

  7.6-54 AddFiberProductFunctorialWithGivenFiberProducts

  7.6-55 AddHomologyObject

  7.6-56 AddHomologyObjectFunctorialWithGivenHomologyObjects

  7.6-57 AddHomomorphismStructureOnMorphisms

  7.6-58 AddHomomorphismStructureOnMorphismsWithGivenObjects

  7.6-59 AddHomomorphismStructureOnObjects

  7.6-60 AddHorizontalPostCompose

  7.6-61 AddHorizontalPreCompose

  7.6-62 AddIdentityMorphism

  7.6-63 AddIdentityTwoCell

  7.6-64 AddImageEmbedding

  7.6-65 AddImageEmbeddingWithGivenImageObject

  7.6-66 AddImageObject

  7.6-67 AddImageObjectFunctorial

  7.6-68 AddImageObjectFunctorialWithGivenImageObjects

  7.6-69 AddIndecomposableInjectiveObjects

  7.6-70 AddIndecomposableProjectiveObjects

  7.6-71 AddInitialObject

  7.6-72 AddInitialObjectFunctorial

  7.6-73 AddInitialObjectFunctorialWithGivenInitialObjects

  7.6-74 AddInjectionOfCofactorOfCoproduct

  7.6-75 AddInjectionOfCofactorOfCoproductWithGivenCoproduct

  7.6-76 AddInjectionOfCofactorOfDirectSum

  7.6-77 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum

  7.6-78 AddInjectionOfCofactorOfPushout

  7.6-79 AddInjectionOfCofactorOfPushoutWithGivenPushout

  7.6-80 AddInjectiveColift

  7.6-81 AddInjectiveDimension

  7.6-82 AddInjectiveEnvelopeObject

  7.6-83 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure

  7.6-84 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects

  7.6-85 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism

  7.6-86 AddInverseForMorphisms

  7.6-87 AddInverseOfMorphismFromCoimageToImage

  7.6-88 AddInverseOfMorphismFromCoimageToImageWithGivenObjects

  7.6-89 AddIsAutomorphism

  7.6-90 AddIsBijectiveObject

  7.6-91 AddIsCodominating

  7.6-92 AddIsColiftable

  7.6-93 AddIsColiftableAlongEpimorphism

  7.6-94 AddIsCongruentForMorphisms

  7.6-95 AddIsDominating

  7.6-96 AddIsEndomorphism

  7.6-97 AddIsEpimorphism

  7.6-98 AddIsEqualAsFactorobjects

  7.6-99 AddIsEqualAsSubobjects

  7.6-100 AddIsEqualForCacheForMorphisms

  7.6-101 AddIsEqualForCacheForObjects

  7.6-102 AddIsEqualForMorphisms

  7.6-103 AddIsEqualForMorphismsOnMor

  7.6-104 AddIsEqualForObjects

  7.6-105 AddIsEqualToIdentityMorphism

  7.6-106 AddIsEqualToZeroMorphism

  7.6-107 AddIsHomSetInhabited

  7.6-108 AddIsIdempotent

  7.6-109 AddIsInitial

  7.6-110 AddIsInjective

  7.6-111 AddIsIsomorphicForObjects

  7.6-112 AddIsIsomorphism

  7.6-113 AddIsLiftable

  7.6-114 AddIsLiftableAlongMonomorphism

  7.6-115 AddIsMonomorphism

  7.6-116 AddIsOne

  7.6-117 AddIsProjective

  7.6-118 AddIsSplitEpimorphism

  7.6-119 AddIsSplitMonomorphism

  7.6-120 AddIsTerminal

  7.6-121 AddIsWellDefinedForMorphisms

  7.6-122 AddIsWellDefinedForMorphismsWithGivenSourceAndRange

  7.6-123 AddIsWellDefinedForObjects

  7.6-124 AddIsWellDefinedForTwoCells

  7.6-125 AddIsZeroForMorphisms

  7.6-126 AddIsZeroForObjects

  7.6-127 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout

  7.6-128 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct

  7.6-129 AddIsomorphismFromCoimageToCokernelOfKernel

  7.6-130 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer

  7.6-131 AddIsomorphismFromCokernelOfKernelToCoimage

  7.6-132 AddIsomorphismFromCoproductToDirectSum

  7.6-133 AddIsomorphismFromDirectProductToDirectSum

  7.6-134 AddIsomorphismFromDirectSumToCoproduct

  7.6-135 AddIsomorphismFromDirectSumToDirectProduct

  7.6-136 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct

  7.6-137 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct

  7.6-138 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram

  7.6-139 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject

  7.6-140 AddIsomorphismFromImageObjectToKernelOfCokernel

  7.6-141 AddIsomorphismFromInitialObjectToZeroObject

  7.6-142 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject

  7.6-143 AddIsomorphismFromKernelOfCokernelToImageObject

  7.6-144 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer

  7.6-145 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram

  7.6-146 AddIsomorphismFromTerminalObjectToZeroObject

  7.6-147 AddIsomorphismFromZeroObjectToInitialObject

  7.6-148 AddIsomorphismFromZeroObjectToTerminalObject

  7.6-149 AddJointPairwiseDifferencesOfMorphismsFromCoproduct

  7.6-150 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct

  7.6-151 AddKernelEmbedding

  7.6-152 AddKernelEmbeddingWithGivenKernelObject

  7.6-153 AddKernelLift

  7.6-154 AddKernelLiftWithGivenKernelObject

  7.6-155 AddKernelObject

  7.6-156 AddKernelObjectFunctorial

  7.6-157 AddKernelObjectFunctorialWithGivenKernelObjects

  7.6-158 AddLift

  7.6-159 AddLiftAlongMonomorphism

  7.6-160 AddLinearCombinationOfMorphisms

  7.6-161 AddMereExistenceOfSolutionOfLinearSystemInAbCategory

  7.6-162 AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory

  7.6-163 AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory

  7.6-164 AddMonomorphismIntoInjectiveEnvelopeObject

  7.6-165 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject

  7.6-166 AddMonomorphismIntoSomeInjectiveObject

  7.6-167 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject

  7.6-168 AddMorphismBetweenDirectSums

  7.6-169 AddMorphismBetweenDirectSumsWithGivenDirectSums

  7.6-170 AddMorphismConstructor

  7.6-171 AddMorphismDatum

  7.6-172 AddMorphismFromCoimageToImage

  7.6-173 AddMorphismFromCoimageToImageWithGivenObjects

  7.6-174 AddMorphismFromEqualizerToSink

  7.6-175 AddMorphismFromEqualizerToSinkWithGivenEqualizer

  7.6-176 AddMorphismFromFiberProductToSink

  7.6-177 AddMorphismFromFiberProductToSinkWithGivenFiberProduct

  7.6-178 AddMorphismFromKernelObjectToSink

  7.6-179 AddMorphismFromKernelObjectToSinkWithGivenKernelObject

  7.6-180 AddMorphismFromSourceToCoequalizer

  7.6-181 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer

  7.6-182 AddMorphismFromSourceToCokernelObject

  7.6-183 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject

  7.6-184 AddMorphismFromSourceToPushout

  7.6-185 AddMorphismFromSourceToPushoutWithGivenPushout

  7.6-186 AddMorphismsOfExternalHom

  7.6-187 AddMultiplyWithElementOfCommutativeRingForMorphisms

  7.6-188 AddObjectConstructor

  7.6-189 AddObjectDatum

  7.6-190 AddPostCompose

  7.6-191 AddPostComposeList

  7.6-192 AddPostInverseForMorphisms

  7.6-193 AddPreCompose

  7.6-194 AddPreComposeList

  7.6-195 AddPreInverseForMorphisms

  7.6-196 AddProjectionInFactorOfDirectProduct

  7.6-197 AddProjectionInFactorOfDirectProductWithGivenDirectProduct

  7.6-198 AddProjectionInFactorOfDirectSum

  7.6-199 AddProjectionInFactorOfDirectSumWithGivenDirectSum

  7.6-200 AddProjectionInFactorOfFiberProduct

  7.6-201 AddProjectionInFactorOfFiberProductWithGivenFiberProduct

  7.6-202 AddProjectionOntoCoequalizer

  7.6-203 AddProjectionOntoCoequalizerWithGivenCoequalizer

  7.6-204 AddProjectiveCoverObject

  7.6-205 AddProjectiveDimension

  7.6-206 AddProjectiveLift

  7.6-207 AddPushout

  7.6-208 AddPushoutFunctorial

  7.6-209 AddPushoutFunctorialWithGivenPushouts

  7.6-210 AddRandomMorphismByInteger

  7.6-211 AddRandomMorphismByList

  7.6-212 AddRandomMorphismWithFixedRangeByInteger

  7.6-213 AddRandomMorphismWithFixedRangeByList

  7.6-214 AddRandomMorphismWithFixedSourceAndRangeByInteger

  7.6-215 AddRandomMorphismWithFixedSourceAndRangeByList

  7.6-216 AddRandomMorphismWithFixedSourceByInteger

  7.6-217 AddRandomMorphismWithFixedSourceByList

  7.6-218 AddRandomObjectByInteger

  7.6-219 AddRandomObjectByList

  7.6-220 AddSetOfMorphismsOfFiniteCategory

  7.6-221 AddSetOfObjectsOfCategory

  7.6-222 AddSimplifyEndo

  7.6-223 AddSimplifyEndo_IsoFromInputObject

  7.6-224 AddSimplifyEndo_IsoToInputObject

  7.6-225 AddSimplifyMorphism

  7.6-226 AddSimplifyObject

  7.6-227 AddSimplifyObject_IsoFromInputObject

  7.6-228 AddSimplifyObject_IsoToInputObject

  7.6-229 AddSimplifyRange

  7.6-230 AddSimplifyRange_IsoFromInputObject

  7.6-231 AddSimplifyRange_IsoToInputObject

  7.6-232 AddSimplifySource

  7.6-233 AddSimplifySourceAndRange

  7.6-234 AddSimplifySourceAndRange_IsoFromInputRange

  7.6-235 AddSimplifySourceAndRange_IsoFromInputSource

  7.6-236 AddSimplifySourceAndRange_IsoToInputRange

  7.6-237 AddSimplifySourceAndRange_IsoToInputSource

  7.6-238 AddSimplifySource_IsoFromInputObject

  7.6-239 AddSimplifySource_IsoToInputObject

  7.6-240 AddSolveLinearSystemInAbCategory

  7.6-241 AddSomeInjectiveObject

  7.6-242 AddSomeIsomorphismBetweenObjects

  7.6-243 AddSomeProjectiveObject

  7.6-244 AddSomeReductionBySplitEpiSummand

  7.6-245 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange

  7.6-246 AddSomeReductionBySplitEpiSummand_MorphismToInputRange

  7.6-247 AddSubtractionForMorphisms

  7.6-248 AddSumOfMorphisms

  7.6-249 AddTerminalObject

  7.6-250 AddTerminalObjectFunctorial

  7.6-251 AddTerminalObjectFunctorialWithGivenTerminalObjects

  7.6-252 AddUniversalMorphismFromCoequalizer

  7.6-253 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer

  7.6-254 AddUniversalMorphismFromCoproduct

  7.6-255 AddUniversalMorphismFromCoproductWithGivenCoproduct

  7.6-256 AddUniversalMorphismFromDirectSum

  7.6-257 AddUniversalMorphismFromDirectSumWithGivenDirectSum

  7.6-258 AddUniversalMorphismFromImage

  7.6-259 AddUniversalMorphismFromImageWithGivenImageObject

  7.6-260 AddUniversalMorphismFromInitialObject

  7.6-261 AddUniversalMorphismFromInitialObjectWithGivenInitialObject

  7.6-262 AddUniversalMorphismFromPushout

  7.6-263 AddUniversalMorphismFromPushoutWithGivenPushout

  7.6-264 AddUniversalMorphismFromZeroObject

  7.6-265 AddUniversalMorphismFromZeroObjectWithGivenZeroObject

  7.6-266 AddUniversalMorphismIntoCoimage

  7.6-267 AddUniversalMorphismIntoCoimageWithGivenCoimageObject

  7.6-268 AddUniversalMorphismIntoDirectProduct

  7.6-269 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct

  7.6-270 AddUniversalMorphismIntoDirectSum

  7.6-271 AddUniversalMorphismIntoDirectSumWithGivenDirectSum

  7.6-272 AddUniversalMorphismIntoEqualizer

  7.6-273 AddUniversalMorphismIntoEqualizerWithGivenEqualizer

  7.6-274 AddUniversalMorphismIntoFiberProduct

  7.6-275 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct

  7.6-276 AddUniversalMorphismIntoTerminalObject

  7.6-277 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject

  7.6-278 AddUniversalMorphismIntoZeroObject

  7.6-279 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject

  7.6-280 AddVerticalPostCompose

  7.6-281 AddVerticalPreCompose

  7.6-282 AddZeroMorphism

  7.6-283 AddZeroObject

  7.6-284 AddZeroObjectFunctorial

  7.6-285 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 AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory
‣ AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( C, F )( operation )
‣ AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory. Optionally, a 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, arg5 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2, arg3, arg4, arg5)\).

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

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory. Optionally, a 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{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2, arg3)\).

7.6-9 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-10 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-11 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-12 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-13 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-14 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-15 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-16 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-17 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-18 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-19 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-20 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-21 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-22 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-23 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-24 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-25 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-26 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-27 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-28 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-29 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-30 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-31 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-32 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-33 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-34 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-35 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-36 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-37 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-38 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-39 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-40 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-41 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-42 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-43 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-44 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-45 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-46 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-47 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-48 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-49 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-50 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-51 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-52 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-53 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-54 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-55 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-56 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-57 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-58 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-59 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-60 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-61 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-62 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-63 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-64 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-65 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-66 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-67 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-68 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-69 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-70 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-71 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-72 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-73 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-74 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-75 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-76 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-77 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-78 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-79 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-80 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-81 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-82 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-83 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-84 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-85 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-86 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-87 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-88 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-89 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-90 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-91 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-92 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-93 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-94 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-95 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-96 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-97 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-98 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-99 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-100 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-101 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-102 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-103 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-104 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-105 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-106 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-107 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-108 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-109 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-110 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-111 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-112 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-113 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-114 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-115 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-116 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-117 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-118 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-119 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-120 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-121 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-122 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-123 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-124 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-125 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-126 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-127 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-128 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-129 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-130 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-131 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-132 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-133 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-134 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-135 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-136 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-137 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-138 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-139 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-140 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-141 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-142 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-143 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-144 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-145 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-146 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-147 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-148 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-149 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-150 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-151 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-152 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-153 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-154 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-155 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-156 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-157 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-158 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-159 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-160 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-161 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-162 AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory
‣ AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( C, F )( operation )
‣ AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory. Optionally, a 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{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2, arg3)\).

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

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory. Optionally, a 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{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4)\).

7.6-164 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-165 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-166 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-167 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-168 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-169 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-170 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-171 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-172 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-173 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-174 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-175 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-176 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-177 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-178 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-179 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-180 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-181 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-182 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-183 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-184 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-185 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-186 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-187 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-188 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-189 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-190 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-191 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-192 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-193 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-194 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-195 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-196 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-197 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-198 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-199 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-200 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-201 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-202 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-203 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-204 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-205 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-206 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-207 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-208 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-209 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-210 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-211 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-212 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-213 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-214 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-215 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-216 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-217 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-218 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-219 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-220 AddSetOfMorphismsOfFiniteCategory
‣ AddSetOfMorphismsOfFiniteCategory( C, F )( operation )
‣ AddSetOfMorphismsOfFiniteCategory( C, F, weight )( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation SetOfMorphismsOfFiniteCategory. Optionally, a 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{SetOfMorphismsOfFiniteCategory}()\).

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

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operation adds the given function \(F\) to the category for the basic operation SetOfObjectsOfCategory. Optionally, a 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{SetOfObjectsOfCategory}()\).

7.6-222 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-223 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-224 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-225 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-226 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-227 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-228 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-229 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-230 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-231 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-232 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-233 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-234 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-235 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-236 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-237 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-238 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-239 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-240 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-241 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-242 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-243 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-244 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-245 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-246 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-247 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-248 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-249 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-250 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-251 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-252 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-253 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-254 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-255 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-256 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-257 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-258 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-259 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-260 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-261 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-262 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-263 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-264 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-265 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-266 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-267 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-268 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-269 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-270 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-271 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-272 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-273 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-274 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-275 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-276 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-277 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-278 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-279 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-280 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-281 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-282 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-283 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-284 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-285 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 17 Ind

generated by GAPDoc2HTML