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.
The entries of method name records can have the following components:
[
"filter_list",
"input_arguments_names",
"return_type",
"output_source_getter_string",
"output_source_getter_preconditions",
"output_range_getter_string",
"output_range_getter_preconditions",
"with_given_object_position",
"dual_operation",
"dual_arguments_reversed",
"dual_with_given_objects_reversed",
"dual_preprocessor_func",
"dual_preprocessor_func_string",
"dual_postprocessor_func",
"dual_postprocessor_func_string",
"functorial",
"compatible_with_congruence_of_morphisms",
"redirect_function",
"pre_function",
"pre_function_full",
"post_function",
]
pre_function (optional): A function which is used as the prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the pre function of the referenced operation is used.
pre_function_full (optional): A function which is used as the full prefunction of the installed methods, as described above. Can also be the name of another operation. In this case the full pre function of the referenced operation is used.
redirect_function (optional): A function which is used as the redirect function of the installed methods, as described above. Can also be the name of another operation. In this case the redirect function of the referenced operation is used.
post_function (optional): A function which is used as the postfunction of the installed methods, as described above.
filter_list: A list containing the basic filters for the methods installed by the add methods. Possible entries are filters, or the strings listed below, which will be replaced by appropriate filters at the time the add method is called. The first entry of filter_list must be the string category. If the category can be inferred from the remaining arguments, a convenience method without the category as the first argument is installed automatically.
category,
object,
morphism,
twocell,
object_in_range_category_of_homomorphism_structure,
morphism_in_range_category_of_homomorphism_structure,
list_of_objects,
list_of_morphisms,
list_of_twocells.
return_type: The return type can either be a filter or one of the strings in the list below. For objects, morphisms and 2-cells the correct Add function (see above) is used for the result of the computation. Otherwise, no Add function is used after all.
[
"object",
"morphism",
"twocell",
"object_in_range_category_of_homomorphism_structure",
"morphism_in_range_category_of_homomorphism_structure",
"bool",
"list_of_objects",
"list_of_morphisms",
"list_of_lists_of_morphisms",
"object_datum",
"morphism_datum",
"nonneg_integer_or_infinity",
"list_of_elements_of_commutative_ring_of_linear_structure",
]
functorial (optional): If an object has a corresponding functorial function, e.g., KernelObject and KernelObjectFunctorial, the name of the functorial is stored as a string.
dual_operation (optional): Name of the dual operation.
dual_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation all arguments have to be given in reversed order.
dual_with_given_objects_reversed (optional): Boolean, marks whether for the call of the dual operation the source and range of a with given operation have to be given in reversed order.
dual_preprocessor_func[_string] (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the arguments given to g are preprocessed by this given function. The function can also be given as a string.
dual_postprocessor_func[_string] (optional): let f be an operation with dual operation g. For the automatic installation of g from f, the computed value of f is postprocessed by the given function. The function can also be given as a string.
input_arguments_names (optional): A duplicate free list (of the same length as filter_list) of strings. For example, these strings will be used as the names of the arguments when automatically generating functions for this operation, e.g. in the opposite category.
output_source_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the source of the returned morphism. The input arguments are available via the names given in input_arguments_names.
output_source_getter_preconditions (optional): Only valid if output_source_getter_string is set: The preconditions of output_source_getter_string in the same form as preconditions of derivations but with the CAP operations given as strings.
output_range_getter_string (optional): Only valid if the operation returns a morphism: a piece of GAP code which computes the range of the returned morphism. The input arguments are available via the names given in input_arguments_names.
output_range_getter_preconditions (optional): Only valid if output_range_getter_string is set: The preconditions of output_range_getter_string in the same form as preconditions of derivations but with the CAP operations given as strings.
with_given_object_position (optional): One of the following strings: "Source", "Range", or "both". Set for the without given operation in a with given pair. Describes whether the source resp. range are given (as the last argument of the with given operation) or both (as the second and the last argument of the with given operation).
compatible_with_congruence_of_morphisms (optional): Indicates if the operation is compatible with the congruence of morphisms, that is, if the output does not change with regard to IsEqualForObjects and IsCongruentForMorphisms if the input changes with regard to IsEqualForObjects and IsCongruentForMorphisms.
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 ) |
‣ AddAdditionForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditionForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{AdditionForMorphisms}(alpha, beta).
‣ AddAdditiveGenerators( C, F ) | ( operation ) |
‣ AddAdditiveGenerators( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditiveGenerators. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{AdditiveGenerators}().
‣ AddAdditiveInverseForMorphisms( C, F ) | ( operation ) |
‣ AddAdditiveInverseForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AdditiveInverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{AdditiveInverseForMorphisms}(alpha).
‣ AddAstrictionToCoimage( C, F ) | ( operation ) |
‣ AddAstrictionToCoimage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AstrictionToCoimage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{AstrictionToCoimage}(alpha).
‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F ) | ( operation ) |
‣ AddAstrictionToCoimageWithGivenCoimageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation AstrictionToCoimageWithGivenCoimageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, C ) \mapsto \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C).
‣ AddBasisOfExternalHom( C, F ) | ( operation ) |
‣ AddBasisOfExternalHom( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BasisOfExternalHom. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3).
‣ AddCoastrictionToImage( C, F ) | ( operation ) |
‣ AddCoastrictionToImage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoastrictionToImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{CoastrictionToImage}(alpha).
‣ AddCoastrictionToImageWithGivenImageObject( C, F ) | ( operation ) |
‣ AddCoastrictionToImageWithGivenImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoastrictionToImageWithGivenImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, I ) \mapsto \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I).
‣ AddCoefficientsOfMorphism( C, F ) | ( operation ) |
‣ AddCoefficientsOfMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoefficientsOfMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{CoefficientsOfMorphism}(arg2).
‣ AddCoequalizer( C, F ) | ( operation ) |
‣ AddCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Coequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{Coequalizer}(Y, morphisms).
‣ AddCoequalizerFunctorial( C, F ) | ( operation ) |
‣ AddCoequalizerFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp).
‣ AddCoequalizerFunctorialWithGivenCoequalizers( C, F ) | ( operation ) |
‣ AddCoequalizerFunctorialWithGivenCoequalizers( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoequalizerFunctorialWithGivenCoequalizers. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp).
‣ AddCoimageObject( C, F ) | ( operation ) |
‣ AddCoimageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{CoimageObject}(arg2).
‣ AddCoimageObjectFunctorial( C, F ) | ( operation ) |
‣ AddCoimageObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap).
‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F ) | ( operation ) |
‣ AddCoimageObjectFunctorialWithGivenCoimageObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageObjectFunctorialWithGivenCoimageObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( C, alpha, mu, alphap, Cp ) \mapsto \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C, alpha, mu, alphap, Cp).
‣ AddCoimageProjection( C, F ) | ( operation ) |
‣ AddCoimageProjection( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageProjection. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{CoimageProjection}(alpha).
‣ AddCoimageProjectionWithGivenCoimageObject( C, F ) | ( operation ) |
‣ AddCoimageProjectionWithGivenCoimageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoimageProjectionWithGivenCoimageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, C ) \mapsto \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C).
‣ AddCokernelColift( C, F ) | ( operation ) |
‣ AddCokernelColift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelColift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, T, tau ) \mapsto \mathtt{CokernelColift}(alpha, T, tau).
‣ AddCokernelColiftWithGivenCokernelObject( C, F ) | ( operation ) |
‣ AddCokernelColiftWithGivenCokernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelColiftWithGivenCokernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, T, tau, P ) \mapsto \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P).
‣ AddCokernelObject( C, F ) | ( operation ) |
‣ AddCokernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{CokernelObject}(alpha).
‣ AddCokernelObjectFunctorial( C, F ) | ( operation ) |
‣ AddCokernelObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap).
‣ AddCokernelObjectFunctorialWithGivenCokernelObjects( C, F ) | ( operation ) |
‣ AddCokernelObjectFunctorialWithGivenCokernelObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelObjectFunctorialWithGivenCokernelObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp).
‣ AddCokernelProjection( C, F ) | ( operation ) |
‣ AddCokernelProjection( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelProjection. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{CokernelProjection}(alpha).
‣ AddCokernelProjectionWithGivenCokernelObject( C, F ) | ( operation ) |
‣ AddCokernelProjectionWithGivenCokernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CokernelProjectionWithGivenCokernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, P ) \mapsto \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P).
‣ AddColift( C, F ) | ( operation ) |
‣ AddColift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Colift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta).
‣ AddColiftAlongEpimorphism( C, F ) | ( operation ) |
‣ AddColiftAlongEpimorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ColiftAlongEpimorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( epsilon, tau ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau).
‣ AddComponentOfMorphismFromCoproduct( C, F ) | ( operation ) |
‣ AddComponentOfMorphismFromCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, I, i ) \mapsto \mathtt{ComponentOfMorphismFromCoproduct}(alpha, I, i).
‣ AddComponentOfMorphismFromDirectSum( C, F ) | ( operation ) |
‣ AddComponentOfMorphismFromDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismFromDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i).
‣ AddComponentOfMorphismIntoDirectProduct( C, F ) | ( operation ) |
‣ AddComponentOfMorphismIntoDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, P, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectProduct}(alpha, P, i).
‣ AddComponentOfMorphismIntoDirectSum( C, F ) | ( operation ) |
‣ AddComponentOfMorphismIntoDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ComponentOfMorphismIntoDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i).
‣ AddCoproduct( C, F ) | ( operation ) |
‣ AddCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Coproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects ) \mapsto \mathtt{Coproduct}(objects).
‣ AddCoproductFunctorial( C, F ) | ( operation ) |
‣ AddCoproductFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp).
‣ AddCoproductFunctorialWithGivenCoproducts( C, F ) | ( operation ) |
‣ AddCoproductFunctorialWithGivenCoproducts( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation CoproductFunctorialWithGivenCoproducts. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp).
‣ AddDirectProduct( C, F ) | ( operation ) |
‣ AddDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects ) \mapsto \mathtt{DirectProduct}(objects).
‣ AddDirectProductFunctorial( C, F ) | ( operation ) |
‣ AddDirectProductFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp).
‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F ) | ( operation ) |
‣ AddDirectProductFunctorialWithGivenDirectProducts( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectProductFunctorialWithGivenDirectProducts. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp).
‣ AddDirectSum( C, F ) | ( operation ) |
‣ AddDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects ) \mapsto \mathtt{DirectSum}(objects).
‣ AddDirectSumFunctorial( C, F ) | ( operation ) |
‣ AddDirectSumFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp).
‣ AddDirectSumFunctorialWithGivenDirectSums( C, F ) | ( operation ) |
‣ AddDirectSumFunctorialWithGivenDirectSums( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DirectSumFunctorialWithGivenDirectSums. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp).
‣ AddDistinguishedObjectOfHomomorphismStructure( C, F ) | ( operation ) |
‣ AddDistinguishedObjectOfHomomorphismStructure( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation DistinguishedObjectOfHomomorphismStructure. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}().
‣ AddEmbeddingOfEqualizer( C, F ) | ( operation ) |
‣ AddEmbeddingOfEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms).
‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F ) | ( operation ) |
‣ AddEmbeddingOfEqualizerWithGivenEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfEqualizerWithGivenEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P).
‣ AddEpimorphismFromProjectiveCoverObject( C, F ) | ( operation ) |
‣ AddEpimorphismFromProjectiveCoverObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A).
‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F ) | ( operation ) |
‣ AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P).
‣ AddEpimorphismFromSomeProjectiveObject( C, F ) | ( operation ) |
‣ AddEpimorphismFromSomeProjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromSomeProjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A).
‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F ) | ( operation ) |
‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P).
‣ AddEqualizer( C, F ) | ( operation ) |
‣ AddEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Equalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{Equalizer}(Y, morphisms).
‣ AddEqualizerFunctorial( C, F ) | ( operation ) |
‣ AddEqualizerFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp).
‣ AddEqualizerFunctorialWithGivenEqualizers( C, F ) | ( operation ) |
‣ AddEqualizerFunctorialWithGivenEqualizers( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EqualizerFunctorialWithGivenEqualizers. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp).
‣ AddFiberProduct( C, F ) | ( operation ) |
‣ AddFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms ) \mapsto \mathtt{FiberProduct}(morphisms).
‣ AddFiberProductFunctorial( C, F ) | ( operation ) |
‣ AddFiberProductFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp).
‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F ) | ( operation ) |
‣ AddFiberProductFunctorialWithGivenFiberProducts( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation FiberProductFunctorialWithGivenFiberProducts. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp).
‣ AddHomologyObject( C, F ) | ( operation ) |
‣ AddHomologyObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomologyObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{HomologyObject}(alpha, beta).
‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F ) | ( operation ) |
‣ AddHomologyObjectFunctorialWithGivenHomologyObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomologyObjectFunctorialWithGivenHomologyObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2).
‣ AddHomomorphismStructureOnMorphisms( C, F ) | ( operation ) |
‣ AddHomomorphismStructureOnMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta).
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F ) | ( operation ) |
‣ AddHomomorphismStructureOnMorphismsWithGivenObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnMorphismsWithGivenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, alpha, beta, range ) \mapsto \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source, alpha, beta, range).
‣ AddHomomorphismStructureOnObjects( C, F ) | ( operation ) |
‣ AddHomomorphismStructureOnObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HomomorphismStructureOnObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3).
‣ AddHorizontalPostCompose( C, F ) | ( operation ) |
‣ AddHorizontalPostCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPostCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3).
‣ AddHorizontalPreCompose( C, F ) | ( operation ) |
‣ AddHorizontalPreCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation HorizontalPreCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3).
‣ AddIdentityMorphism( C, F ) | ( operation ) |
‣ AddIdentityMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IdentityMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a ) \mapsto \mathtt{IdentityMorphism}(a).
‣ AddIdentityTwoCell( C, F ) | ( operation ) |
‣ AddIdentityTwoCell( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IdentityTwoCell. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IdentityTwoCell}(arg2).
‣ AddImageEmbedding( C, F ) | ( operation ) |
‣ AddImageEmbedding( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageEmbedding. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{ImageEmbedding}(alpha).
‣ AddImageEmbeddingWithGivenImageObject( C, F ) | ( operation ) |
‣ AddImageEmbeddingWithGivenImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageEmbeddingWithGivenImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, I ) \mapsto \mathtt{ImageEmbeddingWithGivenImageObject}(alpha, I).
‣ AddImageObject( C, F ) | ( operation ) |
‣ AddImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{ImageObject}(arg2).
‣ AddImageObjectFunctorial( C, F ) | ( operation ) |
‣ AddImageObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, nu, alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap).
‣ AddImageObjectFunctorialWithGivenImageObjects( C, F ) | ( operation ) |
‣ AddImageObjectFunctorialWithGivenImageObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ImageObjectFunctorialWithGivenImageObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip).
‣ AddIndecomposableInjectiveObjects( C, F ) | ( operation ) |
‣ AddIndecomposableInjectiveObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IndecomposableInjectiveObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IndecomposableInjectiveObjects}().
‣ AddIndecomposableProjectiveObjects( C, F ) | ( operation ) |
‣ AddIndecomposableProjectiveObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IndecomposableProjectiveObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IndecomposableProjectiveObjects}().
‣ AddInitialObject( C, F ) | ( operation ) |
‣ AddInitialObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{InitialObject}().
‣ AddInitialObjectFunctorial( C, F ) | ( operation ) |
‣ AddInitialObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{InitialObjectFunctorial}().
‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F ) | ( operation ) |
‣ AddInitialObjectFunctorialWithGivenInitialObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InitialObjectFunctorialWithGivenInitialObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp).
‣ AddInjectionOfCofactorOfCoproduct( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k).
‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfCoproductWithGivenCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfCoproductWithGivenCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P).
‣ AddInjectionOfCofactorOfDirectSum( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k).
‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfDirectSumWithGivenDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfDirectSumWithGivenDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P).
‣ AddInjectionOfCofactorOfPushout( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k).
‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfPushoutWithGivenPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfPushoutWithGivenPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P).
‣ AddInjectiveColift( C, F ) | ( operation ) |
‣ AddInjectiveColift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveColift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{InjectiveColift}(alpha, beta).
‣ AddInjectiveDimension( C, F ) | ( operation ) |
‣ AddInjectiveDimension( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveDimension. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{InjectiveDimension}(arg2).
‣ AddInjectiveEnvelopeObject( C, F ) | ( operation ) |
‣ AddInjectiveEnvelopeObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{InjectiveEnvelopeObject}(arg2).
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F ) | ( operation ) |
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha).
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F ) | ( operation ) |
‣ AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, alpha, range ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source, alpha, range).
‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F ) | ( operation ) |
‣ AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, range, alpha ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source, range, alpha).
‣ AddInverseForMorphisms( C, F ) | ( operation ) |
‣ AddInverseForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{InverseForMorphisms}(alpha).
‣ AddInverseOfMorphismFromCoimageToImage( C, F ) | ( operation ) |
‣ AddInverseOfMorphismFromCoimageToImage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InverseOfMorphismFromCoimageToImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImage}(alpha).
‣ AddInverseOfMorphismFromCoimageToImageWithGivenObjects( C, F ) | ( operation ) |
‣ AddInverseOfMorphismFromCoimageToImageWithGivenObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InverseOfMorphismFromCoimageToImageWithGivenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( I, alpha, C ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImageWithGivenObjects}(I, alpha, C).
‣ AddIsAutomorphism( C, F ) | ( operation ) |
‣ AddIsAutomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsAutomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsAutomorphism}(arg2).
‣ AddIsBijectiveObject( C, F ) | ( operation ) |
‣ AddIsBijectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsBijectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsBijectiveObject}(arg2).
‣ AddIsCodominating( C, F ) | ( operation ) |
‣ AddIsCodominating( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsCodominating. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsCodominating}(arg2, arg3).
‣ AddIsColiftable( C, F ) | ( operation ) |
‣ AddIsColiftable( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsColiftable. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftable}(arg2, arg3).
‣ AddIsColiftableAlongEpimorphism( C, F ) | ( operation ) |
‣ AddIsColiftableAlongEpimorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsColiftableAlongEpimorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3).
‣ AddIsCongruentForMorphisms( C, F ) | ( operation ) |
‣ AddIsCongruentForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsCongruentForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsCongruentForMorphisms}(arg2, arg3).
‣ AddIsDominating( C, F ) | ( operation ) |
‣ AddIsDominating( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsDominating. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsDominating}(arg2, arg3).
‣ AddIsEndomorphism( C, F ) | ( operation ) |
‣ AddIsEndomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEndomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsEndomorphism}(arg2).
‣ AddIsEpimorphism( C, F ) | ( operation ) |
‣ AddIsEpimorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEpimorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsEpimorphism}(arg2).
‣ AddIsEqualAsFactorobjects( C, F ) | ( operation ) |
‣ AddIsEqualAsFactorobjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualAsFactorobjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsFactorobjects}(arg2, arg3).
‣ AddIsEqualAsSubobjects( C, F ) | ( operation ) |
‣ AddIsEqualAsSubobjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualAsSubobjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualAsSubobjects}(arg2, arg3).
‣ AddIsEqualForCacheForMorphisms( C, F ) | ( operation ) |
‣ AddIsEqualForCacheForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3).
‣ AddIsEqualForCacheForObjects( C, F ) | ( operation ) |
‣ AddIsEqualForCacheForObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForCacheForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3).
‣ AddIsEqualForMorphisms( C, F ) | ( operation ) |
‣ AddIsEqualForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphisms}(arg2, arg3).
‣ AddIsEqualForMorphismsOnMor( C, F ) | ( operation ) |
‣ AddIsEqualForMorphismsOnMor( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForMorphismsOnMor. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForMorphismsOnMor}(arg2, arg3).
‣ AddIsEqualForObjects( C, F ) | ( operation ) |
‣ AddIsEqualForObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsEqualForObjects}(arg2, arg3).
‣ AddIsEqualToIdentityMorphism( C, F ) | ( operation ) |
‣ AddIsEqualToIdentityMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualToIdentityMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsEqualToIdentityMorphism}(arg2).
‣ AddIsEqualToZeroMorphism( C, F ) | ( operation ) |
‣ AddIsEqualToZeroMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsEqualToZeroMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsEqualToZeroMorphism}(arg2).
‣ AddIsHomSetInhabited( C, F ) | ( operation ) |
‣ AddIsHomSetInhabited( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsHomSetInhabited. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsHomSetInhabited}(arg2, arg3).
‣ AddIsIdempotent( C, F ) | ( operation ) |
‣ AddIsIdempotent( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsIdempotent. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsIdempotent}(arg2).
‣ AddIsInitial( C, F ) | ( operation ) |
‣ AddIsInitial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsInitial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsInitial}(arg2).
‣ AddIsInjective( C, F ) | ( operation ) |
‣ AddIsInjective( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsInjective. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsInjective}(arg2).
‣ AddIsIsomorphicForObjects( C, F ) | ( operation ) |
‣ AddIsIsomorphicForObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsIsomorphicForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( object_1, object_2 ) \mapsto \mathtt{IsIsomorphicForObjects}(object_1, object_2).
‣ AddIsIsomorphism( C, F ) | ( operation ) |
‣ AddIsIsomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsIsomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsIsomorphism}(arg2).
‣ AddIsLiftable( C, F ) | ( operation ) |
‣ AddIsLiftable( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsLiftable. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftable}(arg2, arg3).
‣ AddIsLiftableAlongMonomorphism( C, F ) | ( operation ) |
‣ AddIsLiftableAlongMonomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsLiftableAlongMonomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3).
‣ AddIsMonomorphism( C, F ) | ( operation ) |
‣ AddIsMonomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsMonomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsMonomorphism}(arg2).
‣ AddIsOne( C, F ) | ( operation ) |
‣ AddIsOne( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsOne. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsOne}(arg2).
‣ AddIsProjective( C, F ) | ( operation ) |
‣ AddIsProjective( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsProjective. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsProjective}(arg2).
‣ AddIsSplitEpimorphism( C, F ) | ( operation ) |
‣ AddIsSplitEpimorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsSplitEpimorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsSplitEpimorphism}(arg2).
‣ AddIsSplitMonomorphism( C, F ) | ( operation ) |
‣ AddIsSplitMonomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsSplitMonomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsSplitMonomorphism}(arg2).
‣ AddIsTerminal( C, F ) | ( operation ) |
‣ AddIsTerminal( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsTerminal. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsTerminal}(arg2).
‣ AddIsWellDefinedForMorphisms( C, F ) | ( operation ) |
‣ AddIsWellDefinedForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{IsWellDefinedForMorphisms}(alpha).
‣ AddIsWellDefinedForMorphismsWithGivenSourceAndRange( C, F ) | ( operation ) |
‣ AddIsWellDefinedForMorphismsWithGivenSourceAndRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForMorphismsWithGivenSourceAndRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, alpha, range ) \mapsto \mathtt{IsWellDefinedForMorphismsWithGivenSourceAndRange}(source, alpha, range).
‣ AddIsWellDefinedForObjects( C, F ) | ( operation ) |
‣ AddIsWellDefinedForObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForObjects}(arg2).
‣ AddIsWellDefinedForTwoCells( C, F ) | ( operation ) |
‣ AddIsWellDefinedForTwoCells( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWellDefinedForTwoCells. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsWellDefinedForTwoCells}(arg2).
‣ AddIsZeroForMorphisms( C, F ) | ( operation ) |
‣ AddIsZeroForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsZeroForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsZeroForMorphisms}(arg2).
‣ AddIsZeroForObjects( C, F ) | ( operation ) |
‣ AddIsZeroForObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsZeroForObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsZeroForObjects}(arg2).
‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F ) | ( operation ) |
‣ AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoequalizerOfCoproductDiagramToPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D).
‣ AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F ) | ( operation ) |
‣ AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D).
‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F ) | ( operation ) |
‣ AddIsomorphismFromCoimageToCokernelOfKernel( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoimageToCokernelOfKernel. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{IsomorphismFromCoimageToCokernelOfKernel}(alpha).
‣ AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( C, F ) | ( operation ) |
‣ AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer}(A, D).
‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F ) | ( operation ) |
‣ AddIsomorphismFromCokernelOfKernelToCoimage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCokernelOfKernelToCoimage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{IsomorphismFromCokernelOfKernelToCoimage}(alpha).
‣ AddIsomorphismFromCoproductToDirectSum( C, F ) | ( operation ) |
‣ AddIsomorphismFromCoproductToDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromCoproductToDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromCoproductToDirectSum}(D).
‣ AddIsomorphismFromDirectProductToDirectSum( C, F ) | ( operation ) |
‣ AddIsomorphismFromDirectProductToDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectProductToDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromDirectProductToDirectSum}(D).
‣ AddIsomorphismFromDirectSumToCoproduct( C, F ) | ( operation ) |
‣ AddIsomorphismFromDirectSumToCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectSumToCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToCoproduct}(D).
‣ AddIsomorphismFromDirectSumToDirectProduct( C, F ) | ( operation ) |
‣ AddIsomorphismFromDirectSumToDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromDirectSumToDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToDirectProduct}(D).
‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F ) | ( operation ) |
‣ AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D).
‣ AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F ) | ( operation ) |
‣ AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D).
‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F ) | ( operation ) |
‣ AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D).
‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha, beta).
‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F ) | ( operation ) |
‣ AddIsomorphismFromImageObjectToKernelOfCokernel( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromImageObjectToKernelOfCokernel. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{IsomorphismFromImageObjectToKernelOfCokernel}(alpha).
‣ AddIsomorphismFromInitialObjectToZeroObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromInitialObjectToZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromInitialObjectToZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IsomorphismFromInitialObjectToZeroObject}().
‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha, beta).
‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromKernelOfCokernelToImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromKernelOfCokernelToImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{IsomorphismFromKernelOfCokernelToImageObject}(alpha).
‣ AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( C, F ) | ( operation ) |
‣ AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer}(A, D).
‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F ) | ( operation ) |
‣ AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromPushoutToCoequalizerOfCoproductDiagram. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D).
‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromTerminalObjectToZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromTerminalObjectToZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IsomorphismFromTerminalObjectToZeroObject}().
‣ AddIsomorphismFromZeroObjectToInitialObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromZeroObjectToInitialObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromZeroObjectToInitialObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToInitialObject}().
‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F ) | ( operation ) |
‣ AddIsomorphismFromZeroObjectToTerminalObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsomorphismFromZeroObjectToTerminalObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToTerminalObject}().
‣ AddJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F ) | ( operation ) |
‣ AddJointPairwiseDifferencesOfMorphismsFromCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation JointPairwiseDifferencesOfMorphismsFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D).
‣ AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F ) | ( operation ) |
‣ AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation JointPairwiseDifferencesOfMorphismsIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D).
‣ AddKernelEmbedding( C, F ) | ( operation ) |
‣ AddKernelEmbedding( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelEmbedding. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{KernelEmbedding}(alpha).
‣ AddKernelEmbeddingWithGivenKernelObject( C, F ) | ( operation ) |
‣ AddKernelEmbeddingWithGivenKernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelEmbeddingWithGivenKernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, P ) \mapsto \mathtt{KernelEmbeddingWithGivenKernelObject}(alpha, P).
‣ AddKernelLift( C, F ) | ( operation ) |
‣ AddKernelLift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelLift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, T, tau ) \mapsto \mathtt{KernelLift}(alpha, T, tau).
‣ AddKernelLiftWithGivenKernelObject( C, F ) | ( operation ) |
‣ AddKernelLiftWithGivenKernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelLiftWithGivenKernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, T, tau, P ) \mapsto \mathtt{KernelLiftWithGivenKernelObject}(alpha, T, tau, P).
‣ AddKernelObject( C, F ) | ( operation ) |
‣ AddKernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{KernelObject}(alpha).
‣ AddKernelObjectFunctorial( C, F ) | ( operation ) |
‣ AddKernelObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, mu, alphap ) \mapsto \mathtt{KernelObjectFunctorial}(alpha, mu, alphap).
‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F ) | ( operation ) |
‣ AddKernelObjectFunctorialWithGivenKernelObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation KernelObjectFunctorialWithGivenKernelObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp).
‣ AddLift( C, F ) | ( operation ) |
‣ AddLift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Lift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{Lift}(alpha, beta).
‣ AddLiftAlongMonomorphism( C, F ) | ( operation ) |
‣ AddLiftAlongMonomorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation LiftAlongMonomorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( iota, tau ) \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau).
‣ AddLinearCombinationOfMorphisms( C, F ) | ( operation ) |
‣ AddLinearCombinationOfMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation LinearCombinationOfMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, list_of_ring_elements, list_of_morphisms, range ) \mapsto \mathtt{LinearCombinationOfMorphisms}(source, list_of_ring_elements, list_of_morphisms, range).
‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F ) | ( operation ) |
‣ AddMereExistenceOfSolutionOfLinearSystemInAbCategory( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MereExistenceOfSolutionOfLinearSystemInAbCategory. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4).
‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F ) | ( operation ) |
‣ AddMonomorphismIntoInjectiveEnvelopeObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObject}(A).
‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F ) | ( operation ) |
‣ AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I).
‣ AddMonomorphismIntoSomeInjectiveObject( C, F ) | ( operation ) |
‣ AddMonomorphismIntoSomeInjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoSomeInjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObject}(A).
‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F ) | ( operation ) |
‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I).
‣ AddMorphismBetweenDirectSums( C, F ) | ( operation ) |
‣ AddMorphismBetweenDirectSums( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSums. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram).
‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F ) | ( operation ) |
‣ AddMorphismBetweenDirectSumsWithGivenDirectSums( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectSumsWithGivenDirectSums. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T).
‣ AddMorphismConstructor( C, F ) | ( operation ) |
‣ AddMorphismConstructor( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismConstructor. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4).
‣ AddMorphismDatum( C, F ) | ( operation ) |
‣ AddMorphismDatum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismDatum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{MorphismDatum}(arg2).
‣ AddMorphismFromCoimageToImage( C, F ) | ( operation ) |
‣ AddMorphismFromCoimageToImage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromCoimageToImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{MorphismFromCoimageToImage}(alpha).
‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F ) | ( operation ) |
‣ AddMorphismFromCoimageToImageWithGivenObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromCoimageToImageWithGivenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( C, alpha, I ) \mapsto \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I).
‣ AddMorphismFromEqualizerToSink( C, F ) | ( operation ) |
‣ AddMorphismFromEqualizerToSink( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSink. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms).
‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F ) | ( operation ) |
‣ AddMorphismFromEqualizerToSinkWithGivenEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromEqualizerToSinkWithGivenEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P).
‣ AddMorphismFromFiberProductToSink( C, F ) | ( operation ) |
‣ AddMorphismFromFiberProductToSink( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromFiberProductToSink. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms ) \mapsto \mathtt{MorphismFromFiberProductToSink}(morphisms).
‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F ) | ( operation ) |
‣ AddMorphismFromFiberProductToSinkWithGivenFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromFiberProductToSinkWithGivenFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P).
‣ AddMorphismFromKernelObjectToSink( C, F ) | ( operation ) |
‣ AddMorphismFromKernelObjectToSink( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromKernelObjectToSink. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{MorphismFromKernelObjectToSink}(alpha).
‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F ) | ( operation ) |
‣ AddMorphismFromKernelObjectToSinkWithGivenKernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromKernelObjectToSinkWithGivenKernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, P ) \mapsto \mathtt{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P).
‣ AddMorphismFromSourceToCoequalizer( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms).
‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToCoequalizerWithGivenCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCoequalizerWithGivenCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, P ) \mapsto \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P).
‣ AddMorphismFromSourceToCokernelObject( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToCokernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCokernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{MorphismFromSourceToCokernelObject}(alpha).
‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToCokernelObjectWithGivenCokernelObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, P ) \mapsto \mathtt{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha, P).
‣ AddMorphismFromSourceToPushout( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms ) \mapsto \mathtt{MorphismFromSourceToPushout}(morphisms).
‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F ) | ( operation ) |
‣ AddMorphismFromSourceToPushoutWithGivenPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismFromSourceToPushoutWithGivenPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P).
‣ AddMorphismsOfExternalHom( C, F ) | ( operation ) |
‣ AddMorphismsOfExternalHom( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismsOfExternalHom. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{MorphismsOfExternalHom}(arg2, arg3).
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F ) | ( operation ) |
‣ AddMultiplyWithElementOfCommutativeRingForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MultiplyWithElementOfCommutativeRingForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( r, alpha ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, alpha).
‣ AddObjectConstructor( C, F ) | ( operation ) |
‣ AddObjectConstructor( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ObjectConstructor. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{ObjectConstructor}(arg2).
‣ AddObjectDatum( C, F ) | ( operation ) |
‣ AddObjectDatum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ObjectDatum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{ObjectDatum}(arg2).
‣ AddPostCompose( C, F ) | ( operation ) |
‣ AddPostCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( beta, alpha ) \mapsto \mathtt{PostCompose}(beta, alpha).
‣ AddPostComposeList( C, F ) | ( operation ) |
‣ AddPostComposeList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostComposeList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, list_of_morphisms, range ) \mapsto \mathtt{PostComposeList}(source, list_of_morphisms, range).
‣ AddPostInverseForMorphisms( C, F ) | ( operation ) |
‣ AddPostInverseForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PostInverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{PostInverseForMorphisms}(alpha).
‣ AddPreCompose( C, F ) | ( operation ) |
‣ AddPreCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{PreCompose}(alpha, beta).
‣ AddPreComposeList( C, F ) | ( operation ) |
‣ AddPreComposeList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreComposeList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, list_of_morphisms, range ) \mapsto \mathtt{PreComposeList}(source, list_of_morphisms, range).
‣ AddPreInverseForMorphisms( C, F ) | ( operation ) |
‣ AddPreInverseForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PreInverseForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{PreInverseForMorphisms}(alpha).
‣ AddProjectionInFactorOfDirectProduct( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k).
‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfDirectProductWithGivenDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectProductWithGivenDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k, P).
‣ AddProjectionInFactorOfDirectSum( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k).
‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfDirectSumWithGivenDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfDirectSumWithGivenDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, k, P ) \mapsto \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P).
‣ AddProjectionInFactorOfFiberProduct( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k).
‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfFiberProductWithGivenFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfFiberProductWithGivenFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k, P).
‣ AddProjectionOntoCoequalizer( C, F ) | ( operation ) |
‣ AddProjectionOntoCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms).
‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
‣ AddProjectionOntoCoequalizerWithGivenCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOntoCoequalizerWithGivenCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, P ) \mapsto \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P).
‣ AddProjectiveCoverObject( C, F ) | ( operation ) |
‣ AddProjectiveCoverObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveCoverObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{ProjectiveCoverObject}(arg2).
‣ AddProjectiveDimension( C, F ) | ( operation ) |
‣ AddProjectiveDimension( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveDimension. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{ProjectiveDimension}(arg2).
‣ AddProjectiveLift( C, F ) | ( operation ) |
‣ AddProjectiveLift( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectiveLift. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{ProjectiveLift}(alpha, beta).
‣ AddPushout( C, F ) | ( operation ) |
‣ AddPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Pushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms ) \mapsto \mathtt{Pushout}(morphisms).
‣ AddPushoutFunctorial( C, F ) | ( operation ) |
‣ AddPushoutFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial}(morphisms, L, morphismsp).
‣ AddPushoutFunctorialWithGivenPushouts( C, F ) | ( operation ) |
‣ AddPushoutFunctorialWithGivenPushouts( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation PushoutFunctorialWithGivenPushouts. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P, morphisms, L, morphismsp, Pp).
‣ AddRandomMorphismByInteger( C, F ) | ( operation ) |
‣ AddRandomMorphismByInteger( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismByInteger. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( n ) \mapsto \mathtt{RandomMorphismByInteger}(n).
‣ AddRandomMorphismByList( C, F ) | ( operation ) |
‣ AddRandomMorphismByList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismByList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( L ) \mapsto \mathtt{RandomMorphismByList}(L).
‣ AddRandomMorphismWithFixedRangeByInteger( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedRangeByInteger( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByInteger. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n).
‣ AddRandomMorphismWithFixedRangeByList( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedRangeByList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedRangeByList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( B, L ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L).
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedSourceAndRangeByInteger( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceAndRangeByInteger. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, B, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByInteger}(A, B, n).
‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedSourceAndRangeByList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceAndRangeByList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, B, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceAndRangeByList}(A, B, L).
‣ AddRandomMorphismWithFixedSourceByInteger( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedSourceByInteger( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByInteger. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n).
‣ AddRandomMorphismWithFixedSourceByList( C, F ) | ( operation ) |
‣ AddRandomMorphismWithFixedSourceByList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomMorphismWithFixedSourceByList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, L ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L).
‣ AddRandomObjectByInteger( C, F ) | ( operation ) |
‣ AddRandomObjectByInteger( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomObjectByInteger. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( n ) \mapsto \mathtt{RandomObjectByInteger}(n).
‣ AddRandomObjectByList( C, F ) | ( operation ) |
‣ AddRandomObjectByList( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RandomObjectByList. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( L ) \mapsto \mathtt{RandomObjectByList}(L).
‣ AddSimplifyEndo( C, F ) | ( operation ) |
‣ AddSimplifyEndo( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyEndo}(mor, n).
‣ AddSimplifyEndo_IsoFromInputObject( C, F ) | ( operation ) |
‣ AddSimplifyEndo_IsoFromInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoFromInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n).
‣ AddSimplifyEndo_IsoToInputObject( C, F ) | ( operation ) |
‣ AddSimplifyEndo_IsoToInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyEndo_IsoToInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n).
‣ AddSimplifyMorphism( C, F ) | ( operation ) |
‣ AddSimplifyMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n).
‣ AddSimplifyObject( C, F ) | ( operation ) |
‣ AddSimplifyObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n).
‣ AddSimplifyObject_IsoFromInputObject( C, F ) | ( operation ) |
‣ AddSimplifyObject_IsoFromInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoFromInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n).
‣ AddSimplifyObject_IsoToInputObject( C, F ) | ( operation ) |
‣ AddSimplifyObject_IsoToInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyObject_IsoToInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n).
‣ AddSimplifyRange( C, F ) | ( operation ) |
‣ AddSimplifyRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n).
‣ AddSimplifyRange_IsoFromInputObject( C, F ) | ( operation ) |
‣ AddSimplifyRange_IsoFromInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoFromInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n).
‣ AddSimplifyRange_IsoToInputObject( C, F ) | ( operation ) |
‣ AddSimplifyRange_IsoToInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifyRange_IsoToInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n).
‣ AddSimplifySource( C, F ) | ( operation ) |
‣ AddSimplifySource( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n).
‣ AddSimplifySourceAndRange( C, F ) | ( operation ) |
‣ AddSimplifySourceAndRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F ) | ( operation ) |
‣ AddSimplifySourceAndRange_IsoFromInputRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F ) | ( operation ) |
‣ AddSimplifySourceAndRange_IsoFromInputSource( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoFromInputSource. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n).
‣ AddSimplifySourceAndRange_IsoToInputRange( C, F ) | ( operation ) |
‣ AddSimplifySourceAndRange_IsoToInputRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor, n).
‣ AddSimplifySourceAndRange_IsoToInputSource( C, F ) | ( operation ) |
‣ AddSimplifySourceAndRange_IsoToInputSource( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySourceAndRange_IsoToInputSource. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n).
‣ AddSimplifySource_IsoFromInputObject( C, F ) | ( operation ) |
‣ AddSimplifySource_IsoFromInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoFromInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n).
‣ AddSimplifySource_IsoToInputObject( C, F ) | ( operation ) |
‣ AddSimplifySource_IsoToInputObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SimplifySource_IsoToInputObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( mor, n ) \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n).
‣ AddSolveLinearSystemInAbCategory( C, F ) | ( operation ) |
‣ AddSolveLinearSystemInAbCategory( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SolveLinearSystemInAbCategory. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4).
‣ AddSomeInjectiveObject( C, F ) | ( operation ) |
‣ AddSomeInjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeInjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{SomeInjectiveObject}(arg2).
‣ AddSomeIsomorphismBetweenObjects( C, F ) | ( operation ) |
‣ AddSomeIsomorphismBetweenObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeIsomorphismBetweenObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( object_1, object_2 ) \mapsto \mathtt{SomeIsomorphismBetweenObjects}(object_1, object_2).
‣ AddSomeProjectiveObject( C, F ) | ( operation ) |
‣ AddSomeProjectiveObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeProjectiveObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{SomeProjectiveObject}(arg2).
‣ AddSomeReductionBySplitEpiSummand( C, F ) | ( operation ) |
‣ AddSomeReductionBySplitEpiSummand( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand}(alpha).
‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F ) | ( operation ) |
‣ AddSomeReductionBySplitEpiSummand_MorphismFromInputRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand_MorphismFromInputRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismFromInputRange}(alpha).
‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F ) | ( operation ) |
‣ AddSomeReductionBySplitEpiSummand_MorphismToInputRange( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SomeReductionBySplitEpiSummand_MorphismToInputRange. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha).
‣ AddSubtractionForMorphisms( C, F ) | ( operation ) |
‣ AddSubtractionForMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SubtractionForMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, beta ) \mapsto \mathtt{SubtractionForMorphisms}(alpha, beta).
‣ AddSumOfMorphisms( C, F ) | ( operation ) |
‣ AddSumOfMorphisms( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SumOfMorphisms. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range).
‣ AddTerminalObject( C, F ) | ( operation ) |
‣ AddTerminalObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{TerminalObject}().
‣ AddTerminalObjectFunctorial( C, F ) | ( operation ) |
‣ AddTerminalObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{TerminalObjectFunctorial}().
‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F ) | ( operation ) |
‣ AddTerminalObjectFunctorialWithGivenTerminalObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation TerminalObjectFunctorialWithGivenTerminalObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp).
‣ AddUniversalMorphismFromCoequalizer( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau).
‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromCoequalizerWithGivenCoequalizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoequalizerWithGivenCoequalizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y, morphisms, T, tau, P).
‣ AddUniversalMorphismFromCoproduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau).
‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromCoproductWithGivenCoproduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromCoproductWithGivenCoproduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P).
‣ AddUniversalMorphismFromDirectSum( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau).
‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromDirectSumWithGivenDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromDirectSumWithGivenDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P).
‣ AddUniversalMorphismFromImage( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromImage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromImage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismFromImage}(alpha, tau).
‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromImageWithGivenImageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromImageWithGivenImageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, tau, I ) \mapsto \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I).
‣ AddUniversalMorphismFromInitialObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromInitialObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromInitialObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T ) \mapsto \mathtt{UniversalMorphismFromInitialObject}(T).
‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromInitialObjectWithGivenInitialObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromInitialObjectWithGivenInitialObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P).
‣ AddUniversalMorphismFromPushout( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau).
‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromPushoutWithGivenPushout( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromPushoutWithGivenPushout. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P).
‣ AddUniversalMorphismFromZeroObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T ) \mapsto \mathtt{UniversalMorphismFromZeroObject}(T).
‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromZeroObjectWithGivenZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromZeroObjectWithGivenZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P).
‣ AddUniversalMorphismIntoCoimage( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoCoimage( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoCoimage. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, tau ) \mapsto \mathtt{UniversalMorphismIntoCoimage}(alpha, tau).
‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoCoimageWithGivenCoimageObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoCoimageWithGivenCoimageObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( alpha, tau, C ) \mapsto \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C).
‣ AddUniversalMorphismIntoDirectProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau).
‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoDirectProductWithGivenDirectProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectProductWithGivenDirectProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P).
‣ AddUniversalMorphismIntoDirectSum( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau).
‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoDirectSumWithGivenDirectSum( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoDirectSumWithGivenDirectSum. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P).
‣ AddUniversalMorphismIntoEqualizer( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau).
‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoEqualizerWithGivenEqualizer( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoEqualizerWithGivenEqualizer. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( Y, morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P).
‣ AddUniversalMorphismIntoFiberProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau).
‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoFiberProductWithGivenFiberProduct( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoFiberProductWithGivenFiberProduct. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P).
‣ AddUniversalMorphismIntoTerminalObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoTerminalObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoTerminalObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T ) \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T).
‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoTerminalObjectWithGivenTerminalObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P).
‣ AddUniversalMorphismIntoZeroObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T ) \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T).
‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoZeroObjectWithGivenZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoZeroObjectWithGivenZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P).
‣ AddVerticalPostCompose( C, F ) | ( operation ) |
‣ AddVerticalPostCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPostCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPostCompose}(arg2, arg3).
‣ AddVerticalPreCompose( C, F ) | ( operation ) |
‣ AddVerticalPreCompose( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation VerticalPreCompose. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{VerticalPreCompose}(arg2, arg3).
‣ AddZeroMorphism( C, F ) | ( operation ) |
‣ AddZeroMorphism( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroMorphism. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b ) \mapsto \mathtt{ZeroMorphism}(a, b).
‣ AddZeroObject( C, F ) | ( operation ) |
‣ AddZeroObject( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObject. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{ZeroObject}().
‣ AddZeroObjectFunctorial( C, F ) | ( operation ) |
‣ AddZeroObjectFunctorial( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObjectFunctorial. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{ZeroObjectFunctorial}().
‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F ) | ( operation ) |
‣ AddZeroObjectFunctorialWithGivenZeroObjects( C, F, weight ) | ( operation ) |
Returns: nothing
The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ZeroObjectFunctorialWithGivenZeroObjects. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( P, Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P, Pp).
generated by GAPDoc2HTML