This section describes the overall structure of Add-functions and the functions installed by them.
Add functions have the following syntax:
DeclareOperation( "AddSomeFunc",
[ IsCapCategory, IsList, IsInt ] );
The first argument is the category to which some function (e.g. KernelObject) is added, the second is a list containing pairs of functions and additional filters for the arguments, (e.g. if one argument is a morphism, an additional filter could be IsMomomorphism). The third is an optional weight which will then be the weight for SomeFunc (default value: 100). This is described later. If only one function is to be installed, the list can be replaced by the function. CAP installs the given function(s) as methods for SomeFunc (resp. SomeFuncOp if SomeFunc is not an operation).
All installed methods follow the following steps, described below:
Redirect function
Prefunction
Function
Logic
Postfunction
Addfunction
Every other part, except from function, does only depend on the name SomeFunc. We now explain the steps in detail.
Redirect function: The redirect is used to redirect the computation from the given functions to some other symbol. If there is for example a with given method for some universal property, and the universal object is already computed, the redirect function might detect such a thing, calls the with given operation with the universal object as additional argument and then returns the value. In general, the redirect can be an arbitrary function. It is called with the same arguments as the operation SomeFunc itself and can return an array containing [ true, something ], which will cause the installed method to simply return the object something, or [ false ]. If the output is false, the computation will continue with the step Prefunction.
Prefunction: The prefunction should be used for error handling and plausibility checks of the input to SomeFunc (e.g. for KernelLift it should check wether range and source of the morphims coincide). Generally, the prefunction is defined in the method record and only depends on the name SomeFunc. It is called with the same input as the function itself, and should return either [ true ], which continues the computation, or [ false, "message" ], which will cause an error with message "message" and some additional information.
Full prefunction: The full prefuction has the same semantics as the prefunction, but can perform additional, very costly checks. They are disabled by default.
Function: This will launch the function(s) given as arguments. The result should be as specified in the type of SomeFunc. The resulting object is now named the result.
Logic: For every function, some logical todos can be implemented in a logic texfile for the category. If there is some logic written down in a file belonging to the category, or belonging to some type of category. Please see the description of logic for more details. If there is some logic and some predicate relations for the function SomeFunc, it is installed in this step for the result.
Postfunction: The postfunction called with the arguments of the function and the result. It can be an arbitrary function doing some cosmetics. If for example SomeFunc is KernelEmbedding, it will set the KernelObject of the input morphism to result. The postfunction is also taken from the method record and does only depend on the name SomeFunc.
Addfunction: If the result is a category cell, it is added to the category for which the function was installed. This is disabled by default and can be enabled via EnableAddForCategoricalOperations (1.12-1).
Except from installing a new method for the name SomeFunc, an Add method does slightly more. Every Add method has the same structure. The steps in the Add method are as follows:
Default weight: If the weight parameter is -1, the default weight is assumed, which is 100.
Weight check: If the current weight of the operation is lower than the given weight of the new functions, then the add function returns and installs nothing.
Installation: Next, the method to install the functions is created. It creates the correct filter list, by merging the standard filters for the operation with the particular filters for the given functions, then installs the method as described above.
After calling an add method, the corresponding operation is available in the category. Also, some derivations, which are triggered by the setting of the primitive value, might be available.
Almost all Add methods in the CAP kernel are installed by the CapInternalInstallAdd operation. The definition of this function is as follows:
DeclareOperation( "CapInternalInstallAdd",
[ IsRecord ] );
The record can have the following components, most of which can be set in the method name record, used as described:
function_name: The name of the function. This does not have to coincide with the installation name. It is used for the derivation weight.
installation_name (optional): A string which is the name of the operation for which the functions given to the Add method are installed as methods.
pre_function (optional): A function which is used as the prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the pre function of the referenced operation is used.
pre_function_full (optional): A function which is used as the full prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the full pre function of the referenced operation is used.
redirect_function (optional): A function which is used as the redirect function of the installed methods, as described above. Can also be the name of another operation. In this case the redirect function of the referenced operation is used.
post_function (optional): A function which is used as the postfunction of the installed methods, as described above.
filter_list: A list containing the basic filters for the methods installed by the add methods. Possible entries are filters, or the strings listed below, which will be replaced by appropriate filters at the time the add method is called. The first entry of filter_list must be the string category. If the category can be inferred from the remaining arguments, a convenience method without the category as the first argument is installed automatically. Additionally, the category is not passed to primitively added functions, except if category!.category_as_first_argument is set to true (this will probably change to be the default in the future).
category,
object,
morphism,
twocell,
object_in_range_category_of_homomorphism_structure,
morphism_in_range_category_of_homomorphism_structure,
other_category,
other_object,
other_morphism,
other_twocell,
list_of_objects,
list_of_morphisms,
list_of_twocells.
well_defined_todo (optional): A boolean, default value is true, which states wether there should be to do list entries which propagate well definedness from the input of the installed methods to their output. Please note that true only makes sense if at least one argument and the output of the installed method is a cell.
return_type: The return type can either be a filter or one of the strings in the list below. For objects, morphisms and 2-cells the correct Add function (see above) is used for the result of the computation. Otherwise, no Add function is used after all.
[
"object",
"object_or_fail",
"morphism",
"morphism_or_fail",
"twocell",
"object_in_range_category_of_homomorphism_structure",
"morphism_in_range_category_of_homomorphism_structure",
"bool",
"other_object",
"other_morphism",
"list_of_objects",
"list_of_morphisms",
"list_of_morphisms_or_fail",
"object_datum",
"morphism_datum",
"nonneg_integer_or_infinity",
]
is_with_given (optional): Boolean, marks whether the function which is to be installed is a with given function or not.
with_given_without_given_name_pair (optional): If the currently installed operation has a corresponding with given operation or is the with given of another operation, the names of both should be in this list.
functorial (optional): If an object has a corresponding functorial function, e.g., KernelObject and KernelObjectFunctorial, the name of the functorial is stored as a string.
dual_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation all arguments have to be given in reversed order.
dual_with_given_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation the source and range of a with given operation have to be given in reversed order.
dual_preprocessor_func (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the arguments given to g are preprocessed by this given function.
dual_postprocessor_func (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the computed value of f is postprocessed by the given function.
input_arguments_names (optional): A duplicate free list (of the same length as filter_list) of strings. For example, these strings will be used as the names of the arguments when automatically generating functions for this operation, e.g. in the opposite category.
output_source_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the source of the returned morphism. The input arguments are available via the names given in input_arguments_names.
can_always_compute_output_source_getter (optional): Only valid if output_source_getter_string is also set: Whether the code in output_source_getter_string is independent of CAP operations and can thus always be computed without having to check the installed operations of a category.
output_range_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the range of the returned morphism. The input arguments are available via the names given in input_arguments_names.
can_always_compute_output_range_getter (optional): Only valid if output_range_getter_string is also set: Whether the code in output_range_getter_string is independent of CAP operations and can thus always be computed without having to check the installed operations of a category.
with_given_object_position (optional): One of the following strings: "Source", "Range", or "both". Set for the without given operation in a with given pair. Describes whether the source resp. range are given (as the last argument of the with given operation) or both (as the second and the last argument of the with given operation).
compatible_with_congruence_of_morphisms (optional): Indicates if the operation is compatible with the congruence of morphisms, that is, if the output does not change with regard to IsEqualForObjects and IsCongruentForMorphisms if the input changes with regard to IsEqualForObjects and IsCongruentForMorphisms.
Using all those entries, the operation CapInternalInstallAdd installs add methods as described above. It first provides plausibility checks for all the entries described, then installs the Add method in 4 ways, with list or functions as second argument, and with an optional third parameter for the weight.
‣ CapInternalInstallAdd( record ) | ( function ) |
See 7.3.
The function CAP_INTERNAL_ENHANCE_NAME_RECORD can be applied to a method name record to make the following enhancements:
Function name: Set the component function_name to the entry name.
WithGiven special case: If the current entry belongs to a WithGiven operation or its without given pair, the with_given_without_given_name_pair is set. Additionally, the with given flag of the WithGiven operation is set to true.
Redirect and post functions are created for all operations belonging to universal constructions (e.g. KernelLift) which are not a WithGiven operation.
‣ 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.
‣ 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.
‣ ListCAPPrepareFunctions( arg ) | ( function ) |
Lists all prepare functions.
‣ AddAdditionForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditionForMorphisms. F: ( a, b ) \mapsto \mathtt{AdditionForMorphisms}(a, b).
‣ AddAdditiveGenerators( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditiveGenerators. F: ( ) \mapsto \mathtt{AdditiveGenerators}().
‣ AddAdditiveInverseForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditiveInverseForMorphisms. F: ( a ) \mapsto \mathtt{AdditiveInverseForMorphisms}(a).
‣ AddAstrictionToCoimage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AstrictionToCoimage. F: ( alpha ) \mapsto \mathtt{AstrictionToCoimage}(alpha).
‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AstrictionToCoimageWithGivenCoimageObject. F: ( alpha, C ) \mapsto \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C).
‣ AddBasisOfExternalHom( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BasisOfExternalHom. F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3).
‣ AddCanonicalIdentificationFromCoimageToImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CanonicalIdentificationFromCoimageToImageObject. F: ( alpha ) \mapsto \mathtt{CanonicalIdentificationFromCoimageToImageObject}(alpha).
‣ AddCanonicalIdentificationFromImageObjectToCoimage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CanonicalIdentificationFromImageObjectToCoimage. F: ( alpha ) \mapsto \mathtt{CanonicalIdentificationFromImageObjectToCoimage}(alpha).
‣ AddCoastrictionToImage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoastrictionToImage. F: ( alpha ) \mapsto \mathtt{CoastrictionToImage}(alpha).
‣ AddCoastrictionToImageWithGivenImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoastrictionToImageWithGivenImageObject. F: ( alpha, I ) \mapsto \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I).
‣ AddCoefficientsOfMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoefficientsOfMorphism. F: ( arg2 ) \mapsto \mathtt{CoefficientsOfMorphism}(arg2).
‣ AddCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Coequalizer. F: ( arg2, arg3 ) \mapsto \mathtt{Coequalizer}(arg2, arg3).
‣ AddCoequalizerFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorial. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp).
‣ AddCoequalizerFunctorialWithGivenCoequalizers( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorialWithGivenCoequalizers. F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp).
‣ AddCoimageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObject. F: ( arg2 ) \mapsto \mathtt{CoimageObject}(arg2).
‣ AddCoimageObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObjectFunctorial. F: ( alpha, mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap).
‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObjectFunctorialWithGivenCoimageObjects. F: ( C, alpha, mu, alphap, Cp ) \mapsto \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C, alpha, mu, alphap, Cp).
‣ AddCoimageProjection( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageProjection. F: ( alpha ) \mapsto \mathtt{CoimageProjection}(alpha).
‣ AddCoimageProjectionWithGivenCoimageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageProjectionWithGivenCoimageObject. F: ( alpha, C ) \mapsto \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C).
‣ AddCokernelColift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelColift. F: ( alpha, T, tau ) \mapsto \mathtt{CokernelColift}(alpha, T, tau).
‣ AddCokernelColiftWithGivenCokernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelColiftWithGivenCokernelObject. F: ( alpha, T, tau, P ) \mapsto \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P).
‣ AddCokernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObject. F: ( arg2 ) \mapsto \mathtt{CokernelObject}(arg2).
‣ AddCokernelObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObjectFunctorial. F: ( alpha, mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap).
‣ AddCokernelObjectFunctorialWithGivenCokernelObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObjectFunctorialWithGivenCokernelObjects. F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp).
‣ AddCokernelProjection( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelProjection. F: ( alpha ) \mapsto \mathtt{CokernelProjection}(alpha).
‣ AddCokernelProjectionWithGivenCokernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelProjectionWithGivenCokernelObject. F: ( alpha, P ) \mapsto \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P).
‣ AddColift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Colift. F: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta).
‣ AddColiftAlongEpimorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ColiftAlongEpimorphism. F: ( epsilon, tau ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau).
‣ AddColiftOrFail( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ColiftOrFail. F: ( alpha, beta ) \mapsto \mathtt{ColiftOrFail}(alpha, beta).
‣ AddComponentOfMorphismFromDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismFromDirectSum. F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i).
‣ AddComponentOfMorphismIntoDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismIntoDirectSum. F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i).
‣ AddCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Coproduct. F: ( arg2 ) \mapsto \mathtt{Coproduct}(arg2).
‣ AddCoproductFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp).
‣ AddCoproductFunctorialWithGivenCoproducts( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorialWithGivenCoproducts. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp).
‣ AddDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProduct. F: ( arg2 ) \mapsto \mathtt{DirectProduct}(arg2).
‣ AddDirectProductFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp).
‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorialWithGivenDirectProducts. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp).
‣ AddDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSum. F: ( arg2 ) \mapsto \mathtt{DirectSum}(arg2).
‣ AddDirectSumCodiagonalDifference( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumCodiagonalDifference. F: ( D ) \mapsto \mathtt{DirectSumCodiagonalDifference}(D).
‣ AddDirectSumDiagonalDifference( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumDiagonalDifference. F: ( D ) \mapsto \mathtt{DirectSumDiagonalDifference}(D).
‣ AddDirectSumFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorial. F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp).
‣ AddDirectSumFunctorialWithGivenDirectSums( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorialWithGivenDirectSums. F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp).
‣ AddDirectSumProjectionInPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumProjectionInPushout. F: ( D ) \mapsto \mathtt{DirectSumProjectionInPushout}(D).
‣ AddDistinguishedObjectOfHomomorphismStructure( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DistinguishedObjectOfHomomorphismStructure. F: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}().
‣ AddEmbeddingOfEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizer. F: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms).
‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizerWithGivenEqualizer. F: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P).
‣ AddEpimorphismFromProjectiveCoverObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromProjectiveCoverObject. F: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A).
‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject. F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P).
‣ AddEpimorphismFromSomeProjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromSomeProjectiveObject. F: ( A ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A).
‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject. F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P).
‣ AddEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Equalizer. F: ( arg2, arg3 ) \mapsto \mathtt{Equalizer}(arg2, arg3).
‣ AddEqualizerFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorial. F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp).
‣ AddEqualizerFunctorialWithGivenEqualizers( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorialWithGivenEqualizers. F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp).
‣ AddFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProduct. F: ( arg2 ) \mapsto \mathtt{FiberProduct}(arg2).
‣ AddFiberProductEmbeddingInDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductEmbeddingInDirectSum. F: ( D ) \mapsto \mathtt{FiberProductEmbeddingInDirectSum}(D).
‣ AddFiberProductFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorial. F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp).
‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorialWithGivenFiberProducts. F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp).
‣ AddHomologyObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomologyObject. F: ( alpha, beta ) \mapsto \mathtt{HomologyObject}(alpha, beta).
‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomologyObjectFunctorialWithGivenHomologyObjects. F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2).
‣ AddHomomorphismStructureOnMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnMorphisms. F: ( alpha, beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta).
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnMorphismsWithGivenObjects. F: ( source, alpha, beta, range ) \mapsto \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source, alpha, beta, range).
‣ AddHomomorphismStructureOnObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnObjects. F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3).
‣ AddHorizontalPostCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPostCompose. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3).
‣ AddHorizontalPreCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPreCompose. F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3).
‣ AddIdentityMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IdentityMorphism. F: ( a ) \mapsto \mathtt{IdentityMorphism}(a).
‣ AddIdentityTwoCell( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IdentityTwoCell. F: ( arg2 ) \mapsto \mathtt{IdentityTwoCell}(arg2).
‣ AddImageEmbedding( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageEmbedding. F: ( alpha ) \mapsto \mathtt{ImageEmbedding}(alpha).
‣ AddImageEmbeddingWithGivenImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageEmbeddingWithGivenImageObject. F: ( alpha, I ) \mapsto \mathtt{ImageEmbeddingWithGivenImageObject}(alpha, I).
‣ AddImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObject. F: ( arg2 ) \mapsto \mathtt{ImageObject}(arg2).
‣ AddImageObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObjectFunctorial. F: ( alpha, nu, alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap).
‣ AddImageObjectFunctorialWithGivenImageObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObjectFunctorialWithGivenImageObjects. F: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip).
‣ AddIndecomposableInjectiveObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IndecomposableInjectiveObjects. F: ( ) \mapsto \mathtt{IndecomposableInjectiveObjects}().
‣ AddIndecomposableProjectiveObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IndecomposableProjectiveObjects. F: ( ) \mapsto \mathtt{IndecomposableProjectiveObjects}().
‣ AddInitialObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObject. F: ( ) \mapsto \mathtt{InitialObject}().
‣ AddInitialObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObjectFunctorial. F: ( ) \mapsto \mathtt{InitialObjectFunctorial}().
‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObjectFunctorialWithGivenInitialObjects. F: ( P, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp).
‣ AddInjectionOfCofactorOfCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproduct. F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k).
‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproductWithGivenCoproduct. F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P).
‣ AddInjectionOfCofactorOfDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSum. F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k).
‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSumWithGivenDirectSum. F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P).
‣ AddInjectionOfCofactorOfPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushout. F: ( morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k).
‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushoutWithGivenPushout. F: ( morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P).
‣ AddInjectiveColift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveColift. F: ( alpha, beta ) \mapsto \mathtt{InjectiveColift}(alpha, beta).
‣ AddInjectiveDimension( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveDimension. F: ( arg2 ) \mapsto \mathtt{InjectiveDimension}(arg2).
‣ AddInjectiveEnvelopeObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveEnvelopeObject. F: ( arg2 ) \mapsto \mathtt{InjectiveEnvelopeObject}(arg2).
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure. F: ( alpha ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha).
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects. F: ( source, alpha, range ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source, alpha, range).
‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism. F: ( source, range, alpha ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source, range, alpha).
‣ AddInverseForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InverseForMorphisms. F: ( alpha ) \mapsto \mathtt{InverseForMorphisms}(alpha).
‣ AddInverseMorphismFromCoimageToImageWithGivenObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InverseMorphismFromCoimageToImageWithGivenObjects. F: ( C, alpha, I ) \mapsto \mathtt{InverseMorphismFromCoimageToImageWithGivenObjects}(C, alpha, I).
‣ AddIsAutomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsAutomorphism. F: ( arg2 ) \mapsto \mathtt{IsAutomorphism}(arg2).
‣ AddIsBijectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsBijectiveObject. F: ( arg2 ) \mapsto \mathtt{IsBijectiveObject}(arg2).
‣ AddIsCodominating( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsCodominating. F: ( arg2, arg3 ) \mapsto \mathtt{IsCodominating}(arg2, arg3).
‣ AddIsColiftable( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsColiftable. F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftable}(arg2, arg3).
‣ AddIsColiftableAlongEpimorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsColiftableAlongEpimorphism. F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3).
‣ AddIsCongruentForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsCongruentForMorphisms. F: ( arg2, arg3 ) \mapsto \mathtt{IsCongruentForMorphisms}(arg2, arg3).
‣ AddIsDominating( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsDominating. F: ( arg2, arg3 ) \mapsto \mathtt{IsDominating}(arg2, arg3).
‣ AddIsEndomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEndomorphism. F: ( arg2 ) \mapsto \mathtt{IsEndomorphism}(arg2).
‣ AddIsEpimorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEpimorphism. F: ( arg2 ) \mapsto \mathtt{IsEpimorphism}(arg2).
‣ AddIsEqualAsFactorobjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualAsFactorobjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsFactorobjects}(arg2, arg3).
‣ AddIsEqualAsSubobjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualAsSubobjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsSubobjects}(arg2, arg3).
‣ AddIsEqualForCacheForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForMorphisms. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3).
‣ AddIsEqualForCacheForObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForObjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3).
‣ AddIsEqualForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForMorphisms. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphisms}(arg2, arg3).
‣ AddIsEqualForMorphismsOnMor( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForMorphismsOnMor. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphismsOnMor}(arg2, arg3).
‣ AddIsEqualForObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForObjects. F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForObjects}(arg2, arg3).
‣ AddIsEqualToIdentityMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualToIdentityMorphism. F: ( arg2 ) \mapsto \mathtt{IsEqualToIdentityMorphism}(arg2).
‣ AddIsEqualToZeroMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualToZeroMorphism. F: ( arg2 ) \mapsto \mathtt{IsEqualToZeroMorphism}(arg2).
‣ AddIsHomSetInhabited( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsHomSetInhabited. F: ( arg2, arg3 ) \mapsto \mathtt{IsHomSetInhabited}(arg2, arg3).
‣ AddIsIdempotent( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsIdempotent. F: ( arg2 ) \mapsto \mathtt{IsIdempotent}(arg2).
‣ AddIsInitial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsInitial. F: ( arg2 ) \mapsto \mathtt{IsInitial}(arg2).
‣ AddIsInjective( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsInjective. F: ( arg2 ) \mapsto \mathtt{IsInjective}(arg2).
‣ AddIsIsomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsIsomorphism. F: ( arg2 ) \mapsto \mathtt{IsIsomorphism}(arg2).
‣ AddIsLiftable( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsLiftable. F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftable}(arg2, arg3).
‣ AddIsLiftableAlongMonomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsLiftableAlongMonomorphism. F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3).
‣ AddIsMonomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsMonomorphism. F: ( arg2 ) \mapsto \mathtt{IsMonomorphism}(arg2).
‣ AddIsOne( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsOne. F: ( arg2 ) \mapsto \mathtt{IsOne}(arg2).
‣ AddIsProjective( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsProjective. F: ( arg2 ) \mapsto \mathtt{IsProjective}(arg2).
‣ AddIsSplitEpimorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsSplitEpimorphism. F: ( arg2 ) \mapsto \mathtt{IsSplitEpimorphism}(arg2).
‣ AddIsSplitMonomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsSplitMonomorphism. F: ( arg2 ) \mapsto \mathtt{IsSplitMonomorphism}(arg2).
‣ AddIsTerminal( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsTerminal. F: ( arg2 ) \mapsto \mathtt{IsTerminal}(arg2).
‣ AddIsWellDefinedForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForMorphisms. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForMorphisms}(arg2).
‣ AddIsWellDefinedForObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForObjects. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForObjects}(arg2).
‣ AddIsWellDefinedForTwoCells( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForTwoCells. F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForTwoCells}(arg2).
‣ AddIsZeroForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsZeroForMorphisms. F: ( arg2 ) \mapsto \mathtt{IsZeroForMorphisms}(arg2).
‣ AddIsZeroForObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsZeroForObjects. F: ( arg2 ) \mapsto \mathtt{IsZeroForObjects}(arg2).
‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoequalizerOfCoproductDiagramToPushout. F: ( D ) \mapsto \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D).
‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoimageToCokernelOfKernel. F: ( alpha ) \mapsto \mathtt{IsomorphismFromCoimageToCokernelOfKernel}(alpha).
‣ AddIsomorphismFromCokernelOfDiagonalDifferenceToPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCokernelOfDiagonalDifferenceToPushout. F: ( D ) \mapsto \mathtt{IsomorphismFromCokernelOfDiagonalDifferenceToPushout}(D).
‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCokernelOfKernelToCoimage. F: ( alpha ) \mapsto \mathtt{IsomorphismFromCokernelOfKernelToCoimage}(alpha).
‣ AddIsomorphismFromCoproductToDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoproductToDirectSum. F: ( D ) \mapsto \mathtt{IsomorphismFromCoproductToDirectSum}(D).
‣ AddIsomorphismFromDirectProductToDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectProductToDirectSum. F: ( D ) \mapsto \mathtt{IsomorphismFromDirectProductToDirectSum}(D).
‣ AddIsomorphismFromDirectSumToCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectSumToCoproduct. F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToCoproduct}(D).
‣ AddIsomorphismFromDirectSumToDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectSumToDirectProduct. F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToDirectProduct}(D).
‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct. F: ( D ) \mapsto \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D).
‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram. F: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D).
‣ AddIsomorphismFromFiberProductToKernelOfDiagonalDifference( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromFiberProductToKernelOfDiagonalDifference. F: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToKernelOfDiagonalDifference}(D).
‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject. F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha, beta).
‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromImageObjectToKernelOfCokernel. F: ( alpha ) \mapsto \mathtt{IsomorphismFromImageObjectToKernelOfCokernel}(alpha).
‣ AddIsomorphismFromInitialObjectToZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromInitialObjectToZeroObject. F: ( ) \mapsto \mathtt{IsomorphismFromInitialObjectToZeroObject}().
‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject. F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha, beta).
‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromKernelOfCokernelToImageObject. F: ( alpha ) \mapsto \mathtt{IsomorphismFromKernelOfCokernelToImageObject}(alpha).
‣ AddIsomorphismFromKernelOfDiagonalDifferenceToFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct. F: ( D ) \mapsto \mathtt{IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct}(D).
‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromPushoutToCoequalizerOfCoproductDiagram. F: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D).
‣ AddIsomorphismFromPushoutToCokernelOfDiagonalDifference( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromPushoutToCokernelOfDiagonalDifference. F: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCokernelOfDiagonalDifference}(D).
‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromTerminalObjectToZeroObject. F: ( ) \mapsto \mathtt{IsomorphismFromTerminalObjectToZeroObject}().
‣ AddIsomorphismFromZeroObjectToInitialObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromZeroObjectToInitialObject. F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToInitialObject}().
‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromZeroObjectToTerminalObject. F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToTerminalObject}().
‣ AddKernelEmbedding( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelEmbedding. F: ( alpha ) \mapsto \mathtt{KernelEmbedding}(alpha).
‣ AddKernelEmbeddingWithGivenKernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelEmbeddingWithGivenKernelObject. F: ( alpha, P ) \mapsto \mathtt{KernelEmbeddingWithGivenKernelObject}(alpha, P).
‣ AddKernelLift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelLift. F: ( alpha, T, tau ) \mapsto \mathtt{KernelLift}(alpha, T, tau).
‣ AddKernelLiftWithGivenKernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelLiftWithGivenKernelObject. F: ( alpha, T, tau, P ) \mapsto \mathtt{KernelLiftWithGivenKernelObject}(alpha, T, tau, P).
‣ AddKernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObject. F: ( arg2 ) \mapsto \mathtt{KernelObject}(arg2).
‣ AddKernelObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObjectFunctorial. F: ( alpha, mu, alphap ) \mapsto \mathtt{KernelObjectFunctorial}(alpha, mu, alphap).
‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObjectFunctorialWithGivenKernelObjects. F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp).
‣ AddLift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Lift. F: ( alpha, beta ) \mapsto \mathtt{Lift}(alpha, beta).
‣ AddLiftAlongMonomorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation LiftAlongMonomorphism. F: ( iota, tau ) \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau).
‣ AddLiftOrFail( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation LiftOrFail. F: ( alpha, beta ) \mapsto \mathtt{LiftOrFail}(alpha, beta).
‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MereExistenceOfSolutionOfLinearSystemInAbCategory. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4).
‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObject. F: ( A ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObject}(A).
‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I).
‣ AddMonomorphismIntoSomeInjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoSomeInjectiveObject. F: ( A ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObject}(A).
‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject. F: ( A, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I).
‣ AddMorphismBetweenDirectSums( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSums. F: ( source_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram).
‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSumsWithGivenDirectSums. F: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T).
‣ AddMorphismConstructor( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismConstructor. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4).
‣ AddMorphismDatum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismDatum. F: ( arg2 ) \mapsto \mathtt{MorphismDatum}(arg2).
‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromCoimageToImageWithGivenObjects. F: ( C, alpha, I ) \mapsto \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I).
‣ AddMorphismFromEqualizerToSink( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSink. F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms).
‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSinkWithGivenEqualizer. F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P).
‣ AddMorphismFromFiberProductToSink( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromFiberProductToSink. F: ( morphisms ) \mapsto \mathtt{MorphismFromFiberProductToSink}(morphisms).
‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromFiberProductToSinkWithGivenFiberProduct. F: ( morphisms, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P).
‣ AddMorphismFromKernelObjectToSink( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromKernelObjectToSink. F: ( alpha ) \mapsto \mathtt{MorphismFromKernelObjectToSink}(alpha).
‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromKernelObjectToSinkWithGivenKernelObject. F: ( alpha, P ) \mapsto \mathtt{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P).
‣ AddMorphismFromSourceToCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizer. F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms).
‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P).
‣ AddMorphismFromSourceToCokernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCokernelObject. F: ( alpha ) \mapsto \mathtt{MorphismFromSourceToCokernelObject}(alpha).
‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCokernelObjectWithGivenCokernelObject. F: ( alpha, P ) \mapsto \mathtt{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha, P).
‣ AddMorphismFromSourceToPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToPushout. F: ( morphisms ) \mapsto \mathtt{MorphismFromSourceToPushout}(morphisms).
‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToPushoutWithGivenPushout. F: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P).
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MultiplyWithElementOfCommutativeRingForMorphisms. F: ( r, a ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, a).
‣ AddObjectConstructor( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ObjectConstructor. F: ( arg2 ) \mapsto \mathtt{ObjectConstructor}(arg2).
‣ AddObjectDatum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ObjectDatum. F: ( arg2 ) \mapsto \mathtt{ObjectDatum}(arg2).
‣ AddPostCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostCompose. F: ( beta, alpha ) \mapsto \mathtt{PostCompose}(beta, alpha).
‣ AddPostComposeList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostComposeList. F: ( list_of_morphisms ) \mapsto \mathtt{PostComposeList}(list_of_morphisms).
‣ AddPostInverseForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostInverseForMorphisms. F: ( alpha ) \mapsto \mathtt{PostInverseForMorphisms}(alpha).
‣ AddPreCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreCompose. F: ( alpha, beta ) \mapsto \mathtt{PreCompose}(alpha, beta).
‣ AddPreComposeList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreComposeList. F: ( list_of_morphisms ) \mapsto \mathtt{PreComposeList}(list_of_morphisms).
‣ AddPreInverseForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreInverseForMorphisms. F: ( alpha ) \mapsto \mathtt{PreInverseForMorphisms}(alpha).
‣ AddProjectionInFactorOfDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProduct. F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k).
‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProductWithGivenDirectProduct. F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k, P).
‣ AddProjectionInFactorOfDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSum. F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k).
‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSumWithGivenDirectSum. F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P).
‣ AddProjectionInFactorOfFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProduct. F: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k).
‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProductWithGivenFiberProduct. F: ( morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k, P).
‣ AddProjectionOntoCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizer. F: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms).
‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P).
‣ AddProjectiveCoverObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveCoverObject. F: ( arg2 ) \mapsto \mathtt{ProjectiveCoverObject}(arg2).
‣ AddProjectiveDimension( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveDimension. F: ( arg2 ) \mapsto \mathtt{ProjectiveDimension}(arg2).
‣ AddProjectiveLift( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveLift. F: ( alpha, beta ) \mapsto \mathtt{ProjectiveLift}(alpha, beta).
‣ AddPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Pushout. F: ( arg2 ) \mapsto \mathtt{Pushout}(arg2).
‣ AddPushoutFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorial. F: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial}(morphisms, L, morphismsp).
‣ AddPushoutFunctorialWithGivenPushouts( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorialWithGivenPushouts. F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P, morphisms, L, morphismsp, Pp).
‣ AddRandomMorphismByInteger( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismByInteger. F: ( n ) \mapsto \mathtt{RandomMorphismByInteger}(n).
‣ AddRandomMorphismByList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismByList. F: ( L ) \mapsto \mathtt{RandomMorphismByList}(L).
‣ AddRandomMorphismWithFixedRangeByInteger( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByInteger. F: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n).
‣ AddRandomMorphismWithFixedRangeByList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByList. F: ( B, L ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L).
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceAndRangeByInteger. F: ( A, B, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByInteger}(A, B, n).
‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceAndRangeByList. F: ( A, B, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByList}(A, B, L).
‣ AddRandomMorphismWithFixedSourceByInteger( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByInteger. F: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n).
‣ AddRandomMorphismWithFixedSourceByList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByList. F: ( A, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L).
‣ AddRandomObjectByInteger( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomObjectByInteger. F: ( n ) \mapsto \mathtt{RandomObjectByInteger}(n).
‣ AddRandomObjectByList( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomObjectByList. F: ( L ) \mapsto \mathtt{RandomObjectByList}(L).
‣ AddSimplifyEndo( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo}(mor, n).
‣ AddSimplifyEndo_IsoFromInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n).
‣ AddSimplifyEndo_IsoToInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n).
‣ AddSimplifyMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyMorphism. F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n).
‣ AddSimplifyObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n).
‣ AddSimplifyObject_IsoFromInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoFromInputObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n).
‣ AddSimplifyObject_IsoToInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoToInputObject. F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n).
‣ AddSimplifyRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange. F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n).
‣ AddSimplifyRange_IsoFromInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n).
‣ AddSimplifyRange_IsoToInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n).
‣ AddSimplifySource( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource. F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n).
‣ AddSimplifySourceAndRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputSource. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n).
‣ AddSimplifySourceAndRange_IsoToInputRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputRange. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoToInputSource( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputSource. F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n).
‣ AddSimplifySource_IsoFromInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoFromInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n).
‣ AddSimplifySource_IsoToInputObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoToInputObject. F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n).
‣ AddSolveLinearSystemInAbCategory( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SolveLinearSystemInAbCategory. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4).
‣ AddSolveLinearSystemInAbCategoryOrFail( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SolveLinearSystemInAbCategoryOrFail. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategoryOrFail}(arg2, arg3, arg4).
‣ AddSomeInjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeInjectiveObject. F: ( arg2 ) \mapsto \mathtt{SomeInjectiveObject}(arg2).
‣ AddSomeProjectiveObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeProjectiveObject. F: ( arg2 ) \mapsto \mathtt{SomeProjectiveObject}(arg2).
‣ AddSomeReductionBySplitEpiSummand( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand}(alpha).
‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand_MorphismFromInputRange. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismFromInputRange}(alpha).
‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand_MorphismToInputRange. F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha).
‣ AddSubtractionForMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SubtractionForMorphisms. F: ( a, b ) \mapsto \mathtt{SubtractionForMorphisms}(a, b).
‣ AddSumOfMorphisms( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SumOfMorphisms. F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range).
‣ AddTerminalObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObject. F: ( ) \mapsto \mathtt{TerminalObject}().
‣ AddTerminalObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObjectFunctorial. F: ( ) \mapsto \mathtt{TerminalObjectFunctorial}().
‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObjectFunctorialWithGivenTerminalObjects. F: ( P, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp).
‣ AddUniversalMorphismFromCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizer. F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau).
‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizerWithGivenCoequalizer. F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y, morphisms, T, tau, P).
‣ AddUniversalMorphismFromCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproduct. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau).
‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproductWithGivenCoproduct. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P).
‣ AddUniversalMorphismFromDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSum. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau).
‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSumWithGivenDirectSum. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P).
‣ AddUniversalMorphismFromImage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromImage. F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismFromImage}(alpha, tau).
‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromImageWithGivenImageObject. F: ( alpha, tau, I ) \mapsto \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I).
‣ AddUniversalMorphismFromInitialObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromInitialObject. F: ( T ) \mapsto \mathtt{UniversalMorphismFromInitialObject}(T).
‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromInitialObjectWithGivenInitialObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P).
‣ AddUniversalMorphismFromPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushout. F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau).
‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushoutWithGivenPushout. F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P).
‣ AddUniversalMorphismFromZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromZeroObject. F: ( T ) \mapsto \mathtt{UniversalMorphismFromZeroObject}(T).
‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromZeroObjectWithGivenZeroObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P).
‣ AddUniversalMorphismIntoCoimage( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoCoimage. F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismIntoCoimage}(alpha, tau).
‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoCoimageWithGivenCoimageObject. F: ( alpha, tau, C ) \mapsto \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C).
‣ AddUniversalMorphismIntoDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProduct. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau).
‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProductWithGivenDirectProduct. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P).
‣ AddUniversalMorphismIntoDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSum. F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau).
‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSumWithGivenDirectSum. F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P).
‣ AddUniversalMorphismIntoEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizer. F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau).
‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizerWithGivenEqualizer. F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P).
‣ AddUniversalMorphismIntoFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProduct. F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau).
‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProductWithGivenFiberProduct. F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P).
‣ AddUniversalMorphismIntoTerminalObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoTerminalObject. F: ( T ) \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T).
‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoTerminalObjectWithGivenTerminalObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P).
‣ AddUniversalMorphismIntoZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoZeroObject. F: ( T ) \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T).
‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoZeroObjectWithGivenZeroObject. F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P).
‣ AddVerticalPostCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPostCompose. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPostCompose}(arg2, arg3).
‣ AddVerticalPreCompose( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPreCompose. F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPreCompose}(arg2, arg3).
‣ AddZeroMorphism( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroMorphism. F: ( a, b ) \mapsto \mathtt{ZeroMorphism}(a, b).
‣ AddZeroObject( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObject. F: ( ) \mapsto \mathtt{ZeroObject}().
‣ AddZeroObjectFunctorial( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObjectFunctorial. F: ( ) \mapsto \mathtt{ZeroObjectFunctorial}().
‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObjectFunctorialWithGivenZeroObjects. F: ( P, Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P, Pp).
generated by GAPDoc2HTML