<!-- This is an automatically generated file. -->
<Chapter Label="Chapter_Add_Functions">
<Heading>Add Functions</Heading>
<P/>
This section describes the overall structure of Add-functions and the functions installed by them.
<P/>
<Section Label="Chapter_Add_Functions_Section_Functions_Installed_by_Add">
<Heading>Functions Installed by Add</Heading>
<P/>
Add functions have the following syntax:
<P/>
<#Include Label="AddSomeFunc">
<P/>
The first argument is the category to which some function (e.g. <Code>KernelObject</Code>)
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 <Code>IsMomomorphism</Code>).
The third is an optional weight which will then be the weight for <Code>SomeFunc</Code> (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 <Code>SomeFunc</Code> (resp. <Code>SomeFuncOp</Code> if <Code>SomeFunc</Code> is not an operation).
<P/>
All installed methods follow the following steps, described below:
<List>
<Item>
Redirect function
</Item>
<Item>
Prefunction
</Item>
<Item>
Function
</Item>
<Item>
Logic
</Item>
<Item>
Postfunction
</Item>
<Item>
Addfunction
</Item>
</List>
<P/>
Every other part, except from function, does only depend on the name <Code>SomeFunc</Code>. We now explain the steps in detail.
<P/>
<List>
<Item>
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 <Code>SomeFunc</Code> itself and can return an array containing <Code>[ true, something ]</Code>, which will cause
the installed method to simply return the object <Code>something</Code>, or <Code>[ false ]</Code>. If the output is <Code>false</Code>, the computation will
continue with the step Prefunction.
</Item>
</List>
<P/>
<List>
<Item>
Prefunction: The prefunction should be used for error handling and plausibility checks of the input to <Code>SomeFunc</Code>
(e.g. for <Code>KernelLift</Code> 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 <Code>SomeFunc</Code>. It is called with the same input as the function itself, and
should return either <Code>[ true ]</Code>, which continues the computation, or <Code>[ false, "message" ]</Code>, which will cause an error with
message <Code>"message"</Code> and some additional information.
</Item>
</List>
<P/>
<List>
<Item>
Full prefunction: The full prefuction has the same semantics as the prefunction, but can perform additional, very
costly checks. They are disabled by default.
</Item>
</List>
<P/>
<List>
<Item>
Function: This will launch the function(s) given as arguments. The result should be as specified in the type of
<Code>SomeFunc</Code>. The resulting object is now named the result.
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>SomeFunc</Code>,
it is installed in this step for the result.
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>SomeFunc</Code> is <Code>KernelEmbedding</Code>, it will set the <Code>KernelObject</Code> of the input morphism to result.
The postfunction is also taken from the method record and does only depend on the name <Code>SomeFunc</Code>.
</Item>
</List>
<P/>
<List>
<Item>
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 <Ref Func="EnableAddForCategoricalOperations" />.
</Item>
</List>
<P/>
</Section>
<P/>
Except from installing a new method for the name <Code>SomeFunc</Code>, an Add method does slightly more.
Every Add method has the same structure. The steps in the Add method are as follows:
<P/>
<List>
<Item>
Default weight: If the weight parameter is -1, the default weight is assumed, which is 100.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
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.
<P/>
</Section>
<Section Label="Section_method_name_record_entries">
<Heading>Method name record entries</Heading>
<P/>
The entries of method name records can have the following components:
<#Include Label="CAP_INTERNAL_VALID_METHOD_NAME_RECORD_COMPONENTS">
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
post_function (optional): A function which is used as the postfunction of the installed methods, as described above.
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>filter_list</Code> must be the string <Code>category</Code>. If the category can be inferred from the remaining arguments, a convenience method without the category
as the first argument is installed automatically.
<List>
<Item>
<C>category</C>,
</Item>
<Item>
<C>object</C>,
</Item>
<Item>
<C>morphism</C>,
</Item>
<Item>
<C>twocell</C>,
</Item>
<Item>
<C>object_in_range_category_of_homomorphism_structure</C>,
</Item>
<Item>
<C>morphism_in_range_category_of_homomorphism_structure</C>,
</Item>
<Item>
<C>list_of_objects</C>,
</Item>
<Item>
<C>list_of_morphisms</C>,
</Item>
<Item>
<C>list_of_twocells</C>.
</Item>
</List>
</Item>
</List>
<P/>
<List>
<Item>
return_type: The return type can either be a filter or one of the strings in the list below.
For objects, morphisms and <Math>2</Math>-cells the correct <C>Add</C> function (see above) is
used for the result of the computation. Otherwise, no <C>Add</C> function is used after all.
</Item>
</List>
<#Include Label="CAP_INTERNAL_VALID_RETURN_TYPES">
<P/>
<List>
<Item>
functorial (optional): If an object has a corresponding functorial function, e.g., <Code>KernelObject</Code> and <Code>KernelObjectFunctorial</Code>,
the name of the functorial is stored as a string.
</Item>
</List>
<P/>
<List>
<Item>
dual_operation (optional): Name of the dual operation.
</Item>
</List>
<P/>
<List>
<Item>
dual_arguments_reversed (optional): Boolean, marks whether for the call of the dual operation all arguments have to be given in reversed order.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
input_arguments_names (optional): A duplicate free list (of the same length as <Code>filter_list</Code>) 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.
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>input_arguments_names</Code>.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>input_arguments_names</Code>.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
with_given_object_position (optional): One of the following strings: <Code>"Source"</Code>, <Code>"Range"</Code>, or <Code>"both"</Code>.
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).
</Item>
</List>
<P/>
<List>
<Item>
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 <Code>IsEqualForObjects</Code> and <Code>IsCongruentForMorphisms</Code> if the input changes with regard to <Code>IsEqualForObjects</Code> and <Code>IsCongruentForMorphisms</Code>.
</Item>
</List>
<P/>
</Section>
<Section Label="Chapter_Add_Functions_Section_Enhancing_the_method_name_record">
<Heading>Enhancing the method name record</Heading>
<P/>
The function CAP_INTERNAL_ENHANCE_NAME_RECORD can be applied to a method name record to make the following enhancements:
<P/>
<List>
<Item>
Function name: Set the component function_name to the entry name.
</Item>
</List>
<P/>
<List>
<Item>
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.
</Item>
</List>
<P/>
<List>
<Item>
Redirect and post functions are created for all operations belonging to universal constructions (e.g. <Code>KernelLift</Code>) which are not a WithGiven operation.
</Item>
</List>
<P/>
</Section>
<P/>
<ManSection>
<Func Arg="prepare_function, category, func" Name="CAPOperationPrepareFunction" />
<Returns>a function
</Returns>
<Description>
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
<C>"BinaryDirectSumToDirectSum"</C> as <A>prepare_function</A>, the category, and
the binary direct sum function. The function then returns a function that can be used
for the direct sum categorical operation.
<P/>
Note that <A>func</A> is not handled by the CAP caching mechanism and that the use
of prepare functions is incompatible with <C>WithGiven</C> operations. Thus, one has
to ensure manually that the equality and typing specifications are fulfilled.
</Description>
</ManSection>
<ManSection>
<Func Arg="prepare_function, name, doc_string[, precondition_list]" Name="CAPAddPrepareFunction" />
<Description>
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 <A>name</A> is the name of the prepare function, which is used in <C>CAPOperationPrepareFunction</C>.
The argument <A>doc_string</A> should be a short string describing the functions.
The optional argument <A>precondition_list</A> 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 <A>precondition_list</A> is only necessary if the function needed is not explicitly
used in the prepare function, e.g., if you use <C>+</C> instead of <C>AdditionForMorphisms</C>.
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group16">
<Oper Arg="C, F" Name="AddAdditionForMorphisms" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddAdditionForMorphisms" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>AdditionForMorphisms</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, beta ) \mapsto \mathtt{AdditionForMorphisms}(alpha, beta)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group17">
<Oper Arg="C, F" Name="AddAdditiveGenerators" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddAdditiveGenerators" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>AdditiveGenerators</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( ) \mapsto \mathtt{AdditiveGenerators}()</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group18">
<Oper Arg="C, F" Name="AddAdditiveInverseForMorphisms" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddAdditiveInverseForMorphisms" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>AdditiveInverseForMorphisms</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{AdditiveInverseForMorphisms}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group19">
<Oper Arg="C, F" Name="AddAstrictionToCoimage" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddAstrictionToCoimage" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>AstrictionToCoimage</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{AstrictionToCoimage}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group20">
<Oper Arg="C, F" Name="AddAstrictionToCoimageWithGivenCoimageObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddAstrictionToCoimageWithGivenCoimageObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>AstrictionToCoimageWithGivenCoimageObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, C ) \mapsto \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group21">
<Oper Arg="C, F" Name="AddBasisOfExternalHom" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddBasisOfExternalHom" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>BasisOfExternalHom</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfExternalHom}(arg2, arg3)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group22">
<Oper Arg="C, F" Name="AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2, arg3, arg4, arg5 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2, arg3, arg4, arg5)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group23">
<Oper Arg="C, F" Name="AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2, arg3)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group24">
<Oper Arg="C, F" Name="AddCoastrictionToImage" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoastrictionToImage" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoastrictionToImage</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{CoastrictionToImage}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group25">
<Oper Arg="C, F" Name="AddCoastrictionToImageWithGivenImageObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoastrictionToImageWithGivenImageObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoastrictionToImageWithGivenImageObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, I ) \mapsto \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group26">
<Oper Arg="C, F" Name="AddCoefficientsOfMorphism" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoefficientsOfMorphism" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoefficientsOfMorphism</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2 ) \mapsto \mathtt{CoefficientsOfMorphism}(arg2)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group27">
<Oper Arg="C, F" Name="AddCoequalizer" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoequalizer" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>Coequalizer</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( Y, morphisms ) \mapsto \mathtt{Coequalizer}(Y, morphisms)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group28">
<Oper Arg="C, F" Name="AddCoequalizerFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoequalizerFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoequalizerFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{CoequalizerFunctorial}(morphisms, mu, morphismsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group29">
<Oper Arg="C, F" Name="AddCoequalizerFunctorialWithGivenCoequalizers" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoequalizerFunctorialWithGivenCoequalizers" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoequalizerFunctorialWithGivenCoequalizers</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P, morphisms, mu, morphismsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group30">
<Oper Arg="C, F" Name="AddCoimageObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoimageObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoimageObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2 ) \mapsto \mathtt{CoimageObject}(arg2)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group31">
<Oper Arg="C, F" Name="AddCoimageObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoimageObjectFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoimageObjectFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group32">
<Oper Arg="C, F" Name="AddCoimageObjectFunctorialWithGivenCoimageObjects" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoimageObjectFunctorialWithGivenCoimageObjects" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoimageObjectFunctorialWithGivenCoimageObjects</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( C, alpha, mu, alphap, Cp ) \mapsto \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C, alpha, mu, alphap, Cp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group33">
<Oper Arg="C, F" Name="AddCoimageProjection" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoimageProjection" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoimageProjection</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{CoimageProjection}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group34">
<Oper Arg="C, F" Name="AddCoimageProjectionWithGivenCoimageObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoimageProjectionWithGivenCoimageObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoimageProjectionWithGivenCoimageObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, C ) \mapsto \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group35">
<Oper Arg="C, F" Name="AddCokernelColift" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelColift" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelColift</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, T, tau ) \mapsto \mathtt{CokernelColift}(alpha, T, tau)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group36">
<Oper Arg="C, F" Name="AddCokernelColiftWithGivenCokernelObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelColiftWithGivenCokernelObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelColiftWithGivenCokernelObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, T, tau, P ) \mapsto \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group37">
<Oper Arg="C, F" Name="AddCokernelObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{CokernelObject}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group38">
<Oper Arg="C, F" Name="AddCokernelObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelObjectFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelObjectFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group39">
<Oper Arg="C, F" Name="AddCokernelObjectFunctorialWithGivenCokernelObjects" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelObjectFunctorialWithGivenCokernelObjects"Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelObjectFunctorialWithGivenCokernelObjects</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, alpha, mu, alphap, Pp ) \mapsto \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P, alpha, mu, alphap, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group40">
<Oper Arg="C, F" Name="AddCokernelProjection" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelProjection" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelProjection</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha ) \mapsto \mathtt{CokernelProjection}(alpha)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group41">
<Oper Arg="C, F" Name="AddCokernelProjectionWithGivenCokernelObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCokernelProjectionWithGivenCokernelObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CokernelProjectionWithGivenCokernelObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, P ) \mapsto \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group42">
<Oper Arg="C, F" Name="AddColift" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddColift" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>Colift</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group43">
<Oper Arg="C, F" Name="AddColiftAlongEpimorphism" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddColiftAlongEpimorphism" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>ColiftAlongEpimorphism</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( epsilon, tau ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group44">
<Oper Arg="C, F" Name="AddComponentOfMorphismFromCoproduct" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddComponentOfMorphismFromCoproduct" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>ComponentOfMorphismFromCoproduct</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, I, i ) \mapsto \mathtt{ComponentOfMorphismFromCoproduct}(alpha, I, i)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group45">
<Oper Arg="C, F" Name="AddComponentOfMorphismFromDirectSum" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddComponentOfMorphismFromDirectSum" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>ComponentOfMorphismFromDirectSum</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group46">
<Oper Arg="C, F" Name="AddComponentOfMorphismIntoDirectProduct" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddComponentOfMorphismIntoDirectProduct" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>ComponentOfMorphismIntoDirectProduct</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, P, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectProduct}(alpha, P, i)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group47">
<Oper Arg="C, F" Name="AddComponentOfMorphismIntoDirectSum" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddComponentOfMorphismIntoDirectSum" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>ComponentOfMorphismIntoDirectSum</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group48">
<Oper Arg="C, F" Name="AddCoproduct" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoproduct" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>Coproduct</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects ) \mapsto \mathtt{Coproduct}(objects)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group49">
<Oper Arg="C, F" Name="AddCoproductFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoproductFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoproductFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects, L, objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group50">
<Oper Arg="C, F" Name="AddCoproductFunctorialWithGivenCoproducts" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddCoproductFunctorialWithGivenCoproducts" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>CoproductFunctorialWithGivenCoproducts</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{CoproductFunctorialWithGivenCoproducts}(P, objects, L, objectsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group51">
<Oper Arg="C, F" Name="AddDirectProduct" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectProduct" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectProduct</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects ) \mapsto \mathtt{DirectProduct}(objects)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group52">
<Oper Arg="C, F" Name="AddDirectProductFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectProductFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectProductFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects, L, objectsp ) \mapsto \mathtt{DirectProductFunctorial}(objects, L, objectsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group53">
<Oper Arg="C, F" Name="AddDirectProductFunctorialWithGivenDirectProducts" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectProductFunctorialWithGivenDirectProducts" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectProductFunctorialWithGivenDirectProducts</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P, objects, L, objectsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group54">
<Oper Arg="C, F" Name="AddDirectSum" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectSum" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectSum</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects ) \mapsto \mathtt{DirectSum}(objects)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group55">
<Oper Arg="C, F" Name="AddDirectSumFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectSumFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectSumFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( objects, L, objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group56">
<Oper Arg="C, F" Name="AddDirectSumFunctorialWithGivenDirectSums" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDirectSumFunctorialWithGivenDirectSums" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DirectSumFunctorialWithGivenDirectSums</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, objects, L, objectsp, Pp ) \mapsto \mathtt{DirectSumFunctorialWithGivenDirectSums}(P, objects, L, objectsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group57">
<Oper Arg="C, F" Name="AddDistinguishedObjectOfHomomorphismStructure" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddDistinguishedObjectOfHomomorphismStructure" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>DistinguishedObjectOfHomomorphismStructure</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}()</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group58">
<Oper Arg="C, F" Name="AddEmbeddingOfEqualizer" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEmbeddingOfEqualizer" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EmbeddingOfEqualizer</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( Y, morphisms ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group59">
<Oper Arg="C, F" Name="AddEmbeddingOfEqualizerWithGivenEqualizer" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEmbeddingOfEqualizerWithGivenEqualizer" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EmbeddingOfEqualizerWithGivenEqualizer</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( Y, morphisms, P ) \mapsto \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group60">
<Oper Arg="C, F" Name="AddEpimorphismFromProjectiveCoverObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEpimorphismFromProjectiveCoverObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EpimorphismFromProjectiveCoverObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group61">
<Oper Arg="C, F" Name="AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( A, P ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A, P)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group62">
<Oper Arg="C, F" Name="AddEpimorphismFromSomeProjectiveObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEpimorphismFromSomeProjectiveObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EpimorphismFromSomeProjectiveObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( A ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group63">
<Oper Arg="C, F" Name="AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( A, P ) \mapsto \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A, P)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group64">
<Oper Arg="C, F" Name="AddEqualizer" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEqualizer" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>Equalizer</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( Y, morphisms ) \mapsto \mathtt{Equalizer}(Y, morphisms)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group65">
<Oper Arg="C, F" Name="AddEqualizerFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEqualizerFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EqualizerFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( morphisms, mu, morphismsp ) \mapsto \mathtt{EqualizerFunctorial}(morphisms, mu, morphismsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group66">
<Oper Arg="C, F" Name="AddEqualizerFunctorialWithGivenEqualizers" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddEqualizerFunctorialWithGivenEqualizers" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>EqualizerFunctorialWithGivenEqualizers</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, morphisms, mu, morphismsp, Pp ) \mapsto \mathtt{EqualizerFunctorialWithGivenEqualizers}(P, morphisms, mu, morphismsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group67">
<Oper Arg="C, F" Name="AddFiberProduct" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddFiberProduct" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>FiberProduct</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( morphisms ) \mapsto \mathtt{FiberProduct}(morphisms)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group68">
<Oper Arg="C, F" Name="AddFiberProductFunctorial" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddFiberProductFunctorial" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>FiberProductFunctorial</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( morphisms, L, morphismsp ) \mapsto \mathtt{FiberProductFunctorial}(morphisms, L, morphismsp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group69">
<Oper Arg="C, F" Name="AddFiberProductFunctorialWithGivenFiberProducts" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddFiberProductFunctorialWithGivenFiberProducts" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>FiberProductFunctorialWithGivenFiberProducts</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P, morphisms, L, morphismsp, Pp)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group70">
<Oper Arg="C, F" Name="AddHomologyObject" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHomologyObject" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HomologyObject</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, beta ) \mapsto \mathtt{HomologyObject}(alpha, beta)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group71">
<Oper Arg="C, F" Name="AddHomologyObjectFunctorialWithGivenHomologyObjects" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHomologyObjectFunctorialWithGivenHomologyObjects"Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HomologyObjectFunctorialWithGivenHomologyObjects</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( H_1, L, H_2 ) \mapsto \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group72">
<Oper Arg="C, F" Name="AddHomomorphismStructureOnMorphisms" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHomomorphismStructureOnMorphisms" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HomomorphismStructureOnMorphisms</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( alpha, beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group73">
<Oper Arg="C, F" Name="AddHomomorphismStructureOnMorphismsWithGivenObjects" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHomomorphismStructureOnMorphismsWithGivenObjects"Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HomomorphismStructureOnMorphismsWithGivenObjects</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( source, alpha, beta, range ) \mapsto \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source, alpha, beta, range)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group74">
<Oper Arg="C, F" Name="AddHomomorphismStructureOnObjects" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHomomorphismStructureOnObjects" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HomomorphismStructureOnObjects</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
<Math>F: ( arg2, arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3)</Math>.
<P/>
</Description>
</ManSection>
<ManSection Label="AutoDoc_generated_group75">
<Oper Arg="C, F" Name="AddHorizontalPostCompose" Label="for IsCapCategory, IsFunction"/>
<Oper Arg="C, F, weight" Name="AddHorizontalPostCompose" Label="for IsCapCategory, IsFunction, IsInt"/>
<Returns>nothing
</Returns>
<Description>
The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
This operation adds the given function <Math>F</Math>
to the category for the basic operation <Code>HorizontalPostCompose</Code>.
Optionally, a weight (default: 100) can be specified which should roughly correspond
to the computational complexity of the function (lower weight = less complex = faster execution).
--> --------------------
--> maximum size reached
--> --------------------
¤ Dauer der Verarbeitung: 0.10 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
