Quellcode-Bibliothek _Chapter_Add_Functions.xml   Sprache: XML

<?xml version="1.0" encoding="UTF-8"?>

<!-- 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>


<Section Label="Chapter_Add_Functions_Section_Add_Method">
<Heading>Add Method</Heading>

<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>


<Section Label="Chapter_Add_Functions_Section_Prepare_functions">
<Heading>Prepare functions</Heading>

<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>
  <Func Arg="arg" Name="ListCAPPrepareFunctions" />
 <Description>
  Lists all prepare functions.
 </Description>
</ManSection>


</Section>


<Section Label="Chapter_Add_Functions_Section_Available_Add_functions">
<Heading>Available Add functions</Heading>

<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).
 <Math>F: ( arg2, arg3 ) \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group76">
  <Oper Arg="C, F" Name="AddHorizontalPreCompose" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddHorizontalPreCompose" 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>HorizontalPreCompose</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{HorizontalPreCompose}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group77">
  <Oper Arg="C, F" Name="AddIdentityMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIdentityMorphism" 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>IdentityMorphism</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{IdentityMorphism}(a)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group78">
  <Oper Arg="C, F" Name="AddIdentityTwoCell" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIdentityTwoCell" 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>IdentityTwoCell</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{IdentityTwoCell}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group79">
  <Oper Arg="C, F" Name="AddImageEmbedding" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddImageEmbedding" 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>ImageEmbedding</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{ImageEmbedding}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group80">
  <Oper Arg="C, F" Name="AddImageEmbeddingWithGivenImageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddImageEmbeddingWithGivenImageObject" 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>ImageEmbeddingWithGivenImageObject</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{ImageEmbeddingWithGivenImageObject}(alpha, I)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group81">
  <Oper Arg="C, F" Name="AddImageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddImageObject" 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>ImageObject</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{ImageObject}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group82">
  <Oper Arg="C, F" Name="AddImageObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddImageObjectFunctorial" 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>ImageObjectFunctorial</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, nu, alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group83">
  <Oper Arg="C, F" Name="AddImageObjectFunctorialWithGivenImageObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddImageObjectFunctorialWithGivenImageObjects" 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>ImageObjectFunctorialWithGivenImageObjects</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: ( I, alpha, nu, alphap, Ip ) \mapsto \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I, alpha, nu, alphap, Ip)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group84">
  <Oper Arg="C, F" Name="AddIndecomposableInjectiveObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIndecomposableInjectiveObjects" 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>IndecomposableInjectiveObjects</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{IndecomposableInjectiveObjects}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group85">
  <Oper Arg="C, F" Name="AddIndecomposableProjectiveObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIndecomposableProjectiveObjects" 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>IndecomposableProjectiveObjects</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{IndecomposableProjectiveObjects}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group86">
  <Oper Arg="C, F" Name="AddInitialObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInitialObject" 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>InitialObject</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{InitialObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group87">
  <Oper Arg="C, F" Name="AddInitialObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInitialObjectFunctorial" 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>InitialObjectFunctorial</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{InitialObjectFunctorial}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group88">
  <Oper Arg="C, F" Name="AddInitialObjectFunctorialWithGivenInitialObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInitialObjectFunctorialWithGivenInitialObjects" 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>InitialObjectFunctorialWithGivenInitialObjects</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, Pp ) \mapsto \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group89">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfCoproduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfCoproduct" 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>InjectionOfCofactorOfCoproduct</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, k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group90">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfCoproductWithGivenCoproduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfCoproductWithGivenCoproduct" 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>InjectionOfCofactorOfCoproductWithGivenCoproduct</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, k, P ) \mapsto \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group91">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfDirectSum" 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>InjectionOfCofactorOfDirectSum</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, k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group92">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfDirectSumWithGivenDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfDirectSumWithGivenDirectSum" 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>InjectionOfCofactorOfDirectSumWithGivenDirectSum</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, k, P ) \mapsto \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group93">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfPushout" 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>InjectionOfCofactorOfPushout</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, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group94">
  <Oper Arg="C, F" Name="AddInjectionOfCofactorOfPushoutWithGivenPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectionOfCofactorOfPushoutWithGivenPushout" 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>InjectionOfCofactorOfPushoutWithGivenPushout</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, k, P ) \mapsto \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group95">
  <Oper Arg="C, F" Name="AddInjectiveColift" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectiveColift" 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>InjectiveColift</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{InjectiveColift}(alpha, beta)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group96">
  <Oper Arg="C, F" Name="AddInjectiveDimension" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectiveDimension" 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>InjectiveDimension</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{InjectiveDimension}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group97">
  <Oper Arg="C, F" Name="AddInjectiveEnvelopeObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInjectiveEnvelopeObject" 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>InjectiveEnvelopeObject</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{InjectiveEnvelopeObject}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group98">
  <Oper Arg="C, F" Name="AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure" 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>InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure</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{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group99">
  <Oper Arg="C, F" Name="AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects" 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>InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects</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, range ) \mapsto \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source, alpha, range)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group100">
  <Oper Arg="C, F" Name="AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism" 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>InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism</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, range, alpha ) \mapsto \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source, range, alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group101">
  <Oper Arg="C, F" Name="AddInverseForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInverseForMorphisms" 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>InverseForMorphisms</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{InverseForMorphisms}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group102">
  <Oper Arg="C, F" Name="AddInverseOfMorphismFromCoimageToImage" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInverseOfMorphismFromCoimageToImage" 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>InverseOfMorphismFromCoimageToImage</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{InverseOfMorphismFromCoimageToImage}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group103">
  <Oper Arg="C, F" Name="AddInverseOfMorphismFromCoimageToImageWithGivenObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddInverseOfMorphismFromCoimageToImageWithGivenObjects" 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>InverseOfMorphismFromCoimageToImageWithGivenObjects</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: ( I, alpha, C ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImageWithGivenObjects}(I, alpha, C)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group104">
  <Oper Arg="C, F" Name="AddIsAutomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsAutomorphism" 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>IsAutomorphism</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{IsAutomorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group105">
  <Oper Arg="C, F" Name="AddIsBijectiveObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsBijectiveObject" 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>IsBijectiveObject</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{IsBijectiveObject}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group106">
  <Oper Arg="C, F" Name="AddIsCodominating" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsCodominating" 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>IsCodominating</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{IsCodominating}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group107">
  <Oper Arg="C, F" Name="AddIsColiftable" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsColiftable" 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>IsColiftable</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{IsColiftable}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group108">
  <Oper Arg="C, F" Name="AddIsColiftableAlongEpimorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsColiftableAlongEpimorphism" 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>IsColiftableAlongEpimorphism</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{IsColiftableAlongEpimorphism}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group109">
  <Oper Arg="C, F" Name="AddIsCongruentForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsCongruentForMorphisms" 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>IsCongruentForMorphisms</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{IsCongruentForMorphisms}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group110">
  <Oper Arg="C, F" Name="AddIsDominating" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsDominating" 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>IsDominating</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{IsDominating}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group111">
  <Oper Arg="C, F" Name="AddIsEndomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEndomorphism" 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>IsEndomorphism</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{IsEndomorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group112">
  <Oper Arg="C, F" Name="AddIsEpimorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEpimorphism" 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>IsEpimorphism</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{IsEpimorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group113">
  <Oper Arg="C, F" Name="AddIsEqualAsFactorobjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualAsFactorobjects" 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>IsEqualAsFactorobjects</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{IsEqualAsFactorobjects}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group114">
  <Oper Arg="C, F" Name="AddIsEqualAsSubobjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualAsSubobjects" 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>IsEqualAsSubobjects</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{IsEqualAsSubobjects}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group115">
  <Oper Arg="C, F" Name="AddIsEqualForCacheForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualForCacheForMorphisms" 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>IsEqualForCacheForMorphisms</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{IsEqualForCacheForMorphisms}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group116">
  <Oper Arg="C, F" Name="AddIsEqualForCacheForObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualForCacheForObjects" 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>IsEqualForCacheForObjects</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{IsEqualForCacheForObjects}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group117">
  <Oper Arg="C, F" Name="AddIsEqualForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualForMorphisms" 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>IsEqualForMorphisms</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{IsEqualForMorphisms}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group118">
  <Oper Arg="C, F" Name="AddIsEqualForMorphismsOnMor" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualForMorphismsOnMor" 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>IsEqualForMorphismsOnMor</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{IsEqualForMorphismsOnMor}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group119">
  <Oper Arg="C, F" Name="AddIsEqualForObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualForObjects" 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>IsEqualForObjects</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{IsEqualForObjects}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group120">
  <Oper Arg="C, F" Name="AddIsEqualToIdentityMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualToIdentityMorphism" 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>IsEqualToIdentityMorphism</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{IsEqualToIdentityMorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group121">
  <Oper Arg="C, F" Name="AddIsEqualToZeroMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsEqualToZeroMorphism" 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>IsEqualToZeroMorphism</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{IsEqualToZeroMorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group122">
  <Oper Arg="C, F" Name="AddIsHomSetInhabited" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsHomSetInhabited" 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>IsHomSetInhabited</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{IsHomSetInhabited}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group123">
  <Oper Arg="C, F" Name="AddIsIdempotent" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsIdempotent" 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>IsIdempotent</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{IsIdempotent}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group124">
  <Oper Arg="C, F" Name="AddIsInitial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsInitial" 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>IsInitial</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{IsInitial}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group125">
  <Oper Arg="C, F" Name="AddIsInjective" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsInjective" 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>IsInjective</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{IsInjective}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group126">
  <Oper Arg="C, F" Name="AddIsIsomorphicForObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsIsomorphicForObjects" 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>IsIsomorphicForObjects</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: ( object_1, object_2 ) \mapsto \mathtt{IsIsomorphicForObjects}(object_1, object_2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group127">
  <Oper Arg="C, F" Name="AddIsIsomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsIsomorphism" 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>IsIsomorphism</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{IsIsomorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group128">
  <Oper Arg="C, F" Name="AddIsLiftable" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsLiftable" 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>IsLiftable</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{IsLiftable}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group129">
  <Oper Arg="C, F" Name="AddIsLiftableAlongMonomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsLiftableAlongMonomorphism" 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>IsLiftableAlongMonomorphism</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{IsLiftableAlongMonomorphism}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group130">
  <Oper Arg="C, F" Name="AddIsMonomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsMonomorphism" 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>IsMonomorphism</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{IsMonomorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group131">
  <Oper Arg="C, F" Name="AddIsOne" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsOne" 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>IsOne</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{IsOne}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group132">
  <Oper Arg="C, F" Name="AddIsProjective" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsProjective" 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>IsProjective</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{IsProjective}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group133">
  <Oper Arg="C, F" Name="AddIsSplitEpimorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsSplitEpimorphism" 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>IsSplitEpimorphism</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{IsSplitEpimorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group134">
  <Oper Arg="C, F" Name="AddIsSplitMonomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsSplitMonomorphism" 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>IsSplitMonomorphism</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{IsSplitMonomorphism}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group135">
  <Oper Arg="C, F" Name="AddIsTerminal" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsTerminal" 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>IsTerminal</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{IsTerminal}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group136">
  <Oper Arg="C, F" Name="AddIsWellDefinedForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsWellDefinedForMorphisms" 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>IsWellDefinedForMorphisms</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{IsWellDefinedForMorphisms}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group137">
  <Oper Arg="C, F" Name="AddIsWellDefinedForMorphismsWithGivenSourceAndRange" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsWellDefinedForMorphismsWithGivenSourceAndRange" 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>IsWellDefinedForMorphismsWithGivenSourceAndRange</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, range ) \mapsto \mathtt{IsWellDefinedForMorphismsWithGivenSourceAndRange}(source, alpha, range)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group138">
  <Oper Arg="C, F" Name="AddIsWellDefinedForObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsWellDefinedForObjects" 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>IsWellDefinedForObjects</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{IsWellDefinedForObjects}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group139">
  <Oper Arg="C, F" Name="AddIsWellDefinedForTwoCells" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsWellDefinedForTwoCells" 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>IsWellDefinedForTwoCells</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{IsWellDefinedForTwoCells}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group140">
  <Oper Arg="C, F" Name="AddIsZeroForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsZeroForMorphisms" 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>IsZeroForMorphisms</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{IsZeroForMorphisms}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group141">
  <Oper Arg="C, F" Name="AddIsZeroForObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsZeroForObjects" 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>IsZeroForObjects</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{IsZeroForObjects}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group142">
  <Oper Arg="C, F" Name="AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout" 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>IsomorphismFromCoequalizerOfCoproductDiagramToPushout</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: ( D ) \mapsto \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group143">
  <Oper Arg="C, F" Name="AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct" 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>IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct</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, D ) \mapsto \mathtt{IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group144">
  <Oper Arg="C, F" Name="AddIsomorphismFromCoimageToCokernelOfKernel" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCoimageToCokernelOfKernel" 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>IsomorphismFromCoimageToCokernelOfKernel</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{IsomorphismFromCoimageToCokernelOfKernel}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group145">
  <Oper Arg="C, F" Name="AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer" 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>IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer</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, D ) \mapsto \mathtt{IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group146">
  <Oper Arg="C, F" Name="AddIsomorphismFromCokernelOfKernelToCoimage" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCokernelOfKernelToCoimage" 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>IsomorphismFromCokernelOfKernelToCoimage</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{IsomorphismFromCokernelOfKernelToCoimage}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group147">
  <Oper Arg="C, F" Name="AddIsomorphismFromCoproductToDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromCoproductToDirectSum" 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>IsomorphismFromCoproductToDirectSum</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: ( D ) \mapsto \mathtt{IsomorphismFromCoproductToDirectSum}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group148">
  <Oper Arg="C, F" Name="AddIsomorphismFromDirectProductToDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromDirectProductToDirectSum" 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>IsomorphismFromDirectProductToDirectSum</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: ( D ) \mapsto \mathtt{IsomorphismFromDirectProductToDirectSum}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group149">
  <Oper Arg="C, F" Name="AddIsomorphismFromDirectSumToCoproduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromDirectSumToCoproduct" 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>IsomorphismFromDirectSumToCoproduct</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: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToCoproduct}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group150">
  <Oper Arg="C, F" Name="AddIsomorphismFromDirectSumToDirectProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromDirectSumToDirectProduct" 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>IsomorphismFromDirectSumToDirectProduct</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: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToDirectProduct}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group151">
  <Oper Arg="C, F" Name="AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct" 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>IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct</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: ( D ) \mapsto \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group152">
  <Oper Arg="C, F" Name="AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct" 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>IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct</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, D ) \mapsto \mathtt{IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group153">
  <Oper Arg="C, F" Name="AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram" 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>IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram</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: ( D ) \mapsto \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group154">
  <Oper Arg="C, F" Name="AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject" 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>IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject</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{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha, beta)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group155">
  <Oper Arg="C, F" Name="AddIsomorphismFromImageObjectToKernelOfCokernel" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromImageObjectToKernelOfCokernel" 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>IsomorphismFromImageObjectToKernelOfCokernel</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{IsomorphismFromImageObjectToKernelOfCokernel}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group156">
  <Oper Arg="C, F" Name="AddIsomorphismFromInitialObjectToZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromInitialObjectToZeroObject" 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>IsomorphismFromInitialObjectToZeroObject</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{IsomorphismFromInitialObjectToZeroObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group157">
  <Oper Arg="C, F" Name="AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject" 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>IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject</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{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha, beta)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group158">
  <Oper Arg="C, F" Name="AddIsomorphismFromKernelOfCokernelToImageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromKernelOfCokernelToImageObject" 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>IsomorphismFromKernelOfCokernelToImageObject</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{IsomorphismFromKernelOfCokernelToImageObject}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group159">
  <Oper Arg="C, F" Name="AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer" 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>IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer</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, D ) \mapsto \mathtt{IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group160">
  <Oper Arg="C, F" Name="AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram" 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>IsomorphismFromPushoutToCoequalizerOfCoproductDiagram</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: ( D ) \mapsto \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group161">
  <Oper Arg="C, F" Name="AddIsomorphismFromTerminalObjectToZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromTerminalObjectToZeroObject" 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>IsomorphismFromTerminalObjectToZeroObject</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{IsomorphismFromTerminalObjectToZeroObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group162">
  <Oper Arg="C, F" Name="AddIsomorphismFromZeroObjectToInitialObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromZeroObjectToInitialObject" 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>IsomorphismFromZeroObjectToInitialObject</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{IsomorphismFromZeroObjectToInitialObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group163">
  <Oper Arg="C, F" Name="AddIsomorphismFromZeroObjectToTerminalObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddIsomorphismFromZeroObjectToTerminalObject" 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>IsomorphismFromZeroObjectToTerminalObject</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{IsomorphismFromZeroObjectToTerminalObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group164">
  <Oper Arg="C, F" Name="AddJointPairwiseDifferencesOfMorphismsFromCoproduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddJointPairwiseDifferencesOfMorphismsFromCoproduct" 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>JointPairwiseDifferencesOfMorphismsFromCoproduct</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, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group165">
  <Oper Arg="C, F" Name="AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct" 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>JointPairwiseDifferencesOfMorphismsIntoDirectProduct</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, D ) \mapsto \mathtt{JointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group166">
  <Oper Arg="C, F" Name="AddKernelEmbedding" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelEmbedding" 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>KernelEmbedding</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{KernelEmbedding}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group167">
  <Oper Arg="C, F" Name="AddKernelEmbeddingWithGivenKernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelEmbeddingWithGivenKernelObject" 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>KernelEmbeddingWithGivenKernelObject</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{KernelEmbeddingWithGivenKernelObject}(alpha, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group168">
  <Oper Arg="C, F" Name="AddKernelLift" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelLift" 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>KernelLift</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{KernelLift}(alpha, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group169">
  <Oper Arg="C, F" Name="AddKernelLiftWithGivenKernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelLiftWithGivenKernelObject" 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>KernelLiftWithGivenKernelObject</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{KernelLiftWithGivenKernelObject}(alpha, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group170">
  <Oper Arg="C, F" Name="AddKernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelObject" 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>KernelObject</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{KernelObject}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group171">
  <Oper Arg="C, F" Name="AddKernelObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelObjectFunctorial" 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>KernelObjectFunctorial</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{KernelObjectFunctorial}(alpha, mu, alphap)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group172">
  <Oper Arg="C, F" Name="AddKernelObjectFunctorialWithGivenKernelObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddKernelObjectFunctorialWithGivenKernelObjects" 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>KernelObjectFunctorialWithGivenKernelObjects</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{KernelObjectFunctorialWithGivenKernelObjects}(P, alpha, mu, alphap, Pp)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group173">
  <Oper Arg="C, F" Name="AddLift" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddLift" 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>Lift</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{Lift}(alpha, beta)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group174">
  <Oper Arg="C, F" Name="AddLiftAlongMonomorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddLiftAlongMonomorphism" 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>LiftAlongMonomorphism</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: ( iota, tau ) \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group175">
  <Oper Arg="C, F" Name="AddLinearCombinationOfMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddLinearCombinationOfMorphisms" 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>LinearCombinationOfMorphisms</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, list_of_ring_elements, list_of_morphisms, range ) \mapsto \mathtt{LinearCombinationOfMorphisms}(source, list_of_ring_elements, list_of_morphisms, range)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group176">
  <Oper Arg="C, F" Name="AddMereExistenceOfSolutionOfLinearSystemInAbCategory" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMereExistenceOfSolutionOfLinearSystemInAbCategory" 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>MereExistenceOfSolutionOfLinearSystemInAbCategory</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 ) \mapsto \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group177">
  <Oper Arg="C, F" Name="AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory" 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>MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory</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{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group178">
  <Oper Arg="C, F" Name="AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory" 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>MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory</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 ) \mapsto \mathtt{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group179">
  <Oper Arg="C, F" Name="AddMonomorphismIntoInjectiveEnvelopeObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMonomorphismIntoInjectiveEnvelopeObject" 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>MonomorphismIntoInjectiveEnvelopeObject</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{MonomorphismIntoInjectiveEnvelopeObject}(A)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group180">
  <Oper Arg="C, F" Name="AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject" 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>MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject</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, I ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A, I)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group181">
  <Oper Arg="C, F" Name="AddMonomorphismIntoSomeInjectiveObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMonomorphismIntoSomeInjectiveObject" 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>MonomorphismIntoSomeInjectiveObject</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{MonomorphismIntoSomeInjectiveObject}(A)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group182">
  <Oper Arg="C, F" Name="AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject" 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>MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject</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, I ) \mapsto \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A, I)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group183">
  <Oper Arg="C, F" Name="AddMorphismBetweenDirectSums" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismBetweenDirectSums" 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>MorphismBetweenDirectSums</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_diagram, mat, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group184">
  <Oper Arg="C, F" Name="AddMorphismBetweenDirectSumsWithGivenDirectSums" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismBetweenDirectSumsWithGivenDirectSums" 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>MorphismBetweenDirectSumsWithGivenDirectSums</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: ( S, source_diagram, mat, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S, source_diagram, mat, range_diagram, T)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group185">
  <Oper Arg="C, F" Name="AddMorphismConstructor" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismConstructor" 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>MorphismConstructor</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 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group186">
  <Oper Arg="C, F" Name="AddMorphismDatum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismDatum" 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>MorphismDatum</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{MorphismDatum}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group187">
  <Oper Arg="C, F" Name="AddMorphismFromCoimageToImage" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromCoimageToImage" 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>MorphismFromCoimageToImage</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{MorphismFromCoimageToImage}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group188">
  <Oper Arg="C, F" Name="AddMorphismFromCoimageToImageWithGivenObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromCoimageToImageWithGivenObjects" 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>MorphismFromCoimageToImageWithGivenObjects</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, I ) \mapsto \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group189">
  <Oper Arg="C, F" Name="AddMorphismFromEqualizerToSink" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromEqualizerToSink" 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>MorphismFromEqualizerToSink</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{MorphismFromEqualizerToSink}(Y, morphisms)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group190">
  <Oper Arg="C, F" Name="AddMorphismFromEqualizerToSinkWithGivenEqualizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromEqualizerToSinkWithGivenEqualizer" 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>MorphismFromEqualizerToSinkWithGivenEqualizer</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{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group191">
  <Oper Arg="C, F" Name="AddMorphismFromFiberProductToSink" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromFiberProductToSink" 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>MorphismFromFiberProductToSink</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{MorphismFromFiberProductToSink}(morphisms)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group192">
  <Oper Arg="C, F" Name="AddMorphismFromFiberProductToSinkWithGivenFiberProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromFiberProductToSinkWithGivenFiberProduct" 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>MorphismFromFiberProductToSinkWithGivenFiberProduct</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, P ) \mapsto \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group193">
  <Oper Arg="C, F" Name="AddMorphismFromKernelObjectToSink" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromKernelObjectToSink" 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>MorphismFromKernelObjectToSink</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{MorphismFromKernelObjectToSink}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group194">
  <Oper Arg="C, F" Name="AddMorphismFromKernelObjectToSinkWithGivenKernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromKernelObjectToSinkWithGivenKernelObject" 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>MorphismFromKernelObjectToSinkWithGivenKernelObject</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{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group195">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToCoequalizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToCoequalizer" 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>MorphismFromSourceToCoequalizer</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{MorphismFromSourceToCoequalizer}(Y, morphisms)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group196">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToCoequalizerWithGivenCoequalizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToCoequalizerWithGivenCoequalizer" 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>MorphismFromSourceToCoequalizerWithGivenCoequalizer</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{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y, morphisms, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group197">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToCokernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToCokernelObject" 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>MorphismFromSourceToCokernelObject</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{MorphismFromSourceToCokernelObject}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group198">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject" 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>MorphismFromSourceToCokernelObjectWithGivenCokernelObject</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{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group199">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToPushout" 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>MorphismFromSourceToPushout</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{MorphismFromSourceToPushout}(morphisms)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group200">
  <Oper Arg="C, F" Name="AddMorphismFromSourceToPushoutWithGivenPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismFromSourceToPushoutWithGivenPushout" 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>MorphismFromSourceToPushoutWithGivenPushout</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, P ) \mapsto \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group201">
  <Oper Arg="C, F" Name="AddMorphismsOfExternalHom" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMorphismsOfExternalHom" 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>MorphismsOfExternalHom</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{MorphismsOfExternalHom}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group202">
  <Oper Arg="C, F" Name="AddMultiplyWithElementOfCommutativeRingForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddMultiplyWithElementOfCommutativeRingForMorphisms" 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>MultiplyWithElementOfCommutativeRingForMorphisms</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: ( r, alpha ) \mapsto \mathtt{MultiplyWithElementOfCommutativeRingForMorphisms}(r, alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group203">
  <Oper Arg="C, F" Name="AddObjectConstructor" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddObjectConstructor" 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>ObjectConstructor</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{ObjectConstructor}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group204">
  <Oper Arg="C, F" Name="AddObjectDatum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddObjectDatum" 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>ObjectDatum</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{ObjectDatum}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group205">
  <Oper Arg="C, F" Name="AddPostCompose" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPostCompose" 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>PostCompose</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: ( beta, alpha ) \mapsto \mathtt{PostCompose}(beta, alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group206">
  <Oper Arg="C, F" Name="AddPostComposeList" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPostComposeList" 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>PostComposeList</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, list_of_morphisms, range ) \mapsto \mathtt{PostComposeList}(source, list_of_morphisms, range)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group207">
  <Oper Arg="C, F" Name="AddPostInverseForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPostInverseForMorphisms" 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>PostInverseForMorphisms</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{PostInverseForMorphisms}(alpha)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group208">
  <Oper Arg="C, F" Name="AddPreCompose" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPreCompose" 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>PreCompose</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{PreCompose}(alpha, beta)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group209">
  <Oper Arg="C, F" Name="AddPreComposeList" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPreComposeList" 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>PreComposeList</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, list_of_morphisms, range ) \mapsto \mathtt{PreComposeList}(source, list_of_morphisms, range)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group210">
  <Oper Arg="C, F" Name="AddPreInverseForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddPreInverseForMorphisms" 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>PreInverseForMorphisms</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{PreInverseForMorphisms}(alpha)</Math>.
<P/>
 </Description>
</


<ManSection Label="AutoDoc_generated_group211">
<Arg"java.lang.StringIndexOutOfBoundsException: Range [102, 103) out of bounds for length 102
  O Arg"C,F weight"Name=AddProjectionInFactorOfDirectProduct" ,  IsInt/java.lang.StringIndexOutOfBoundsException: Index 117 out of bounds for length 117
R>nothing# nsIScriptElement
<Returns
 <static_assertsn <=)
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given 
 to the category for the basic operation <Code>ProjectionInFactorOfDirectProduct</Code>.
 Optionally, a weight (defaultif(aCurrentDoc==java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 50
 to the computational omplexity  function l = lesscomplex = faster execution.
 <Math      mDocument>)
<
 </Description>
  ;


<ManSection Label="AutoDoc_generated_group212">
  OperArg", = "IsCapCategory, IsFunction">
  <Oper Arg="C, F, weight" Name="AddProjectionInFactorOfDirectProductWithGivenDirectProduct" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</      deletejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 36
 <escription
     operator)&java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 59
This given <ath><Mathjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }
  operator)opAppendText aOperation {

<ath>:   k   mapsto mathtt{rojectionInFactorOfDirectProductWithGivenDirectProductobjects,k,P<Math.
<P/>
 </Description>
</ManSection


<ManSection Label=""
onInFactorOfDirectSumLabel=forIsCapCategoryjava.lang.StringIndexOutOfBoundsException: Range [96, 95) out of bounds for length 98
"java.lang.StringIndexOutOfBoundsException: Range [73, 65) out of bounds for length 113
 <Returns>nothing
</Returns>
 <Description>
 
 This operation adds the given function <Math>F</Math>
 to the category for thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 Optionally, a weight (default: 100) can be
 to the computational complexity of the function (lower weight = less complex java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 <Mathjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<Poperator((onst java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 65
 </voidoperator)opSetStyleLineNumberjava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 62
<}


<ManSection Label="AutoDoc_generated_group214">
  <Operjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  <Oper Arg="C
 <Returns>nothing
<    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
D>
 The        .>)
given MF/java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
 to the category for the basic operation <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 Optionally, a weight (default: 100) can be specified which java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 0
 to the computational complexity of the function (lower weight = less complex java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<>F  ,k   \athttjava.lang.StringIndexOutOfBoundsException: Range [93, 91) out of bounds for length 115
<P/>
 /escription
</ManSection>


<ManSection   uint32_toldLength java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 47
  <Oper Arg="C,  MutationObservers:aTextNode,info;
  <Oper Arg="C, F, weight" Name="AddProjectionInFactorOfFiberProduct" Label="for IsCapCategory, IsFunction, IsInt"  (, ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
</java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 <Description>
 The arguments are a category <Math>C</Math> and a function  nsresult  =NS_OK;
 This operation && lastChild-) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 to the category for the basic operation <Code>    return AppendTextToTextNode(aBuffer, aLength, lastChild->GetAsText
    d:) canbespecifiedwhichshould correspond
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms, k)</Math>.
<P/>
 >
</ManSection>


<ManSection Label="AutoDoc_generated_group216">
  <Oper Arg="C, F" Name="AddProjectionInFactorOfFiberProductWithGivenFiberProduct" Label="java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 73
  <Oper Arg="C, F, MOZ_ASSERT!Node-G);
 <Returns>nothing
</Returns>
 <Description>
 The area MC/ath> afunction <athF/.
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>ProjectionInFactorOfFiberProductWithGivenFiberProduct</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly correspond
  function(ower =  complex= execution)
 <Math>F: ( morphisms, k, P ) \mapsto \mathtt        aParent  Mjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 71
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group217">
 Ojava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 94
  <Oper Arg="C, F, weight" Name="AddProjectionOntoCoequalizer" Label="for IsCapCategory, IsFunction, IsInt"/>
 <njava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
</Returns>
 <// But see https://github.com/whatwg/html/issues/12494
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 This operation adds the given function <Math>F</  MaybeAutoCEReaction>autoCEReaction;
 to the category for the basic operation <Code>ProjectionOntoCoequalizer</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 56
 to complexity of the function(ower weight = less complex =execution.
 <Math>F: ( Y, morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms)</Math>.
</
 <java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
<java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13


<ManSection
OperArgC "Name"java.lang.StringIndexOutOfBoundsException: Range [80, 73) out of bounds for length 114
  <Oper Arg="C, F, weight" Name="AddProjectionOntoCoequalizerWithGivenCoequalizer" Label="for IsCapCategory, IsFunction, IsInt"/>
 =>()java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
<Returnsjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 <Description>
 The arguments are a 
 This 
 basic<Code</ode.
 Optionally, a weight (default  doc>ppendChildTo( false rv;
 to the computational complexity of    aNode>java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 34
,)m{java.lang.StringIndexOutOfBoundsException: Range [107, 91) out of bounds for length 117
<P/>
 </   (!doc-DOMNotificationsSuspended()) {
</ManSection>


  }
  <Oper Arg="C, Sforgot  blockscripts)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  <Oper Arg="C, F, weight" Name="MakeAndAddRef<nsDocElementCreatedNotificationRunner>(doc));
 <Returns>nothing
</
 <Description>
 The arguments are a category <Math>C</Math      returnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>ProjectiveCoverObject</Code>.
 Optionally, a weight (default: 100) can be specified}
 tothe complexityof  (lowerweight  lesscomplex = )
 <Math>F: ( arg2 ) \mapsto \mathtt{ProjectiveCoverObject}(arg2)</Math>.
<P/>
 </Description>
<MOZ_ASSERT(>IsInDocUpdate);


<ManSection Label="AutoDoc_generated_group220">
  <Oper Arg="C, F" Name="AddProjectiveDimension" Label="for IsCapCategory, IsFunction"/>
  mension"Label"forIsCapCategory,IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
  arguments are a category <Math>C<Math anda function M></ath>.
 This operation adds the given
the java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 74
 Optionally, a   MOZ_ASSERT(aBuilder;
 to the computational complexity of   java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 77
 <Math>F: (  booldidAppend =false;
<P/
 </Description>
</ManSection,   


 =A>
  <Oper  }
  <Oper Arg="C, F, weight" Name="AddProjectiveLift" Label    didAppend =true
 <Returns>nothingMutationObservers::NotifyContentAppended(
</Returns>
 <java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 The arguments are a nsresult nsHtml5TreeOperation::FosterParent(nsIContent* aNode,
 This operation adds the given function <nsIContent 
 to the category for the basic operation <Code>ProjectiveLift</Code>.aBuilder;
 Optionally, a weight (default: 100  if (OZ_UNLIKELY(Node-GetParentNode() {
 to the computational complexity of     if (MOZ_UNLIKELY(aNode->GetParentNode
 Math:(alpha,beta )m\mathtt{rojectiveLift}a,beta)/Math>.
<P/>
 <Description
</     aTable-java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 43


<ManSection Label="AutoDoc_generated_group222">
 <Arg=",FN=AddPushout "or  java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 76
  <Oper Arg="}
 <Returns>nothing
<Returns
 <Description>
 Thereturn.java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
 Thisfoster  :java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 70
 to the category for the basic   
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 98
 <Math>F: ( morphisms ) \mapsto \mathtt{Pushout}(morphisms)</Math>.
<P    
 </Description>
</ManSection>


<ManSection Label="                                          java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 80
  <Oper Arg="C, F" Name="AddPushoutFunctorial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name=  updatenode-OwnerDoc) java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 74
 <Returns>nothing
</Returns>
 <Description>
 The arguments         (localName! nsGkAtoms:nonce) {
 This operation adds the given function <Math>F</Math>
 to the category for       // allocation.
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 85
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( morphisms, L, morphismsp ) \mapsto \mathtt{PushoutFunctorial        -(NameSpaceID_None  nullptr  ,
<P/>
 </Description>
<        


<ManSection Label="AutoDoc_generated_group224">
  <Oper Arg="C, F" Name="java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 3
  <Oper Arg="C, F, weight" Name="AddPushoutFunctorialWithGivenPushouts" Label="for java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 52
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a   aElement->ReserveAttributeCjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 49
 This operation adds the    aElement-SetParserHadDuplicateAttributeError;
 to for basic  <CodePushoutFunctorialWithGivenPushoutsCode>
 Optionally, a weight (default: 100) can be specified which should roughly correspondnsHtml5String&val= .)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 to the     if (localName (=nsGkAtoms:_lass 
 <Math>F: ( P, morphisms, L, morphismsp, Pp ) \mapsto \mathtt{PushoutFunctorialWithGivenPushouts}(P,       if(lass) {
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group225">
  <Oper Arg="C, F" Name="AddRandomMorphismByInteger" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddRandomMorphismByInteger"     }else {
 <Returns>nothing
</eturnsjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 <Description>
 The arguments  a category <>C/>andafunction<ath><Math>
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>RandomMorphismByInteger</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computationalcomplexityofthe function(  = complex=  .
 <Math>F: ( n ) \mapsto \mathtt{RandomMorphismByInteger}(n)</Math>.
<P/>
 </Description>
</ManSection>    }


abel=AutoDoc_generated_group226">
  }
  <Oper Arg="C, F, weight" Name="void nsHtml5TreeOperation::SetHTMLElementAttributesFast(
 <Returns>nothing
</Returns>
 <Description>
 The arguments   aElement>java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 49
 This operation adds the given function <Math>F</Math>
 to the category for the  / SetNoNameSpaceAttrOnNewlyCreatedElement calls so that
 Optionally,  // subsequent calls no longer have to check for mapped attribute
 to   complexity of the function l weight=lesscomplex = faster execution).
 <Math>F: ( L ) \mapsto \mathtt{RandomMorphismByList}(L)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group227">
  <Oper Arg="C, F"  aAttributes->MarkAsMovedFrom();
  <Oper Arg="C, F, weight" Name="java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 1
 <Returns>nothing
<>
 <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>RandomMorphismWithFixedRangeByInteger</Code>.
 Optionally, a weight  Document*document=nodeInfo>GetDocument(;
 to the computational complexity of the function (lower weight = less complexif(Attributes){
 <Math>    nsHtml5String is = aAttributes->getValue(nsHtml5AttributeName::ATTR_IS);
<P/>
 </      isi);
<ManSection>


< Label"AutoDoc_generated_group228"java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  <  ifijava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 63
< ",F  "AddRandomMorphismWithFixedRangeByList" Label=for IsCapCategory,IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 aCreator=  ? tagAtom: isAtom;
 to the category for the basic operation <Code>RandomMorphismWithFixedRangeByList</Code>.
Optionallya  (default 100) can be specified which should roughly correspond
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( B,  document >ameAtom(),nodeInfo-N) ;
  }
 </Description>
</ManSection>


<">
  <Oper     } elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 O Arg=",F,weight Name=AddRandomMorphismWithFixedSourceAndRangeByInteger" 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 forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational    }
 <Math>F: ( A, B, n ) \      return;
<P/>
    
</ManSection>


<ManSection Label="AutoDoc_generated_group230">
  <Oper Arg="C, F" Name};
  <Oper Arg="C,    / This will cause custom element constructors to run.
 Returnsnothing
</Returns>
 <Description>
 The arguments are a category        >java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 73
 This operation adds the}
 to the category for the basic operation <Code>RandomMorphismWithFixedSourceAndRangeByList</Code>.
Optionally weightdefault 100 can be  which shouldroughly
 to the computational complexity of     , aBuilder
 <Math>F: ( A, B, L )  nsCOMPtr<sIContent java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
<P/>
 </Description , java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 65
</anSectionjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13


<ManSection Label="AutoDoc_generated_group231">
  <Oper Arg="C, F" Name="AddRandomMorphismWithFixedSourceByInteger" Label="for IsCapCategory, java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 10
  <Oper         ,  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 74
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given  MOZ_ASSERT(S_SUCCEEDED(rv)& xmlElement;
 to the category for the basic operation <Code>RandomMorphismWithFixedSourceByInteger</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, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n)</Math>.
 Element*newContent=newElement-java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 48
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group232">
  <Oper Arg="C, F" Name="AddRandomMorphismWithFixedSourceByList" Label="for IsCapCategory, IsFunction"/>
  <Oper    }
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and
 This adds givenfunction <Math><Math>
 to the category for the basic operation <Code>RandomMorphismWithFixedSourceByList</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    return newContent;
<P/>
 </java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
</ManSection>


<ManSection Label="java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
  <Oper Arg="C, F" Name="AddRandomObjectByInteger" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight"  auto =entry.ameSVG
 <Returns>nothing
</Returns>
 <Description>
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 75
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>RandomObjectByInteger</Code>.
 Optionally, a weight (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 17
 to the computational complexity of
 <Math>F: (      =valMaybeAsAtom(;
<P/>
 </Description>
</ManSection>


<ManSection Label"AutoDoc_generated_group234"java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  <// holder, so a call on `val` is a call on an owning instance of
  <Oper;
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and    }
 This #fdef DEBUG
 to the category for the basic operation <Code>RandomObjectByList</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 1
 the computational complexity of the function (owerweight = less complex   execution)
 <Math>F: ( L ) \mapsto \mathtt{RandomObjectByList}(L)</Math>.
<P/   nsAtom aName,nsHtml5HtmlAttributes* aAttributes,
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group235">
  <Oper Arg="C, F" Name="AddSetOfMorphismsOfFiniteCategory" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F,         aName, nullptr  ::)
 <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    <> nodeInfo =aNodeInfoManager-GetNodeInfo(
 Optionally, a weight (default: 100) can be specified which           :ELEMENT_NODE)
  computationalcomplexity  the function (lower weight = ess =faster execution).
 <Math>F: (  ) \mapsto \mathtt{SetOfMorphismsOfFiniteCategory}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group236">
  <Oper Arg="C,  * newContent =;
  <Oper Arg="C, F, (newElement.orget();
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and {
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code> >java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 51
     newContent->etParserHadDuplicateAttributeError)
 to the computational complexity of the function (lower weight = less complex = faster execution).
 MathF  )\mapsto mathtt{SetOfObjectsOfCategory})/>
<P} {
 </Description>
</ManSection>


M ">
  <Oper Arg="C, F" Name="AddSimplifyEndonewContent->SetAttr(triple.mNamespace,triple.mLocal,triple.mPrefix,
  <Oper Arg="C, F, weight" Name="AddSimplifyEndo" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 The argumentsendif
 This operation adds the given function <Math>F</}
 to  categoryforthe basic operation <SimplifyEndo/>
especifiedwhichroughly correspond
tyof java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 98
 <Math>
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group238">
  <Oper Arg="C, F" Name=formControl>java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 35
  <Oper Arg="C, F, weight" Name="AddSimplifyEndo_IsoFromInputObject" Label      aNode-AsElement()HasAttr(nsGkAtoms::){
 <Returns>nothing
</Returns>
 <Description    ifimage>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 36
 The arguments are a category <Math>C</Math> and a function   }
 This operation adds the given function <Math>F<nsresult nsHtml5TreeOperation:FosterParentText
 to the category for the basic operation <Code>SimplifyEndo_IsoFromInputObject</Code>.
 :100)can bespecified whichshould roughly correspond
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: (   MOZ_ASSERT(aBuilder->IsInDocUpdate();
/
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group239">
  <Oper Arg="C, F" Name="AddSimplifyEndo_IsoToInputObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifyEndo_IsoToInputObject" Label="for IsCapCategory, IsFunction, IsInt"/>
 <eturnsnothing

 Description
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given function <java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
 to the category for the basic operation <Code>SimplifyEndo_IsoToInputObject</Code>.
 Optionally, a weight (default: 100) can be specified which should roughlyMutationObservers:java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
 to the computational complexity of the function (lower weight = less complex
 <Math>F: ( mor, n ) \mapsto \mathtt{java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 1
<P/
 </Description>
</ManSection>


java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47
  <Oper Arg="C, F" Name="AddSimplifyMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
 <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 NS_ENSURE_SUCCESSrv,rv;
 Optionally, a weight (default: 100) can be specified which should roughly correspond
  weight= java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 98
 <Math>F: ( mor, n ) \mapsto \mathtt{SimplifyMorphism}(mor, n)</Math>.
<P/>
 </Description>
<


<ManSection Label="AutoDoc_generated_group241">
  <Oper Arg="C, F" Name=}
  <Oper Arg="C, F, weight" Name="AddSimplifyObjectnsIContent  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 55
 <Returns>nothing
</Returns>
 <nsIContent*: java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 69
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given function <return IsElementOrTemplateContent(tableParentjava.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 78
 to the category for the basic operation <Code>SimplifyObject</Code>.
 Optionally, a weight (default: 100) can be specified which shouldsele>reventExecution)
 to the computational complexity of the function (lower weight = less complex = faster executionMOZ_ASSERTjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 63
 <Math>F: ( A, n ) \mapsto \mathtt{SimplifyObject}(A, n)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group242">
  <Oper Arg="C, F" Name="AddSimplifyObject_IsoFromInputObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, Fjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 68
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given function <Math>Fjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 to the category for  nsIScriptElement> = aNode;
 Optionally, a weight (default: 100) can be specified which should roughly correspond
  if()
 <Math>F: ( A, n ) \mapsto \mathtt{java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 27
<P/>
 </Description>
</ManSection>


<java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 47
  <Oper Arg="C, F" Name="AddSimplifyObject_IsoToInputObject" Label="for IsCapCategory, java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 73
  <Oper Arg="C, F, java.lang.StringIndexOutOfBoundsException: Range [25, 21) out of bounds for length 44
 <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>SimplifyObject_IsoToInputObject</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly correspond
  computationalcomplexityof (weight  lesscomplex =faster.
 <Math>F: ( A, n ) \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group244">
  OperArg=C "Name"" Label"IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifyRange" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This java.lang.StringIndexOutOfBoundsException: Range [6, 15) out of bounds for length 5
 to the category for the basic operation <Code>SimplifyRange</Code>.
 Optionally, a weight (default: 100) can be specified = (mStackParent;
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( mor, n ) \mapsto \mathtt{SimplifyRange}(mor, n)</Math>.
<P/>
 <
</ManSection>


<ManSection Label="AutoDoc_generated_group245">
  <Oper
  Oper =" ,weight"Name"java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 116
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <return AddAttributes(node, attributes, mBuilder);
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SimplifyRange_IsoFromInputObject</Code>.
 Optionally, a weight (default: 100) can be specified java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 39
 to the computational complexity of}
 <Math>    nsresultoperator) java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
<P/>
 </Description>
</ManSection         aOperationmAttributes;


<ManSectionaOperationmIntendedParent?*aOperation.  java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  <Oper Arg="C, F"      / intendedParent == isa special casewhere 
  Oper" , "java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 114
 <Returns>nothing
</Returns>
 
 The arguments are                          :mBuilder-G)
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SimplifyRange_IsoToInputObject</Code>.
 Optionally,weightdefault:100canbewhich should roughly correspond
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( mor, n ) \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n)</Math>.
<P/>
 </Description>
</ManSection>


ManSectionLabel=AutoDoc_generated_group247
  <Oper Arg="C, F" Name="AddSimplifySource" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifySource" Label="for IsCapCategory, IsFunction, IsInt"/>
 Returns>othing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation          ?>(
  category  <<>
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of the function (lower* java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 75
 <Math>F: ( mor, n ) \mapsto \mathtt{SimplifySource}(mor, n)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection       * =aOperationmContentjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  <Oper Arg="C, F" Name="AddSimplifySourceAndRange" Label=      nsHtml5HtmlAttributes* =aOperation.java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  <Oper Arg="C, F, weight" Name="AddSimplifySourceAndRange" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 This operation adds the given function <Math>F</Math>
                          :mBuilder-GetNodeInfoManager(;
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of           CreateMathMLElement(name, att(,attributes nodeInfoManager,mBuilder)
 <Math>F      returnNS_OK;
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group249">
  <Oper Arg="C, F" Name="AddSimplifySourceAndRange_IsoFromInputRange" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifySourceAndRange_IsoFromInputRange" Label="for IsCapCategory, java.lang.StringIndexOutOfBoundsException: Index 106 out of bounds for length 19
 <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       b,   java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 58
 Optionally, a weight (default: 100) }
 to the computational
 <Math>F    nsresult operator)const opFosterParentText& aOperation){
</
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group250">
  <Oper Arg="C, F" Name="AddSimplifySourceAndRange_IsoFromInputSource" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifySourceAndRange_IsoFromInputSource" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
 Thisjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 54
 to the category for the basic operation <java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 43
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of the java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
 <Math>F: (      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 44
<      length=mLength;
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group251">
  <Oper Arg="C, F nsAtom name  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  <Oper Arg="C, F, weight" Name="java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 24
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C<    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SimplifySourceAndRange_IsoToInputRange</Code>.
Optionally, (:)canwhichjava.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 85
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F      (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 71
<  NS_OK
 </java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
</ManSection>


<ManSection Label="AutoDoc_generated_group252">
  <Oper Arg="C, F" Name="AddSimplifySourceAndRange_IsoToInputSource" Label="for java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 60
  <Oper Arg="C, F, weight" Name="AddSimplifySourceAndRange_IsoToInputSource" Label="for IsCapCategory,      return java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 <Returns>nothing
</Returns>
 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
    root=java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 69
 This operation adds the given function <*,
 to the category           java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 Optionally, 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: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor, n)</Math>.
<P/>
 // We failed to attach a new shadow root, so instead attach a template
</ManSection>


<ManSection Label="AutoDoc_generated_group253">
  <Oper Arg="C, F" Name="AddSimplifySource_IsoFromInputObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifySource_IsoFromInputObject" Label="for IsCapCategory, IsFunction, IsInt"/>
 <         "tojava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 67
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.
erationadds  java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54
 to the category for the basic operation <Code>SimplifySource_IsoFromInputObject</Code>.
 Optionally, a weight (default// Can this happen? If it can, give up.
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( mor}
<P/>
 </Description   aOperation.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
</ManSection>


<ManSection Label        
  <Oper Arg="C, F" Name="AddSimplifySource_IsoToInputObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSimplifySource_IsoToInputObject"        returnNS_OK;
 <Returns>nothing
</Returns>
 <Description>
ory<C/> anda function MathF/Math>.
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SimplifySource_IsoToInputObject</Code>.
 Optionally,
ityofthe function(lower =lesscomplex =execution.
 <Math>F: ( mor, n )ble  *(Operation.mTable);
<P      nsIContent* stackParent = *(Operation.mStackParent);
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group255">
  <Oper Arg="C, F"         >java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55
  <Oper Arg="C, F, weight" Name="AddSolveLinearSystemInAbCategory" Label="for IsCapCategory, IsFunction, IsInt"/>
 }
</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>SolveLinearSystemInAbCategory</Code>.
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of the function (lower weightnsresultjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 24
 <Math>F: ( arg2, arg3, arg4 ) \mapsto \mathtt{SolveLinearSystemInAbCategory}(arg2, arg3, arg4)</Math>.
<P/>
 </Description>
</ManSection>


ManSection =java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 47
  <Oper Arg="C, F" Name="AddSomeInjectiveObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, *java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 17
</Returns>
 <Description
categoryM>C/  a java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 75
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SomeInjectiveObject</         java.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 70
 weight( 100)can be specifiedwhich  correspond
 to the computational complexity of the function (lower weight = less complex = faster execution).
<F(arg2  \mapsto mathtt{(<Math>
<P/>
 </Description>
<    )java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 69


<ManSection Label="AutoDoc_generated_group257">
per=C "Name"java.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 98
  <Oper Arg="C, F, weight" Name="AddSomeIsomorphismBetweenObjects" 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>SomeIsomorphismBetweenObjects
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of the function (lower weight = less complex = }
 <Math>F: ( object_1, object_2 ) \mapsto \mathtt{SomeIsomorphismBetweenObjects}(object_1, object_2)</Math>.
<P/>
 </Description>
</ManSection>


java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 47
  <Oper Arg="C, F" Name="AddSomeProjectiveObject" Label="for IsCapCategory, (uint32_t);
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <returnjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 This java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 to the category for the basic operation <Code>SomeProjectiveObject</Code>.
;
 to the computational complexity of the function (lower weight = less complex = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 <Math>F: ( arg2 ) \mapsto \mathtt{SomeProjectiveObject}(arg2)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group259">
  <Oper Arg="C, F" Name="java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
  <Oper Arg="C, F, weight" Name="AddSomeReductionBySplitEpiSummand" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 java.lang.StringIndexOutOfBoundsException: Range [6, 3) out of bounds for length 14
 ThisMOZ_ASSERT(nsNameSpaceManager:GetInstance()>mSVGDisabled,
 to the category for the basic operation <Code>SomeReductionBySplitEpiSummand</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      returnNS_OK;
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group260">
  <Oper Arg="C, F" Name="AddSomeReductionBySplitEpiSummand_MorphismFromInputRange" Label="for        s){
  <Oper Arg="C, F, weight" Name="AddSomeReductionBySplitEpiSummand_MorphismFromInputRange" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>            JS:amColumnNumber);
<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>SomeReductionBySplitEpiSummand_MorphismFromInputRange</Code>.
 Optionally, a weight (default: 100) can be specified which should
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( alpha ) \mapsto \mathtt{java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 5
</
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group261">
  <Oper Arg="C, F" Name="AddSomeReductionBySplitEpiSummand_MorphismToInputRange" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddSomeReductionBySplitEpiSummand_MorphismToInputRange" Label="for    nsresult )const  java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 73
 <Returns>nothing
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
 <Description>
 The arguments are a categorynsresult operator)(  
 This operation adds the given function <      Elementelement=((aOperation)>)
 to the category for the basic operation      char16_t   mClass
 Optionally, a weight (default: 100) can be specified which should roughly correspond
nalcomplexityofthe function(weight=lesscomplex =faster execution).
 <Math>F: ( alpha ) \mapsto \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha)</Math>nsGkAtoms:_classjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group262">
  <Oper Arg="C, F" Name="AddSubtractionForMorphisms" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C      return NS_OK;
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SubtractionForMorphisms</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{SubtractionForMorphisms}  =mBuilderGetDocument)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
<P/>
 </Description>
</ManSection>


<ManSectionLabel">
  < Arg",F"" "java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 83
  <Oper Arg="C, F, weight" Name="AddSumOfMorphisms" Label="for IsCapCategory, IsFunction, IsInt"/>
 <Returns>nothing
</Returns>
 <Description>
 The arguments      // Reuse the fix for bug 467852
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>SumOfMorphisms</Code>.
 Optionally, a weight (default: 100) can be specifiedbool=false
 othecomputational complexity of thefunction (lower weight = less complex = faster execution).
 <Math>F: ( source, list_of_morphisms, range ) \mapsto \mathtt{SumOfMorphisms}(source, java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 79
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group264">
  <Oper Arg="C, F" Name="AddTerminalObject" Label="      // URLs that return data (e.g. "http:" URLs) should be prefixed with
  <Oper Arg="C, F, weight      // undecorated.// undecorated.
 <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>TerminalObject</Code>.
 Optionally, a weight (defaultjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: (        java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
<P/>
 </Description>
/ManSection


<ManSection Label="AutoDoc_generated_group265">
  <Oper Arg="C, F"     nsresult operator( java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
  <Oper Arg="nsDependentString baseUrl(aOperation.mBuffer, aOperation.mLength);
 <Returns>nothing
</Returns>
 <Description>
      return 
 }
 to the category for the basic operation <Code>TerminalObjectFunctorial</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{TerminalObjectFunctorial}()</Math>.
<P/>
 </Description>
</       = aOperationmOther


<ManSection Label="AutoDoc_generated_group266">
  <Oper Arg="C, F" Name="AddTerminalObjectFunctorialWithGivenTerminalObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F,         klass.AppendLiteral error");
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</Math>.

 to the category for the basic java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 31
 Optionally, 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, Pp ) \mapsto \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 51
<P/>
 </Description>
<        java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37


<ManSection Label="AutoDoc_generated_group267">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromCoequalizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromCoequalizerNS_ENSURE_SUCCESS(,NS_OK)
 <Returns>nothing
<
 <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 
 Optionally, a weight (default: 100) can>nsGkAtoms:t title;
 to the computational complexity       if(
 <Math>F: ( Y, morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y, morphisms, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group268">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromCoequalizerWithGivenCoequalizer" Label=}
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromCoequalizerWithGivenCoequalizer" 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>
  element->etAttr(NameSpaceID_None :d val,true;
 Optionally, a weightreturn NS_OK
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( nsresult operator)(constopShallowCloneInto& aOperation){
<P/>
 </Description>
</ManSection      ErrorResult rv;


<ManSection Label="AutoDoc_generated_group269">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromCoproduct" Label="for IsCapCategory, IsFunction"/>
  return.java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 34
 <Returns>nothing
</Returns>
 <Description>
 The arguments are a category <Math>C</Math> and a function <Math>F</;
 This operation adds the given function <Math>F</Math>
 to the category for the basic operation <Code>UniversalMorphismFromCoproduct</java.lang.StringIndexOutOfBoundsException: Range [0, 83) out of bounds for length 58
 Optionally, a weight (default: 100) can be specifiedmInterrupted;// this causes a notification flush anyway
 to the computational complexity of the function (lower weight = less complex = faster execution).
 <Math>F: ( objects, T, tau
<>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group270">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromCoproductWithGivenCoproduct" Label="for IsCapCategory, IsFunction"/>
  
 <Returnsnsresult operator)const&aOperation){
</Returns>
 <Description>
 The arguments are a  <athC/  afunction <><Math>java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 }
 to the java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 Optionally, a weight (default: 100) can be specified which should roughly correspond
 to the computational complexity of the function (java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 19
 <Math>F: ( objects, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects, T, tau, P)<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group271">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromDirectSum" 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>UniversalMorphismFromDirectSum</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, T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group272">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromDirectSumWithGivenDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromDirectSumWithGivenDirectSum" 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>UniversalMorphismFromDirectSumWithGivenDirectSum</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group273">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromImage" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromImage" 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>UniversalMorphismFromImage</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, tau ) \mapsto \mathtt{UniversalMorphismFromImage}(alpha, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group274">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromImageWithGivenImageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromImageWithGivenImageObject" 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>UniversalMorphismFromImageWithGivenImageObject</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, tau, I ) \mapsto \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group275">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromInitialObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromInitialObject" 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>UniversalMorphismFromInitialObject</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: ( T ) \mapsto \mathtt{UniversalMorphismFromInitialObject}(T)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group276">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromInitialObjectWithGivenInitialObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromInitialObjectWithGivenInitialObject" 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>UniversalMorphismFromInitialObjectWithGivenInitialObject</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: ( T, P ) \mapsto \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group277">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromPushout" 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>UniversalMorphismFromPushout</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, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group278">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromPushoutWithGivenPushout" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromPushoutWithGivenPushout" 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>UniversalMorphismFromPushoutWithGivenPushout</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group279">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromZeroObject" 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>UniversalMorphismFromZeroObject</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: ( T ) \mapsto \mathtt{UniversalMorphismFromZeroObject}(T)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group280">
  <Oper Arg="C, F" Name="AddUniversalMorphismFromZeroObjectWithGivenZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismFromZeroObjectWithGivenZeroObject" 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>UniversalMorphismFromZeroObjectWithGivenZeroObject</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: ( T, P ) \mapsto \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group281">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoCoimage" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoCoimage" 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>UniversalMorphismIntoCoimage</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, tau ) \mapsto \mathtt{UniversalMorphismIntoCoimage}(alpha, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group282">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoCoimageWithGivenCoimageObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoCoimageWithGivenCoimageObject" 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>UniversalMorphismIntoCoimageWithGivenCoimageObject</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, tau, C ) \mapsto \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group283">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoDirectProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoDirectProduct" 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>UniversalMorphismIntoDirectProduct</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, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group284">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoDirectProductWithGivenDirectProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoDirectProductWithGivenDirectProduct" 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>UniversalMorphismIntoDirectProductWithGivenDirectProduct</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group285">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoDirectSum" 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>UniversalMorphismIntoDirectSum</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, T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group286">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoDirectSumWithGivenDirectSum" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoDirectSumWithGivenDirectSum" 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>UniversalMorphismIntoDirectSumWithGivenDirectSum</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group287">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoEqualizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoEqualizer" 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>UniversalMorphismIntoEqualizer</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, T, tau ) \mapsto \mathtt{UniversalMorphismIntoEqualizer}(Y, morphisms, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group288">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoEqualizerWithGivenEqualizer" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoEqualizerWithGivenEqualizer" 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>UniversalMorphismIntoEqualizerWithGivenEqualizer</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y, morphisms, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group289">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoFiberProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoFiberProduct" 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>UniversalMorphismIntoFiberProduct</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, T, tau ) \mapsto \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group290">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoFiberProductWithGivenFiberProduct" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoFiberProductWithGivenFiberProduct" 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>UniversalMorphismIntoFiberProductWithGivenFiberProduct</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, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms, T, tau, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group291">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoTerminalObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoTerminalObject" 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>UniversalMorphismIntoTerminalObject</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: ( T ) \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group292">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject" 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>UniversalMorphismIntoTerminalObjectWithGivenTerminalObject</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: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group293">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoZeroObject" 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>UniversalMorphismIntoZeroObject</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: ( T ) \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group294">
  <Oper Arg="C, F" Name="AddUniversalMorphismIntoZeroObjectWithGivenZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddUniversalMorphismIntoZeroObjectWithGivenZeroObject" 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>UniversalMorphismIntoZeroObjectWithGivenZeroObject</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: ( T, P ) \mapsto \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group295">
  <Oper Arg="C, F" Name="AddVerticalPostCompose" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddVerticalPostCompose" 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>VerticalPostCompose</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{VerticalPostCompose}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group296">
  <Oper Arg="C, F" Name="AddVerticalPreCompose" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddVerticalPreCompose" 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>VerticalPreCompose</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{VerticalPreCompose}(arg2, arg3)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group297">
  <Oper Arg="C, F" Name="AddZeroMorphism" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddZeroMorphism" 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>ZeroMorphism</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, b ) \mapsto \mathtt{ZeroMorphism}(a, b)</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group298">
  <Oper Arg="C, F" Name="AddZeroObject" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddZeroObject" 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>ZeroObject</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{ZeroObject}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group299">
  <Oper Arg="C, F" Name="AddZeroObjectFunctorial" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddZeroObjectFunctorial" 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>ZeroObjectFunctorial</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{ZeroObjectFunctorial}()</Math>.
<P/>
 </Description>
</ManSection>


<ManSection Label="AutoDoc_generated_group300">
  <Oper Arg="C, F" Name="AddZeroObjectFunctorialWithGivenZeroObjects" Label="for IsCapCategory, IsFunction"/>
  <Oper Arg="C, F, weight" Name="AddZeroObjectFunctorialWithGivenZeroObjects" 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>ZeroObjectFunctorialWithGivenZeroObjects</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, Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P, Pp)</Math>.
<P/>
 </Description>
</ManSection>


</Section>



</Chapter>