  
  [1X7 [33X[0;0YAdd Functions[133X[101X
  
  [33X[0;0YThis  section  describes  the  overall  structure  of  Add-functions and the
  functions installed by them.[133X
  
  
  [1X7.1 [33X[0;0YFunctions Installed by Add[133X[101X
  
  [33X[0;0YAdd functions have the following syntax:[133X
  
  [4X[32X  Code  [32X[104X
    [4XDeclareOperation( "AddSomeFunc",[104X
    [4X                  [ IsCapCategory, IsList, IsInt ] );[104X
  [4X[32X[104X
  
  [33X[0;0YThe   first   argument   is  the  category  to  which  some  function  (e.g.
  [10XKernelObject[110X)  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 [10XIsMomomorphism[110X). The third is an
  optional  weight  which will then be the weight for [10XSomeFunc[110X (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 [10XSomeFunc[110X (resp. [10XSomeFuncOp[110X if [10XSomeFunc[110X is not an operation).[133X
  
  [33X[0;0YAll installed methods follow the following steps, described below:[133X
  
  [30X    [33X[0;6YRedirect function[133X
  
  [30X    [33X[0;6YPrefunction[133X
  
  [30X    [33X[0;6YFunction[133X
  
  [30X    [33X[0;6YLogic[133X
  
  [30X    [33X[0;6YPostfunction[133X
  
  [30X    [33X[0;6YAddfunction[133X
  
  [33X[0;0YEvery  other  part,  except  from  function,  does  only  depend on the name
  [10XSomeFunc[110X. We now explain the steps in detail.[133X
  
  [30X    [33X[0;6YRedirect  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  [10XSomeFunc[110X itself and can return an array
        containing  [10X[ true, something ][110X, which will cause the installed method
        to  simply return the object [10Xsomething[110X, or [10X[ false ][110X. If the output is
        [9Xfalse[109X, the computation will continue with the step Prefunction.[133X
  
  [30X    [33X[0;6YPrefunction:  The  prefunction  should  be used for error handling and
        plausibility  checks  of the input to [10XSomeFunc[110X (e.g. for [10XKernelLift[110X 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 [10XSomeFunc[110X. It is called with the same input as the
        function  itself,  and  should return either [10X[ true ][110X, which continues
        the  computation,  or  [10X[ false, "message" ][110X, which will cause an error
        with message [10X"message"[110X and some additional information.[133X
  
  [30X    [33X[0;6YFull  prefunction:  The  full prefuction has the same semantics as the
        prefunction,  but can perform additional, very costly checks. They are
        disabled by default.[133X
  
  [30X    [33X[0;6YFunction:  This  will  launch  the function(s) given as arguments. The
        result  should  be as specified in the type of [10XSomeFunc[110X. The resulting
        object is now named the result.[133X
  
  [30X    [33X[0;6YLogic:  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
        [10XSomeFunc[110X, it is installed in this step for the result.[133X
  
  [30X    [33X[0;6YPostfunction:  The  postfunction  called  with  the  arguments  of the
        function  and  the  result. It can be an arbitrary function doing some
        cosmetics. If for example [10XSomeFunc[110X is [10XKernelEmbedding[110X, it will set the
        [10XKernelObject[110X of the input morphism to result. The postfunction is also
        taken  from  the  method  record  and  does  only  depend  on the name
        [10XSomeFunc[110X.[133X
  
  [30X    [33X[0;6YAddfunction:  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  [2XEnableAddForCategoricalOperations[102X
        ([14X1.12-1[114X).[133X
  
  
  [1X7.2 [33X[0;0YAdd Method[133X[101X
  
  [33X[0;0YExcept  from  installing  a  new method for the name [10XSomeFunc[110X, an Add method
  does  slightly  more.  Every Add method has the same structure. The steps in
  the Add method are as follows:[133X
  
  [30X    [33X[0;6YDefault  weight:  If the weight parameter is -1, the default weight is
        assumed, which is 100.[133X
  
  [30X    [33X[0;6YWeight 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.[133X
  
  [30X    [33X[0;6YInstallation: 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.[133X
  
  [33X[0;0YAfter 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.[133X
  
  
  [1X7.3 [33X[0;0YMethod name record entries[133X[101X
  
  [33X[0;0YThe entries of method name records can have the following components:[133X
  
  [4X[32X  Code  [32X[104X
    [4X    [[104X
    [4X        "filter_list",[104X
    [4X        "input_arguments_names",[104X
    [4X        "return_type",[104X
    [4X        "output_source_getter_string",[104X
    [4X        "output_source_getter_preconditions",[104X
    [4X        "output_range_getter_string",[104X
    [4X        "output_range_getter_preconditions",[104X
    [4X        "with_given_object_position",[104X
    [4X        "dual_operation",[104X
    [4X        "dual_arguments_reversed",[104X
    [4X        "dual_with_given_objects_reversed",[104X
    [4X        "dual_preprocessor_func",[104X
    [4X        "dual_preprocessor_func_string",[104X
    [4X        "dual_postprocessor_func",[104X
    [4X        "dual_postprocessor_func_string",[104X
    [4X        "functorial",[104X
    [4X        "compatible_with_congruence_of_morphisms",[104X
    [4X        "redirect_function",[104X
    [4X        "pre_function",[104X
    [4X        "pre_function_full",[104X
    [4X        "post_function",[104X
    [4X    ][104X
  [4X[32X[104X
  
  [30X    [33X[0;6Ypre_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.[133X
  
  [30X    [33X[0;6Ypre_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.[133X
  
  [30X    [33X[0;6Yredirect_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.[133X
  
  [30X    [33X[0;6Ypost_function (optional): A function which is used as the postfunction
        of the installed methods, as described above.[133X
  
  [30X    [33X[0;6Yfilter_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 [10Xfilter_list[110X must
        be  the  string  [10Xcategory[110X.  If  the  category can be inferred from the
        remaining  arguments, a convenience method without the category as the
        first argument is installed automatically.[133X
  
        [30X    [33X[0;12Y[10Xcategory[110X,[133X
  
        [30X    [33X[0;12Y[10Xobject[110X,[133X
  
        [30X    [33X[0;12Y[10Xmorphism[110X,[133X
  
        [30X    [33X[0;12Y[10Xtwocell[110X,[133X
  
        [30X    [33X[0;12Y[10Xobject_in_range_category_of_homomorphism_structure[110X,[133X
  
        [30X    [33X[0;12Y[10Xmorphism_in_range_category_of_homomorphism_structure[110X,[133X
  
        [30X    [33X[0;12Y[10Xlist_of_objects[110X,[133X
  
        [30X    [33X[0;12Y[10Xlist_of_morphisms[110X,[133X
  
        [30X    [33X[0;12Y[10Xlist_of_twocells[110X.[133X
  
  [30X    [33X[0;6Yreturn_type:  The  return  type  can  either be a filter or one of the
        strings  in  the  list  below.  For objects, morphisms and [23X2[123X-cells the
        correct  [10XAdd[110X  function  (see  above)  is  used  for  the result of the
        computation. Otherwise, no [10XAdd[110X function is used after all.[133X
  
  [4X[32X  Code  [32X[104X
    [4X    [[104X
    [4X        "object",[104X
    [4X        "morphism",[104X
    [4X        "twocell",[104X
    [4X        "object_in_range_category_of_homomorphism_structure",[104X
    [4X        "morphism_in_range_category_of_homomorphism_structure",[104X
    [4X        "bool",[104X
    [4X        "list_of_objects",[104X
    [4X        "list_of_morphisms",[104X
    [4X        "list_of_lists_of_morphisms",[104X
    [4X        "object_datum",[104X
    [4X        "morphism_datum",[104X
    [4X        "nonneg_integer_or_infinity",[104X
    [4X        "list_of_elements_of_commutative_semiring_of_linear_structure",[104X
    [4X    ][104X
  [4X[32X[104X
  
  [30X    [33X[0;6Yfunctorial  (optional):  If  an  object has a corresponding functorial
        function,  e.g.,  [10XKernelObject[110X and [10XKernelObjectFunctorial[110X, the name of
        the functorial is stored as a string.[133X
  
  [30X    [33X[0;6Ydual_operation (optional): Name of the dual operation.[133X
  
  [30X    [33X[0;6Ydual_arguments_reversed  (optional):  Boolean,  marks  whether for the
        call  of the dual operation all arguments have to be given in reversed
        order.[133X
  
  [30X    [33X[0;6Ydual_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.[133X
  
  [30X    [33X[0;6Ydual_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.[133X
  
  [30X    [33X[0;6Ydual_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.[133X
  
  [30X    [33X[0;6Yinput_arguments_names  (optional):  A duplicate free list (of the same
        length  as [10Xfilter_list[110X) 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.[133X
  
  [30X    [33X[0;6Youtput_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 [10Xinput_arguments_names[110X.[133X
  
  [30X    [33X[0;6Youtput_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.[133X
  
  [30X    [33X[0;6Youtput_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 [10Xinput_arguments_names[110X.[133X
  
  [30X    [33X[0;6Youtput_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.[133X
  
  [30X    [33X[0;6Ywith_given_object_position  (optional):  One of the following strings:
        [10X"Source"[110X, [10X"Range"[110X, or [10X"both"[110X. 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).[133X
  
  [30X    [33X[0;6Ycompatible_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 [10XIsEqualForObjects[110X and
        [10XIsCongruentForMorphisms[110X   if   the   input   changes  with  regard  to
        [10XIsEqualForObjects[110X and [10XIsCongruentForMorphisms[110X.[133X
  
  
  [1X7.4 [33X[0;0YEnhancing the method name record[133X[101X
  
  [33X[0;0YThe  function  CAP_INTERNAL_ENHANCE_NAME_RECORD  can  be applied to a method
  name record to make the following enhancements:[133X
  
  [30X    [33X[0;6YFunction name: Set the component function_name to the entry name.[133X
  
  [30X    [33X[0;6YWithGiven  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.[133X
  
  [30X    [33X[0;6YRedirect  and  post functions are created for all operations belonging
        to universal constructions (e.g. [10XKernelLift[110X) which are not a WithGiven
        operation.[133X
  
  
  [1X7.5 [33X[0;0YPrepare functions[133X[101X
  
  [1X7.5-1 CAPOperationPrepareFunction[101X
  
  [33X[1;0Y[29X[2XCAPOperationPrepareFunction[102X( [3Xprepare_function[103X, [3Xcategory[103X, [3Xfunc[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya function[133X
  
  [33X[0;0YGiven  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  [10X"BinaryDirectSumToDirectSum"[110X  as [3Xprepare_function[103X, the
  category,  and  the  binary direct sum function. The function then returns a
  function that can be used for the direct sum categorical operation.[133X
  
  [33X[0;0YNote  that [3Xfunc[103X is not handled by the CAP caching mechanism and that the use
  of  prepare  functions  is incompatible with [10XWithGiven[110X operations. Thus, one
  has  to  ensure  manually  that  the  equality and typing specifications are
  fulfilled.[133X
  
  [1X7.5-2 CAPAddPrepareFunction[101X
  
  [33X[1;0Y[29X[2XCAPAddPrepareFunction[102X( [3Xprepare_function[103X, [3Xname[103X, [3Xdoc_string[103X[, [3Xprecondition_list[103X] ) [32X function[133X
  
  [33X[0;0YAdds  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 [3Xname[103X is
  the    name    of    the    prepare    function,    which    is    used   in
  [10XCAPOperationPrepareFunction[110X.  The  argument  [3Xdoc_string[103X  should  be  a short
  string describing the functions. The optional argument [3Xprecondition_list[103X 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
  [3Xprecondition_list[103X is only necessary if the function needed is not explicitly
  used   in   the   prepare   function,   e.g.,   if  you  use  [10X+[110X  instead  of
  [10XAdditionForMorphisms[110X.[133X
  
  [1X7.5-3 ListCAPPrepareFunctions[101X
  
  [33X[1;0Y[29X[2XListCAPPrepareFunctions[102X( [3Xarg[103X ) [32X function[133X
  
  [33X[0;0YLists all prepare functions.[133X
  
  
  [1X7.6 [33X[0;0YAvailable Add functions[133X[101X
  
  [1X7.6-1 AddAdditionForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddAdditionForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddAdditionForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XAdditionForMorphisms[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( alpha, beta
  ) \mapsto \mathtt{AdditionForMorphisms}(alpha, beta)[123X.[133X
  
  [1X7.6-2 AddAdditiveGenerators[101X
  
  [33X[1;0Y[29X[2XAddAdditiveGenerators[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddAdditiveGenerators[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XAdditiveGenerators[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less     complex     =     faster     execution).    [23XF:    (    )    \mapsto
  \mathtt{AdditiveGenerators}()[123X.[133X
  
  [1X7.6-3 AddAdditiveInverseForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddAdditiveInverseForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddAdditiveInverseForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XAdditiveInverseForMorphisms[110X.  Optionally,  a  weight  (default:  100) can be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{AdditiveInverseForMorphisms}(alpha)[123X.[133X
  
  [1X7.6-4 AddAstrictionToCoimage[101X
  
  [33X[1;0Y[29X[2XAddAstrictionToCoimage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddAstrictionToCoimage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XAstrictionToCoimage[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{AstrictionToCoimage}(alpha)[123X.[133X
  
  [1X7.6-5 AddAstrictionToCoimageWithGivenCoimageObject[101X
  
  [33X[1;0Y[29X[2XAddAstrictionToCoimageWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddAstrictionToCoimageWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XAstrictionToCoimageWithGivenCoimageObject[110X.  Optionally,  a  weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:            (            alpha,            C           )           \mapsto
  \mathtt{AstrictionToCoimageWithGivenCoimageObject}(alpha, C)[123X.[133X
  
  [1X7.6-6 AddBasisOfExternalHom[101X
  
  [33X[1;0Y[29X[2XAddBasisOfExternalHom[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddBasisOfExternalHom[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XBasisOfExternalHom[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{BasisOfExternalHom}(arg2, arg3)[123X.[133X
  
  [1X7.6-7 AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory[101X
  
  [33X[1;0Y[29X[2XAddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory[110X. Optionally,
  a  weight (default: 100) can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster    execution).    [23XF:   (   arg2,   arg3,   arg4,   arg5   )   \mapsto
  \mathtt{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2,
  arg3, arg4, arg5)[123X.[133X
  
  [1X7.6-8 AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory[101X
  
  [33X[1;0Y[29X[2XAddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory[110X.   Optionally,   a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster      execution).      [23XF:      (      arg2,     arg3     )     \mapsto
  \mathtt{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2,
  arg3)[123X.[133X
  
  [1X7.6-9 AddCoastrictionToImage[101X
  
  [33X[1;0Y[29X[2XAddCoastrictionToImage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoastrictionToImage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoastrictionToImage[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{CoastrictionToImage}(alpha)[123X.[133X
  
  [1X7.6-10 AddCoastrictionToImageWithGivenImageObject[101X
  
  [33X[1;0Y[29X[2XAddCoastrictionToImageWithGivenImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoastrictionToImageWithGivenImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoastrictionToImageWithGivenImageObject[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:            (            alpha,            I           )           \mapsto
  \mathtt{CoastrictionToImageWithGivenImageObject}(alpha, I)[123X.[133X
  
  [1X7.6-11 AddCoefficientsOfMorphism[101X
  
  [33X[1;0Y[29X[2XAddCoefficientsOfMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoefficientsOfMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoefficientsOfMorphism[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{CoefficientsOfMorphism}(arg2)[123X.[133X
  
  [1X7.6-12 AddCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the basic operation [10XCoequalizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:  (  Y,  morphisms  )  \mapsto
  \mathtt{Coequalizer}(Y, morphisms)[123X.[133X
  
  [1X7.6-13 AddCoequalizerFunctorial[101X
  
  [33X[1;0Y[29X[2XAddCoequalizerFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizerFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoequalizerFunctorial[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight = less complex = faster execution). [23XF: ( morphisms,
  mu,   morphismsp  )  \mapsto  \mathtt{CoequalizerFunctorial}(morphisms,  mu,
  morphismsp)[123X.[133X
  
  [1X7.6-14 AddCoequalizerFunctorialWithGivenCoequalizers[101X
  
  [33X[1;0Y[29X[2XAddCoequalizerFunctorialWithGivenCoequalizers[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizerFunctorialWithGivenCoequalizers[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoequalizerFunctorialWithGivenCoequalizers[110X.  Optionally,  a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:     (     P,     morphisms,     mu,     morphismsp,    Pp    )    \mapsto
  \mathtt{CoequalizerFunctorialWithGivenCoequalizers}(P,     morphisms,    mu,
  morphismsp, Pp)[123X.[133X
  
  [1X7.6-15 AddCoequalizerOfIdentityAndAutomorphisms[101X
  
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoequalizerOfIdentityAndAutomorphisms[110X.  Optionally,  a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:          (          Y,          automorphisms          )          \mapsto
  \mathtt{CoequalizerOfIdentityAndAutomorphisms}(Y, automorphisms)[123X.[133X
  
  [1X7.6-16 AddCoequalizerOfIdentityAndAutomorphismsFunctorial[101X
  
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphismsFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphismsFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoequalizerOfIdentityAndAutomorphismsFunctorial[110X.    Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).  [23XF:  (  automorphisms,  mu,  automorphismsp  )  \mapsto
  \mathtt{CoequalizerOfIdentityAndAutomorphismsFunctorial}(automorphisms,  mu,
  automorphismsp)[123X.[133X
  
  [1X7.6-17 AddCoequalizerOfIdentityAndAutomorphismsFunctorialWithGivenCoequalizers[101X
  
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphismsFunctorialWithGivenCoequalizers[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoequalizerOfIdentityAndAutomorphismsFunctorialWithGivenCoequalizers[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoequalizerOfIdentityAndAutomorphismsFunctorialWithGivenCoequalizers[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less complex = faster execution). [23XF: ( P, automorphisms, mu, automorphismsp,
  Pp                                 )                                 \mapsto
  \mathtt{CoequalizerOfIdentityAndAutomorphismsFunctorialWithGivenCoequalizers}(P,
  automorphisms, mu, automorphismsp, Pp)[123X.[133X
  
  [1X7.6-18 AddCoimageObject[101X
  
  [33X[1;0Y[29X[2XAddCoimageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoimageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XCoimageObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{CoimageObject}(arg2)[123X.[133X
  
  [1X7.6-19 AddCoimageObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddCoimageObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoimageObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoimageObjectFunctorial[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  mu, alphap ) \mapsto \mathtt{CoimageObjectFunctorial}(alpha, mu, alphap)[123X.[133X
  
  [1X7.6-20 AddCoimageObjectFunctorialWithGivenCoimageObjects[101X
  
  [33X[1;0Y[29X[2XAddCoimageObjectFunctorialWithGivenCoimageObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoimageObjectFunctorialWithGivenCoimageObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoimageObjectFunctorialWithGivenCoimageObjects[110X.    Optionally,    a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   C,   alpha,   mu,   alphap,   Cp  )  \mapsto
  \mathtt{CoimageObjectFunctorialWithGivenCoimageObjects}(C,     alpha,    mu,
  alphap, Cp)[123X.[133X
  
  [1X7.6-21 AddCoimageProjection[101X
  
  [33X[1;0Y[29X[2XAddCoimageProjection[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoimageProjection[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XCoimageProjection[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{CoimageProjection}(alpha)[123X.[133X
  
  [1X7.6-22 AddCoimageProjectionWithGivenCoimageObject[101X
  
  [33X[1;0Y[29X[2XAddCoimageProjectionWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoimageProjectionWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoimageProjectionWithGivenCoimageObject[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:            (            alpha,            C           )           \mapsto
  \mathtt{CoimageProjectionWithGivenCoimageObject}(alpha, C)[123X.[133X
  
  [1X7.6-23 AddCokernelColift[101X
  
  [33X[1;0Y[29X[2XAddCokernelColift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelColift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XCokernelColift[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster  execution).  [23XF:  (  alpha,  T,  tau  )  \mapsto
  \mathtt{CokernelColift}(alpha, T, tau)[123X.[133X
  
  [1X7.6-24 AddCokernelColiftWithGivenCokernelObject[101X
  
  [33X[1;0Y[29X[2XAddCokernelColiftWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelColiftWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCokernelColiftWithGivenCokernelObject[110X.  Optionally,  a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:        (        alpha,        T,       tau,       P       )       \mapsto
  \mathtt{CokernelColiftWithGivenCokernelObject}(alpha, T, tau, P)[123X.[133X
  
  [1X7.6-25 AddCokernelObject[101X
  
  [33X[1;0Y[29X[2XAddCokernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XCokernelObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{CokernelObject}(alpha)[123X.[133X
  
  [1X7.6-26 AddCokernelObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddCokernelObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCokernelObjectFunctorial[110X.   Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  mu, alphap ) \mapsto \mathtt{CokernelObjectFunctorial}(alpha, mu, alphap)[123X.[133X
  
  [1X7.6-27 AddCokernelObjectFunctorialWithGivenCokernelObjects[101X
  
  [33X[1;0Y[29X[2XAddCokernelObjectFunctorialWithGivenCokernelObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelObjectFunctorialWithGivenCokernelObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCokernelObjectFunctorialWithGivenCokernelObjects[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   P,   alpha,   mu,   alphap,   Pp  )  \mapsto
  \mathtt{CokernelObjectFunctorialWithGivenCokernelObjects}(P,    alpha,   mu,
  alphap, Pp)[123X.[133X
  
  [1X7.6-28 AddCokernelProjection[101X
  
  [33X[1;0Y[29X[2XAddCokernelProjection[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelProjection[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XCokernelProjection[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{CokernelProjection}(alpha)[123X.[133X
  
  [1X7.6-29 AddCokernelProjectionWithGivenCokernelObject[101X
  
  [33X[1;0Y[29X[2XAddCokernelProjectionWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCokernelProjectionWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCokernelProjectionWithGivenCokernelObject[110X.  Optionally,  a  weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:            (            alpha,            P           )           \mapsto
  \mathtt{CokernelProjectionWithGivenCokernelObject}(alpha, P)[123X.[133X
  
  [1X7.6-30 AddColift[101X
  
  [33X[1;0Y[29X[2XAddColift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddColift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XColift[110X. Optionally,
  a  weight (default: 100) can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster execution). [23XF: ( alpha, beta ) \mapsto \mathtt{Colift}(alpha, beta)[123X.[133X
  
  [1X7.6-31 AddColiftAlongEpimorphism[101X
  
  [33X[1;0Y[29X[2XAddColiftAlongEpimorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddColiftAlongEpimorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XColiftAlongEpimorphism[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( epsilon, tau
  ) \mapsto \mathtt{ColiftAlongEpimorphism}(epsilon, tau)[123X.[133X
  
  [1X7.6-32 AddComponentOfMorphismFromCoproduct[101X
  
  [33X[1;0Y[29X[2XAddComponentOfMorphismFromCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddComponentOfMorphismFromCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XComponentOfMorphismFromCoproduct[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  I, i ) \mapsto \mathtt{ComponentOfMorphismFromCoproduct}(alpha, I, i)[123X.[133X
  
  [1X7.6-33 AddComponentOfMorphismFromDirectSum[101X
  
  [33X[1;0Y[29X[2XAddComponentOfMorphismFromDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddComponentOfMorphismFromDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XComponentOfMorphismFromDirectSum[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  S, i ) \mapsto \mathtt{ComponentOfMorphismFromDirectSum}(alpha, S, i)[123X.[133X
  
  [1X7.6-34 AddComponentOfMorphismIntoDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddComponentOfMorphismIntoDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddComponentOfMorphismIntoDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XComponentOfMorphismIntoDirectProduct[110X.  Optionally,  a  weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:          (          alpha,         P,         i         )         \mapsto
  \mathtt{ComponentOfMorphismIntoDirectProduct}(alpha, P, i)[123X.[133X
  
  [1X7.6-35 AddComponentOfMorphismIntoDirectSum[101X
  
  [33X[1;0Y[29X[2XAddComponentOfMorphismIntoDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddComponentOfMorphismIntoDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XComponentOfMorphismIntoDirectSum[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  S, i ) \mapsto \mathtt{ComponentOfMorphismIntoDirectSum}(alpha, S, i)[123X.[133X
  
  [1X7.6-36 AddCoproduct[101X
  
  [33X[1;0Y[29X[2XAddCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic  operation [10XCoproduct[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =   faster   execution).   [23XF:   (   objects   )   \mapsto
  \mathtt{Coproduct}(objects)[123X.[133X
  
  [1X7.6-37 AddCoproductFunctorial[101X
  
  [33X[1;0Y[29X[2XAddCoproductFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoproductFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoproductFunctorial[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( objects, L,
  objectsp ) \mapsto \mathtt{CoproductFunctorial}(objects, L, objectsp)[123X.[133X
  
  [1X7.6-38 AddCoproductFunctorialWithGivenCoproducts[101X
  
  [33X[1;0Y[29X[2XAddCoproductFunctorialWithGivenCoproducts[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddCoproductFunctorialWithGivenCoproducts[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XCoproductFunctorialWithGivenCoproducts[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:      (      P,     objects,     L,     objectsp,     Pp     )     \mapsto
  \mathtt{CoproductFunctorialWithGivenCoproducts}(P,   objects,  L,  objectsp,
  Pp)[123X.[133X
  
  [1X7.6-39 AddDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XDirectProduct[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =   faster   execution).   [23XF:   (   objects   )   \mapsto
  \mathtt{DirectProduct}(objects)[123X.[133X
  
  [1X7.6-40 AddDirectProductFunctorial[101X
  
  [33X[1;0Y[29X[2XAddDirectProductFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectProductFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XDirectProductFunctorial[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  L,   objectsp   )   \mapsto   \mathtt{DirectProductFunctorial}(objects,   L,
  objectsp)[123X.[133X
  
  [1X7.6-41 AddDirectProductFunctorialWithGivenDirectProducts[101X
  
  [33X[1;0Y[29X[2XAddDirectProductFunctorialWithGivenDirectProducts[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectProductFunctorialWithGivenDirectProducts[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XDirectProductFunctorialWithGivenDirectProducts[110X.    Optionally,    a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   P,   objects,  L,  objectsp,  Pp  )  \mapsto
  \mathtt{DirectProductFunctorialWithGivenDirectProducts}(P,    objects,    L,
  objectsp, Pp)[123X.[133X
  
  [1X7.6-42 AddDirectSum[101X
  
  [33X[1;0Y[29X[2XAddDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic  operation [10XDirectSum[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =   faster   execution).   [23XF:   (   objects   )   \mapsto
  \mathtt{DirectSum}(objects)[123X.[133X
  
  [1X7.6-43 AddDirectSumFunctorial[101X
  
  [33X[1;0Y[29X[2XAddDirectSumFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectSumFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XDirectSumFunctorial[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( objects, L,
  objectsp ) \mapsto \mathtt{DirectSumFunctorial}(objects, L, objectsp)[123X.[133X
  
  [1X7.6-44 AddDirectSumFunctorialWithGivenDirectSums[101X
  
  [33X[1;0Y[29X[2XAddDirectSumFunctorialWithGivenDirectSums[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDirectSumFunctorialWithGivenDirectSums[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XDirectSumFunctorialWithGivenDirectSums[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:      (      P,     objects,     L,     objectsp,     Pp     )     \mapsto
  \mathtt{DirectSumFunctorialWithGivenDirectSums}(P,   objects,  L,  objectsp,
  Pp)[123X.[133X
  
  [1X7.6-45 AddDistinguishedObjectOfHomomorphismStructure[101X
  
  [33X[1;0Y[29X[2XAddDistinguishedObjectOfHomomorphismStructure[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddDistinguishedObjectOfHomomorphismStructure[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XDistinguishedObjectOfHomomorphismStructure[110X.  Optionally,  a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( ) \mapsto \mathtt{DistinguishedObjectOfHomomorphismStructure}()[123X.[133X
  
  [1X7.6-46 AddEmbeddingOfEqualizer[101X
  
  [33X[1;0Y[29X[2XAddEmbeddingOfEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEmbeddingOfEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEmbeddingOfEqualizer[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( Y, morphisms
  ) \mapsto \mathtt{EmbeddingOfEqualizer}(Y, morphisms)[123X.[133X
  
  [1X7.6-47 AddEmbeddingOfEqualizerWithGivenEqualizer[101X
  
  [33X[1;0Y[29X[2XAddEmbeddingOfEqualizerWithGivenEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEmbeddingOfEqualizerWithGivenEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEmbeddingOfEqualizerWithGivenEqualizer[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:         (         Y,         morphisms,         P        )        \mapsto
  \mathtt{EmbeddingOfEqualizerWithGivenEqualizer}(Y, morphisms, P)[123X.[133X
  
  [1X7.6-48 AddEpimorphismFromProjectiveCoverObject[101X
  
  [33X[1;0Y[29X[2XAddEpimorphismFromProjectiveCoverObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEpimorphismFromProjectiveCoverObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEpimorphismFromProjectiveCoverObject[110X.  Optionally,  a  weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( A ) \mapsto \mathtt{EpimorphismFromProjectiveCoverObject}(A)[123X.[133X
  
  [1X7.6-49 AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject[101X
  
  [33X[1;0Y[29X[2XAddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   P   )   \mapsto
  \mathtt{EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject}(A,
  P)[123X.[133X
  
  [1X7.6-50 AddEpimorphismFromSomeProjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddEpimorphismFromSomeProjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEpimorphismFromSomeProjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEpimorphismFromSomeProjectiveObject[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( A )
  \mapsto \mathtt{EpimorphismFromSomeProjectiveObject}(A)[123X.[133X
  
  [1X7.6-51 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   P   )   \mapsto
  \mathtt{EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject}(A,
  P)[123X.[133X
  
  [1X7.6-52 AddEqualizer[101X
  
  [33X[1;0Y[29X[2XAddEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic  operation [10XEqualizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:  (  Y,  morphisms  )  \mapsto
  \mathtt{Equalizer}(Y, morphisms)[123X.[133X
  
  [1X7.6-53 AddEqualizerFunctorial[101X
  
  [33X[1;0Y[29X[2XAddEqualizerFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEqualizerFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEqualizerFunctorial[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight = less complex = faster execution). [23XF: ( morphisms,
  mu,   morphismsp   )   \mapsto  \mathtt{EqualizerFunctorial}(morphisms,  mu,
  morphismsp)[123X.[133X
  
  [1X7.6-54 AddEqualizerFunctorialWithGivenEqualizers[101X
  
  [33X[1;0Y[29X[2XAddEqualizerFunctorialWithGivenEqualizers[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddEqualizerFunctorialWithGivenEqualizers[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XEqualizerFunctorialWithGivenEqualizers[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:     (     P,     morphisms,     mu,     morphismsp,    Pp    )    \mapsto
  \mathtt{EqualizerFunctorialWithGivenEqualizers}(P,       morphisms,      mu,
  morphismsp, Pp)[123X.[133X
  
  [1X7.6-55 AddFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XFiberProduct[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   morphisms   )   \mapsto
  \mathtt{FiberProduct}(morphisms)[123X.[133X
  
  [1X7.6-56 AddFiberProductFunctorial[101X
  
  [33X[1;0Y[29X[2XAddFiberProductFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddFiberProductFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XFiberProductFunctorial[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight = less complex = faster execution). [23XF: ( morphisms,
  L,   morphismsp   )  \mapsto  \mathtt{FiberProductFunctorial}(morphisms,  L,
  morphismsp)[123X.[133X
  
  [1X7.6-57 AddFiberProductFunctorialWithGivenFiberProducts[101X
  
  [33X[1;0Y[29X[2XAddFiberProductFunctorialWithGivenFiberProducts[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddFiberProductFunctorialWithGivenFiberProducts[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XFiberProductFunctorialWithGivenFiberProducts[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:     (     P,     morphisms,     L,     morphismsp,     Pp    )    \mapsto
  \mathtt{FiberProductFunctorialWithGivenFiberProducts}(P,    morphisms,    L,
  morphismsp, Pp)[123X.[133X
  
  [1X7.6-58 AddHomologyObject[101X
  
  [33X[1;0Y[29X[2XAddHomologyObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHomologyObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XHomologyObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (  alpha,  beta  )  \mapsto
  \mathtt{HomologyObject}(alpha, beta)[123X.[133X
  
  [1X7.6-59 AddHomologyObjectFunctorialWithGivenHomologyObjects[101X
  
  [33X[1;0Y[29X[2XAddHomologyObjectFunctorialWithGivenHomologyObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHomologyObjectFunctorialWithGivenHomologyObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHomologyObjectFunctorialWithGivenHomologyObjects[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     H_1,     L,     H_2     )    \mapsto
  \mathtt{HomologyObjectFunctorialWithGivenHomologyObjects}(H_1, L, H_2)[123X.[133X
  
  [1X7.6-60 AddHomomorphismStructureOnMorphisms[101X
  
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHomomorphismStructureOnMorphisms[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  beta ) \mapsto \mathtt{HomomorphismStructureOnMorphisms}(alpha, beta)[123X.[133X
  
  [1X7.6-61 AddHomomorphismStructureOnMorphismsWithGivenObjects[101X
  
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnMorphismsWithGivenObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnMorphismsWithGivenObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHomomorphismStructureOnMorphismsWithGivenObjects[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   source,   alpha,   beta,   range  )  \mapsto
  \mathtt{HomomorphismStructureOnMorphismsWithGivenObjects}(source,     alpha,
  beta, range)[123X.[133X
  
  [1X7.6-62 AddHomomorphismStructureOnObjects[101X
  
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHomomorphismStructureOnObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHomomorphismStructureOnObjects[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{HomomorphismStructureOnObjects}(arg2, arg3)[123X.[133X
  
  [1X7.6-63 AddHorizontalPostCompose[101X
  
  [33X[1;0Y[29X[2XAddHorizontalPostCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHorizontalPostCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHorizontalPostCompose[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{HorizontalPostCompose}(arg2, arg3)[123X.[133X
  
  [1X7.6-64 AddHorizontalPreCompose[101X
  
  [33X[1;0Y[29X[2XAddHorizontalPreCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddHorizontalPreCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XHorizontalPreCompose[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{HorizontalPreCompose}(arg2, arg3)[123X.[133X
  
  [1X7.6-65 AddIdentityMorphism[101X
  
  [33X[1;0Y[29X[2XAddIdentityMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIdentityMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X to the category for the basic operation [10XIdentityMorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:    (    a    )   \mapsto
  \mathtt{IdentityMorphism}(a)[123X.[133X
  
  [1X7.6-66 AddIdentityTwoCell[101X
  
  [33X[1;0Y[29X[2XAddIdentityTwoCell[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIdentityTwoCell[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to the category for the basic operation [10XIdentityTwoCell[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IdentityTwoCell}(arg2)[123X.[133X
  
  [1X7.6-67 AddImageEmbedding[101X
  
  [33X[1;0Y[29X[2XAddImageEmbedding[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddImageEmbedding[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XImageEmbedding[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{ImageEmbedding}(alpha)[123X.[133X
  
  [1X7.6-68 AddImageEmbeddingWithGivenImageObject[101X
  
  [33X[1;0Y[29X[2XAddImageEmbeddingWithGivenImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddImageEmbeddingWithGivenImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XImageEmbeddingWithGivenImageObject[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower  weight  =  less complex = faster execution). [23XF: (
  alpha, I ) \mapsto \mathtt{ImageEmbeddingWithGivenImageObject}(alpha, I)[123X.[133X
  
  [1X7.6-69 AddImageObject[101X
  
  [33X[1;0Y[29X[2XAddImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the basic operation [10XImageObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{ImageObject}(arg2)[123X.[133X
  
  [1X7.6-70 AddImageObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddImageObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddImageObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XImageObjectFunctorial[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight = less complex = faster execution). [23XF: ( alpha, nu,
  alphap ) \mapsto \mathtt{ImageObjectFunctorial}(alpha, nu, alphap)[123X.[133X
  
  [1X7.6-71 AddImageObjectFunctorialWithGivenImageObjects[101X
  
  [33X[1;0Y[29X[2XAddImageObjectFunctorialWithGivenImageObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddImageObjectFunctorialWithGivenImageObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XImageObjectFunctorialWithGivenImageObjects[110X.  Optionally,  a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:      (      I,      alpha,      nu,      alphap,     Ip     )     \mapsto
  \mathtt{ImageObjectFunctorialWithGivenImageObjects}(I,  alpha,  nu,  alphap,
  Ip)[123X.[133X
  
  [1X7.6-72 AddIndecomposableInjectiveObjects[101X
  
  [33X[1;0Y[29X[2XAddIndecomposableInjectiveObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIndecomposableInjectiveObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIndecomposableInjectiveObjects[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( )
  \mapsto \mathtt{IndecomposableInjectiveObjects}()[123X.[133X
  
  [1X7.6-73 AddIndecomposableProjectiveObjects[101X
  
  [33X[1;0Y[29X[2XAddIndecomposableProjectiveObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIndecomposableProjectiveObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIndecomposableProjectiveObjects[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( )
  \mapsto \mathtt{IndecomposableProjectiveObjects}()[123X.[133X
  
  [1X7.6-74 AddInitialObject[101X
  
  [33X[1;0Y[29X[2XAddInitialObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInitialObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XInitialObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less complex = faster execution). [23XF: ( ) \mapsto \mathtt{InitialObject}()[123X.[133X
  
  [1X7.6-75 AddInitialObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddInitialObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInitialObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInitialObjectFunctorial[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( )
  \mapsto \mathtt{InitialObjectFunctorial}()[123X.[133X
  
  [1X7.6-76 AddInitialObjectFunctorialWithGivenInitialObjects[101X
  
  [33X[1;0Y[29X[2XAddInitialObjectFunctorialWithGivenInitialObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInitialObjectFunctorialWithGivenInitialObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInitialObjectFunctorialWithGivenInitialObjects[110X.    Optionally,    a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:      (      P,      Pp      )      \mapsto
  \mathtt{InitialObjectFunctorialWithGivenInitialObjects}(P, Pp)[123X.[133X
  
  [1X7.6-77 AddInjectionOfCofactorOfCoproduct[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfCoproduct[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  k ) \mapsto \mathtt{InjectionOfCofactorOfCoproduct}(objects, k)[123X.[133X
  
  [1X7.6-78 AddInjectionOfCofactorOfCoproductWithGivenCoproduct[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfCoproductWithGivenCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfCoproductWithGivenCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfCoproductWithGivenCoproduct[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     objects,     k,    P    )    \mapsto
  \mathtt{InjectionOfCofactorOfCoproductWithGivenCoproduct}(objects, k, P)[123X.[133X
  
  [1X7.6-79 AddInjectionOfCofactorOfDirectSum[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfDirectSum[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  k ) \mapsto \mathtt{InjectionOfCofactorOfDirectSum}(objects, k)[123X.[133X
  
  [1X7.6-80 AddInjectionOfCofactorOfDirectSumWithGivenDirectSum[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfDirectSumWithGivenDirectSum[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     objects,     k,    P    )    \mapsto
  \mathtt{InjectionOfCofactorOfDirectSumWithGivenDirectSum}(objects, k, P)[123X.[133X
  
  [1X7.6-81 AddInjectionOfCofactorOfPushout[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfPushout[110X.  Optionally,  a  weight  (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfPushout}(morphisms, k)[123X.[133X
  
  [1X7.6-82 AddInjectionOfCofactorOfPushoutWithGivenPushout[101X
  
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectionOfCofactorOfPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectionOfCofactorOfPushoutWithGivenPushout[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:         (         morphisms,         k,         P        )        \mapsto
  \mathtt{InjectionOfCofactorOfPushoutWithGivenPushout}(morphisms, k, P)[123X.[133X
  
  [1X7.6-83 AddInjectiveColift[101X
  
  [33X[1;0Y[29X[2XAddInjectiveColift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectiveColift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to the category for the basic operation [10XInjectiveColift[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (  alpha,  beta  )  \mapsto
  \mathtt{InjectiveColift}(alpha, beta)[123X.[133X
  
  [1X7.6-84 AddInjectiveDimension[101X
  
  [33X[1;0Y[29X[2XAddInjectiveDimension[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectiveDimension[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XInjectiveDimension[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{InjectiveDimension}(arg2)[123X.[133X
  
  [1X7.6-85 AddInjectiveEnvelopeObject[101X
  
  [33X[1;0Y[29X[2XAddInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInjectiveEnvelopeObject[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{InjectiveEnvelopeObject}(arg2)[123X.[133X
  
  [1X7.6-86 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure[101X
  
  [33X[1;0Y[29X[2XAddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure}(alpha)[123X.[133X
  
  [1X7.6-87 AddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects[101X
  
  [33X[1;0Y[29X[2XAddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster  execution).  [23XF:  (  source, alpha, range ) \mapsto
  \mathtt{InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects}(source,
  alpha, range)[123X.[133X
  
  [1X7.6-88 AddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism[101X
  
  [33X[1;0Y[29X[2XAddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster  execution).  [23XF:  (  source, range, alpha ) \mapsto
  \mathtt{InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism}(source,
  range, alpha)[123X.[133X
  
  [1X7.6-89 AddInverseForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddInverseForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInverseForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInverseForMorphisms[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{InverseForMorphisms}(alpha)[123X.[133X
  
  [1X7.6-90 AddInverseOfMorphismFromCoimageToImage[101X
  
  [33X[1;0Y[29X[2XAddInverseOfMorphismFromCoimageToImage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInverseOfMorphismFromCoimageToImage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInverseOfMorphismFromCoimageToImage[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of the function (lower weight = less complex = faster execution). [23XF: ( alpha
  ) \mapsto \mathtt{InverseOfMorphismFromCoimageToImage}(alpha)[123X.[133X
  
  [1X7.6-91 AddInverseOfMorphismFromCoimageToImageWithGivenObjects[101X
  
  [33X[1;0Y[29X[2XAddInverseOfMorphismFromCoimageToImageWithGivenObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddInverseOfMorphismFromCoimageToImageWithGivenObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XInverseOfMorphismFromCoimageToImageWithGivenObjects[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     I,     alpha,     C     )    \mapsto
  \mathtt{InverseOfMorphismFromCoimageToImageWithGivenObjects}(I, alpha, C)[123X.[133X
  
  [1X7.6-92 AddIsAutomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsAutomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsAutomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XIsAutomorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsAutomorphism}(arg2)[123X.[133X
  
  [1X7.6-93 AddIsBijectiveObject[101X
  
  [33X[1;0Y[29X[2XAddIsBijectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsBijectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XIsBijectiveObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsBijectiveObject}(arg2)[123X.[133X
  
  [1X7.6-94 AddIsCodominating[101X
  
  [33X[1;0Y[29X[2XAddIsCodominating[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsCodominating[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XIsCodominating[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsCodominating}(arg2, arg3)[123X.[133X
  
  [1X7.6-95 AddIsColiftable[101X
  
  [33X[1;0Y[29X[2XAddIsColiftable[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsColiftable[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XIsColiftable[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsColiftable}(arg2, arg3)[123X.[133X
  
  [1X7.6-96 AddIsColiftableAlongEpimorphism[101X
  
  [33X[1;0Y[29X[2XAddIsColiftableAlongEpimorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsColiftableAlongEpimorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsColiftableAlongEpimorphism[110X.  Optionally,  a  weight  (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsColiftableAlongEpimorphism}(arg2, arg3)[123X.[133X
  
  [1X7.6-97 AddIsCongruentForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsCongruentForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsCongruentForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsCongruentForMorphisms[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsCongruentForMorphisms}(arg2, arg3)[123X.[133X
  
  [1X7.6-98 AddIsDominating[101X
  
  [33X[1;0Y[29X[2XAddIsDominating[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsDominating[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XIsDominating[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsDominating}(arg2, arg3)[123X.[133X
  
  [1X7.6-99 AddIsEndomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsEndomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEndomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XIsEndomorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsEndomorphism}(arg2)[123X.[133X
  
  [1X7.6-100 AddIsEpimorphism[101X
  
  [33X[1;0Y[29X[2XAddIsEpimorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEpimorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XIsEpimorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsEpimorphism}(arg2)[123X.[133X
  
  [1X7.6-101 AddIsEqualAsFactorobjects[101X
  
  [33X[1;0Y[29X[2XAddIsEqualAsFactorobjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualAsFactorobjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualAsFactorobjects[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{IsEqualAsFactorobjects}(arg2, arg3)[123X.[133X
  
  [1X7.6-102 AddIsEqualAsSubobjects[101X
  
  [33X[1;0Y[29X[2XAddIsEqualAsSubobjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualAsSubobjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualAsSubobjects[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{IsEqualAsSubobjects}(arg2, arg3)[123X.[133X
  
  [1X7.6-103 AddIsEqualForCacheForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsEqualForCacheForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualForCacheForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualForCacheForMorphisms[110X.  Optionally,  a  weight  (default:  100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsEqualForCacheForMorphisms}(arg2, arg3)[123X.[133X
  
  [1X7.6-104 AddIsEqualForCacheForObjects[101X
  
  [33X[1;0Y[29X[2XAddIsEqualForCacheForObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualForCacheForObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualForCacheForObjects[110X.  Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsEqualForCacheForObjects}(arg2, arg3)[123X.[133X
  
  [1X7.6-105 AddIsEqualForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsEqualForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualForMorphisms[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{IsEqualForMorphisms}(arg2, arg3)[123X.[133X
  
  [1X7.6-106 AddIsEqualForMorphismsOnMor[101X
  
  [33X[1;0Y[29X[2XAddIsEqualForMorphismsOnMor[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualForMorphismsOnMor[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualForMorphismsOnMor[110X.   Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsEqualForMorphismsOnMor}(arg2, arg3)[123X.[133X
  
  [1X7.6-107 AddIsEqualForObjects[101X
  
  [33X[1;0Y[29X[2XAddIsEqualForObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualForObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XIsEqualForObjects[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsEqualForObjects}(arg2, arg3)[123X.[133X
  
  [1X7.6-108 AddIsEqualToIdentityMorphism[101X
  
  [33X[1;0Y[29X[2XAddIsEqualToIdentityMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualToIdentityMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualToIdentityMorphism[110X.  Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{IsEqualToIdentityMorphism}(arg2)[123X.[133X
  
  [1X7.6-109 AddIsEqualToZeroMorphism[101X
  
  [33X[1;0Y[29X[2XAddIsEqualToZeroMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsEqualToZeroMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsEqualToZeroMorphism[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{IsEqualToZeroMorphism}(arg2)[123X.[133X
  
  [1X7.6-110 AddIsHomSetInhabited[101X
  
  [33X[1;0Y[29X[2XAddIsHomSetInhabited[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsHomSetInhabited[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XIsHomSetInhabited[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsHomSetInhabited}(arg2, arg3)[123X.[133X
  
  [1X7.6-111 AddIsIdempotent[101X
  
  [33X[1;0Y[29X[2XAddIsIdempotent[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsIdempotent[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XIsIdempotent[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsIdempotent}(arg2)[123X.[133X
  
  [1X7.6-112 AddIsInitial[101X
  
  [33X[1;0Y[29X[2XAddIsInitial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsInitial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic  operation [10XIsInitial[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsInitial}(arg2)[123X.[133X
  
  [1X7.6-113 AddIsInjective[101X
  
  [33X[1;0Y[29X[2XAddIsInjective[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsInjective[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the basic operation [10XIsInjective[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsInjective}(arg2)[123X.[133X
  
  [1X7.6-114 AddIsIsomorphicForObjects[101X
  
  [33X[1;0Y[29X[2XAddIsIsomorphicForObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsIsomorphicForObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsIsomorphicForObjects[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  = less complex = faster execution). [23XF: ( object_1,
  object_2 ) \mapsto \mathtt{IsIsomorphicForObjects}(object_1, object_2)[123X.[133X
  
  [1X7.6-115 AddIsIsomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsIsomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsIsomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XIsIsomorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsIsomorphism}(arg2)[123X.[133X
  
  [1X7.6-116 AddIsLiftable[101X
  
  [33X[1;0Y[29X[2XAddIsLiftable[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsLiftable[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic operation [10XIsLiftable[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{IsLiftable}(arg2, arg3)[123X.[133X
  
  [1X7.6-117 AddIsLiftableAlongMonomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsLiftableAlongMonomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsLiftableAlongMonomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsLiftableAlongMonomorphism[110X.  Optionally,  a  weight  (default:  100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3 ) \mapsto \mathtt{IsLiftableAlongMonomorphism}(arg2, arg3)[123X.[133X
  
  [1X7.6-118 AddIsMonomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsMonomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsMonomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XIsMonomorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsMonomorphism}(arg2)[123X.[133X
  
  [1X7.6-119 AddIsOne[101X
  
  [33X[1;0Y[29X[2XAddIsOne[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsOne[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XIsOne[110X. Optionally,
  a  weight (default: 100) can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster execution). [23XF: ( arg2 ) \mapsto \mathtt{IsOne}(arg2)[123X.[133X
  
  [1X7.6-120 AddIsProjective[101X
  
  [33X[1;0Y[29X[2XAddIsProjective[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsProjective[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XIsProjective[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsProjective}(arg2)[123X.[133X
  
  [1X7.6-121 AddIsSplitEpimorphism[101X
  
  [33X[1;0Y[29X[2XAddIsSplitEpimorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsSplitEpimorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XIsSplitEpimorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsSplitEpimorphism}(arg2)[123X.[133X
  
  [1X7.6-122 AddIsSplitMonomorphism[101X
  
  [33X[1;0Y[29X[2XAddIsSplitMonomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsSplitMonomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsSplitMonomorphism[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{IsSplitMonomorphism}(arg2)[123X.[133X
  
  [1X7.6-123 AddIsTerminal[101X
  
  [33X[1;0Y[29X[2XAddIsTerminal[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsTerminal[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic operation [10XIsTerminal[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsTerminal}(arg2)[123X.[133X
  
  [1X7.6-124 AddIsWellDefinedForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsWellDefinedForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsWellDefinedForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsWellDefinedForMorphisms[110X.  Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{IsWellDefinedForMorphisms}(alpha)[123X.[133X
  
  [1X7.6-125 AddIsWellDefinedForMorphismsWithGivenSourceAndRange[101X
  
  [33X[1;0Y[29X[2XAddIsWellDefinedForMorphismsWithGivenSourceAndRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsWellDefinedForMorphismsWithGivenSourceAndRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsWellDefinedForMorphismsWithGivenSourceAndRange[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster    execution).    [23XF:    (    source,    alpha,    range   )   \mapsto
  \mathtt{IsWellDefinedForMorphismsWithGivenSourceAndRange}(source,     alpha,
  range)[123X.[133X
  
  [1X7.6-126 AddIsWellDefinedForObjects[101X
  
  [33X[1;0Y[29X[2XAddIsWellDefinedForObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsWellDefinedForObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsWellDefinedForObjects[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{IsWellDefinedForObjects}(arg2)[123X.[133X
  
  [1X7.6-127 AddIsWellDefinedForTwoCells[101X
  
  [33X[1;0Y[29X[2XAddIsWellDefinedForTwoCells[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsWellDefinedForTwoCells[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsWellDefinedForTwoCells[110X.   Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{IsWellDefinedForTwoCells}(arg2)[123X.[133X
  
  [1X7.6-128 AddIsZeroForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsZeroForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsZeroForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XIsZeroForMorphisms[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsZeroForMorphisms}(arg2)[123X.[133X
  
  [1X7.6-129 AddIsZeroForObjects[101X
  
  [33X[1;0Y[29X[2XAddIsZeroForObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsZeroForObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X to the category for the basic operation [10XIsZeroForObjects[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{IsZeroForObjects}(arg2)[123X.[133X
  
  [1X7.6-130 AddIsomorphismFromCoequalizerOfCoproductDiagramToPushout[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerOfCoproductDiagramToPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerOfCoproductDiagramToPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoequalizerOfCoproductDiagramToPushout[110X.  Optionally, a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster        execution).        [23XF:        (        D        )       \mapsto
  \mathtt{IsomorphismFromCoequalizerOfCoproductDiagramToPushout}(D)[123X.[133X
  
  [1X7.6-131 AddIsomorphismFromCoequalizerOfIdentityAndAutomorphismsToCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerOfIdentityAndAutomorphismsToCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerOfIdentityAndAutomorphismsToCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoequalizerOfIdentityAndAutomorphismsToCoequalizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex  =  faster  execution).  [23XF:  (  Y,  automorphisms  )  \mapsto
  \mathtt{IsomorphismFromCoequalizerOfIdentityAndAutomorphismsToCoequalizer}(Y,
  automorphisms)[123X.[133X
  
  [1X7.6-132 AddIsomorphismFromCoequalizerToCoequalizerOfIdentityAndAutomorphisms[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerToCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerToCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoequalizerToCoequalizerOfIdentityAndAutomorphisms[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex  =  faster  execution).  [23XF:  (  Y,  automorphisms  )  \mapsto
  \mathtt{IsomorphismFromCoequalizerToCoequalizerOfIdentityAndAutomorphisms}(Y,
  automorphisms)[123X.[133X
  
  [1X7.6-133 AddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   D   )   \mapsto
  \mathtt{IsomorphismFromCoequalizerToCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproduct}(A,
  D)[123X.[133X
  
  [1X7.6-134 AddIsomorphismFromCoimageToCokernelOfKernel[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoimageToCokernelOfKernel[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoimageToCokernelOfKernel[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoimageToCokernelOfKernel[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:               (               alpha               )               \mapsto
  \mathtt{IsomorphismFromCoimageToCokernelOfKernel}(alpha)[123X.[133X
  
  [1X7.6-135 AddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   D   )   \mapsto
  \mathtt{IsomorphismFromCokernelOfJointPairwiseDifferencesOfMorphismsFromCoproductToCoequalizer}(A,
  D)[123X.[133X
  
  [1X7.6-136 AddIsomorphismFromCokernelOfKernelToCoimage[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCokernelOfKernelToCoimage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCokernelOfKernelToCoimage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCokernelOfKernelToCoimage[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:               (               alpha               )               \mapsto
  \mathtt{IsomorphismFromCokernelOfKernelToCoimage}(alpha)[123X.[133X
  
  [1X7.6-137 AddIsomorphismFromCoproductToDirectSum[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromCoproductToDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromCoproductToDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromCoproductToDirectSum[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( D )
  \mapsto \mathtt{IsomorphismFromCoproductToDirectSum}(D)[123X.[133X
  
  [1X7.6-138 AddIsomorphismFromDirectProductToDirectSum[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectProductToDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectProductToDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromDirectProductToDirectSum[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( D ) \mapsto \mathtt{IsomorphismFromDirectProductToDirectSum}(D)[123X.[133X
  
  [1X7.6-139 AddIsomorphismFromDirectSumToCoproduct[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectSumToCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectSumToCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromDirectSumToCoproduct[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( D )
  \mapsto \mathtt{IsomorphismFromDirectSumToCoproduct}(D)[123X.[133X
  
  [1X7.6-140 AddIsomorphismFromDirectSumToDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectSumToDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromDirectSumToDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromDirectSumToDirectProduct[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( D ) \mapsto \mathtt{IsomorphismFromDirectSumToDirectProduct}(D)[123X.[133X
  
  [1X7.6-141 AddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct[110X.  Optionally, a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster        execution).        [23XF:        (        D        )       \mapsto
  \mathtt{IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct}(D)[123X.[133X
  
  [1X7.6-142 AddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   D   )   \mapsto
  \mathtt{IsomorphismFromEqualizerToKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A,
  D)[123X.[133X
  
  [1X7.6-143 AddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromFiberProductToEqualizerOfDirectProductDiagram[110X.  Optionally, a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster        execution).        [23XF:        (        D        )       \mapsto
  \mathtt{IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram}(D)[123X.[133X
  
  [1X7.6-144 AddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromHomologyObjectToItsConstructionAsAnImageObject[110X. Optionally, a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster      execution).      [23XF:      (     alpha,     beta     )     \mapsto
  \mathtt{IsomorphismFromHomologyObjectToItsConstructionAsAnImageObject}(alpha,
  beta)[123X.[133X
  
  [1X7.6-145 AddIsomorphismFromImageObjectToKernelOfCokernel[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromImageObjectToKernelOfCokernel[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromImageObjectToKernelOfCokernel[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromImageObjectToKernelOfCokernel[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:               (               alpha               )               \mapsto
  \mathtt{IsomorphismFromImageObjectToKernelOfCokernel}(alpha)[123X.[133X
  
  [1X7.6-146 AddIsomorphismFromInitialObjectToZeroObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromInitialObjectToZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromInitialObjectToZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromInitialObjectToZeroObject[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( ) \mapsto \mathtt{IsomorphismFromInitialObjectToZeroObject}()[123X.[133X
  
  [1X7.6-147 AddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromItsConstructionAsAnImageObjectToHomologyObject[110X. Optionally, a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster      execution).      [23XF:      (     alpha,     beta     )     \mapsto
  \mathtt{IsomorphismFromItsConstructionAsAnImageObjectToHomologyObject}(alpha,
  beta)[123X.[133X
  
  [1X7.6-148 AddIsomorphismFromKernelOfCokernelToImageObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromKernelOfCokernelToImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromKernelOfCokernelToImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromKernelOfCokernelToImageObject[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:               (               alpha               )               \mapsto
  \mathtt{IsomorphismFromKernelOfCokernelToImageObject}(alpha)[123X.[133X
  
  [1X7.6-149 AddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   D   )   \mapsto
  \mathtt{IsomorphismFromKernelOfJointPairwiseDifferencesOfMorphismsIntoDirectProductToEqualizer}(A,
  D)[123X.[133X
  
  [1X7.6-150 AddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromPushoutToCoequalizerOfCoproductDiagram[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromPushoutToCoequalizerOfCoproductDiagram[110X.  Optionally, a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster        execution).        [23XF:        (        D        )       \mapsto
  \mathtt{IsomorphismFromPushoutToCoequalizerOfCoproductDiagram}(D)[123X.[133X
  
  [1X7.6-151 AddIsomorphismFromTerminalObjectToZeroObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromTerminalObjectToZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromTerminalObjectToZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromTerminalObjectToZeroObject[110X.  Optionally,  a  weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( ) \mapsto \mathtt{IsomorphismFromTerminalObjectToZeroObject}()[123X.[133X
  
  [1X7.6-152 AddIsomorphismFromZeroObjectToInitialObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromZeroObjectToInitialObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromZeroObjectToInitialObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromZeroObjectToInitialObject[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToInitialObject}()[123X.[133X
  
  [1X7.6-153 AddIsomorphismFromZeroObjectToTerminalObject[101X
  
  [33X[1;0Y[29X[2XAddIsomorphismFromZeroObjectToTerminalObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddIsomorphismFromZeroObjectToTerminalObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XIsomorphismFromZeroObjectToTerminalObject[110X.  Optionally,  a  weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( ) \mapsto \mathtt{IsomorphismFromZeroObjectToTerminalObject}()[123X.[133X
  
  [1X7.6-154 AddJointPairwiseDifferencesOfMorphismsFromCoproduct[101X
  
  [33X[1;0Y[29X[2XAddJointPairwiseDifferencesOfMorphismsFromCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddJointPairwiseDifferencesOfMorphismsFromCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XJointPairwiseDifferencesOfMorphismsFromCoproduct[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:       (      A,      D      )      \mapsto
  \mathtt{JointPairwiseDifferencesOfMorphismsFromCoproduct}(A, D)[123X.[133X
  
  [1X7.6-155 AddJointPairwiseDifferencesOfMorphismsIntoDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddJointPairwiseDifferencesOfMorphismsIntoDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddJointPairwiseDifferencesOfMorphismsIntoDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XJointPairwiseDifferencesOfMorphismsIntoDirectProduct[110X.  Optionally,  a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:       (      A,      D      )      \mapsto
  \mathtt{JointPairwiseDifferencesOfMorphismsIntoDirectProduct}(A, D)[123X.[133X
  
  [1X7.6-156 AddKernelEmbedding[101X
  
  [33X[1;0Y[29X[2XAddKernelEmbedding[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelEmbedding[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to the category for the basic operation [10XKernelEmbedding[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{KernelEmbedding}(alpha)[123X.[133X
  
  [1X7.6-157 AddKernelEmbeddingWithGivenKernelObject[101X
  
  [33X[1;0Y[29X[2XAddKernelEmbeddingWithGivenKernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelEmbeddingWithGivenKernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XKernelEmbeddingWithGivenKernelObject[110X.  Optionally,  a  weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( alpha, P ) \mapsto \mathtt{KernelEmbeddingWithGivenKernelObject}(alpha,
  P)[123X.[133X
  
  [1X7.6-158 AddKernelLift[101X
  
  [33X[1;0Y[29X[2XAddKernelLift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelLift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic operation [10XKernelLift[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster  execution).  [23XF:  (  alpha,  T,  tau  )  \mapsto
  \mathtt{KernelLift}(alpha, T, tau)[123X.[133X
  
  [1X7.6-159 AddKernelLiftWithGivenKernelObject[101X
  
  [33X[1;0Y[29X[2XAddKernelLiftWithGivenKernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelLiftWithGivenKernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XKernelLiftWithGivenKernelObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  T,  tau, P ) \mapsto \mathtt{KernelLiftWithGivenKernelObject}(alpha, T, tau,
  P)[123X.[133X
  
  [1X7.6-160 AddKernelObject[101X
  
  [33X[1;0Y[29X[2XAddKernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XKernelObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).   [23XF:   (   alpha   )   \mapsto
  \mathtt{KernelObject}(alpha)[123X.[133X
  
  [1X7.6-161 AddKernelObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddKernelObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XKernelObjectFunctorial[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight = less complex = faster execution). [23XF: ( alpha, mu,
  alphap ) \mapsto \mathtt{KernelObjectFunctorial}(alpha, mu, alphap)[123X.[133X
  
  [1X7.6-162 AddKernelObjectFunctorialWithGivenKernelObjects[101X
  
  [33X[1;0Y[29X[2XAddKernelObjectFunctorialWithGivenKernelObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddKernelObjectFunctorialWithGivenKernelObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XKernelObjectFunctorialWithGivenKernelObjects[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:      (      P,      alpha,      mu,      alphap,     Pp     )     \mapsto
  \mathtt{KernelObjectFunctorialWithGivenKernelObjects}(P,  alpha, mu, alphap,
  Pp)[123X.[133X
  
  [1X7.6-163 AddLift[101X
  
  [33X[1;0Y[29X[2XAddLift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddLift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XLift[110X. Optionally, a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster execution). [23XF: ( alpha, beta ) \mapsto \mathtt{Lift}(alpha, beta)[123X.[133X
  
  [1X7.6-164 AddLiftAlongMonomorphism[101X
  
  [33X[1;0Y[29X[2XAddLiftAlongMonomorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddLiftAlongMonomorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XLiftAlongMonomorphism[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( iota, tau )
  \mapsto \mathtt{LiftAlongMonomorphism}(iota, tau)[123X.[133X
  
  [1X7.6-165 AddLinearCombinationOfMorphisms[101X
  
  [33X[1;0Y[29X[2XAddLinearCombinationOfMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddLinearCombinationOfMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XLinearCombinationOfMorphisms[110X.  Optionally,  a  weight  (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( source,
  list_of_ring_elements,      list_of_morphisms,      range      )     \mapsto
  \mathtt{LinearCombinationOfMorphisms}(source,         list_of_ring_elements,
  list_of_morphisms, range)[123X.[133X
  
  [1X7.6-166 AddMereExistenceOfSolutionOfLinearSystemInAbCategory[101X
  
  [33X[1;0Y[29X[2XAddMereExistenceOfSolutionOfLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMereExistenceOfSolutionOfLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMereExistenceOfSolutionOfLinearSystemInAbCategory[110X.   Optionally,   a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:    (    arg2,    arg3,    arg4    )    \mapsto
  \mathtt{MereExistenceOfSolutionOfLinearSystemInAbCategory}(arg2,       arg3,
  arg4)[123X.[133X
  
  [1X7.6-167 AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory[101X
  
  [33X[1;0Y[29X[2XAddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2,
  arg3)[123X.[133X
  
  [1X7.6-168 AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory[101X
  
  [33X[1;0Y[29X[2XAddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory[110X.    Optionally,    a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster     execution).     [23XF:    (    arg2,    arg3,    arg4    )    \mapsto
  \mathtt{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3,
  arg4)[123X.[133X
  
  [1X7.6-169 AddMonomorphismIntoInjectiveEnvelopeObject[101X
  
  [33X[1;0Y[29X[2XAddMonomorphismIntoInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMonomorphismIntoInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMonomorphismIntoInjectiveEnvelopeObject[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( A ) \mapsto \mathtt{MonomorphismIntoInjectiveEnvelopeObject}(A)[123X.[133X
  
  [1X7.6-170 AddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject[101X
  
  [33X[1;0Y[29X[2XAddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   I   )   \mapsto
  \mathtt{MonomorphismIntoInjectiveEnvelopeObjectWithGivenInjectiveEnvelopeObject}(A,
  I)[123X.[133X
  
  [1X7.6-171 AddMonomorphismIntoSomeInjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddMonomorphismIntoSomeInjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMonomorphismIntoSomeInjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMonomorphismIntoSomeInjectiveObject[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( A )
  \mapsto \mathtt{MonomorphismIntoSomeInjectiveObject}(A)[123X.[133X
  
  [1X7.6-172 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject[110X. Optionally,
  a  weight (default: 100) can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster       execution).       [23XF:       (      A,      I      )      \mapsto
  \mathtt{MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject}(A,
  I)[123X.[133X
  
  [1X7.6-173 AddMorphismBetweenDirectSums[101X
  
  [33X[1;0Y[29X[2XAddMorphismBetweenDirectSums[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismBetweenDirectSums[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismBetweenDirectSums[110X.  Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  source_diagram,         mat,         range_diagram         )         \mapsto
  \mathtt{MorphismBetweenDirectSums}(source_diagram, mat, range_diagram)[123X.[133X
  
  [1X7.6-174 AddMorphismBetweenDirectSumsWithGivenDirectSums[101X
  
  [33X[1;0Y[29X[2XAddMorphismBetweenDirectSumsWithGivenDirectSums[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismBetweenDirectSumsWithGivenDirectSums[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismBetweenDirectSumsWithGivenDirectSums[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:    (    S,    source_diagram,    mat,    range_diagram,   T   )   \mapsto
  \mathtt{MorphismBetweenDirectSumsWithGivenDirectSums}(S,     source_diagram,
  mat, range_diagram, T)[123X.[133X
  
  [1X7.6-175 AddMorphismConstructor[101X
  
  [33X[1;0Y[29X[2XAddMorphismConstructor[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismConstructor[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismConstructor[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( arg2, arg3,
  arg4 ) \mapsto \mathtt{MorphismConstructor}(arg2, arg3, arg4)[123X.[133X
  
  [1X7.6-176 AddMorphismDatum[101X
  
  [33X[1;0Y[29X[2XAddMorphismDatum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismDatum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XMorphismDatum[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{MorphismDatum}(arg2)[123X.[133X
  
  [1X7.6-177 AddMorphismFromCoimageToImage[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromCoimageToImage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromCoimageToImage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromCoimageToImage[110X.  Optionally,  a  weight  (default:  100)  can be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{MorphismFromCoimageToImage}(alpha)[123X.[133X
  
  [1X7.6-178 AddMorphismFromCoimageToImageWithGivenObjects[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromCoimageToImageWithGivenObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromCoimageToImageWithGivenObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromCoimageToImageWithGivenObjects[110X.  Optionally,  a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:          (          C,         alpha,         I         )         \mapsto
  \mathtt{MorphismFromCoimageToImageWithGivenObjects}(C, alpha, I)[123X.[133X
  
  [1X7.6-179 AddMorphismFromEqualizerToSink[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromEqualizerToSink[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromEqualizerToSink[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromEqualizerToSink[110X.  Optionally,  a  weight  (default:  100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex = faster execution). [23XF: ( Y,
  morphisms ) \mapsto \mathtt{MorphismFromEqualizerToSink}(Y, morphisms)[123X.[133X
  
  [1X7.6-180 AddMorphismFromEqualizerToSinkWithGivenEqualizer[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromEqualizerToSinkWithGivenEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromEqualizerToSinkWithGivenEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromEqualizerToSinkWithGivenEqualizer[110X.    Optionally,    a    weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (    Y,    morphisms,    P    )    \mapsto
  \mathtt{MorphismFromEqualizerToSinkWithGivenEqualizer}(Y, morphisms, P)[123X.[133X
  
  [1X7.6-181 AddMorphismFromFiberProductToSink[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromFiberProductToSink[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromFiberProductToSink[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromFiberProductToSink[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  morphisms ) \mapsto \mathtt{MorphismFromFiberProductToSink}(morphisms)[123X.[133X
  
  [1X7.6-182 AddMorphismFromFiberProductToSinkWithGivenFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromFiberProductToSinkWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromFiberProductToSinkWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromFiberProductToSinkWithGivenFiberProduct[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster      execution).      [23XF:     (     morphisms,     P     )     \mapsto
  \mathtt{MorphismFromFiberProductToSinkWithGivenFiberProduct}(morphisms, P)[123X.[133X
  
  [1X7.6-183 AddMorphismFromKernelObjectToSink[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromKernelObjectToSink[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromKernelObjectToSink[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromKernelObjectToSink[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{MorphismFromKernelObjectToSink}(alpha)[123X.[133X
  
  [1X7.6-184 AddMorphismFromKernelObjectToSinkWithGivenKernelObject[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromKernelObjectToSinkWithGivenKernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromKernelObjectToSinkWithGivenKernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromKernelObjectToSinkWithGivenKernelObject[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster      execution).      [23XF:      (      alpha,      P      )     \mapsto
  \mathtt{MorphismFromKernelObjectToSinkWithGivenKernelObject}(alpha, P)[123X.[133X
  
  [1X7.6-185 AddMorphismFromSourceToCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToCoequalizer[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex = faster execution). [23XF: ( Y,
  morphisms ) \mapsto \mathtt{MorphismFromSourceToCoequalizer}(Y, morphisms)[123X.[133X
  
  [1X7.6-186 AddMorphismFromSourceToCoequalizerWithGivenCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToCoequalizerWithGivenCoequalizer[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (    Y,    morphisms,    P    )    \mapsto
  \mathtt{MorphismFromSourceToCoequalizerWithGivenCoequalizer}(Y,   morphisms,
  P)[123X.[133X
  
  [1X7.6-187 AddMorphismFromSourceToCokernelObject[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCokernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCokernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToCokernelObject[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of the function (lower weight = less complex = faster execution). [23XF: ( alpha
  ) \mapsto \mathtt{MorphismFromSourceToCokernelObject}(alpha)[123X.[133X
  
  [1X7.6-188 AddMorphismFromSourceToCokernelObjectWithGivenCokernelObject[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCokernelObjectWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToCokernelObjectWithGivenCokernelObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToCokernelObjectWithGivenCokernelObject[110X.   Optionally,   a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster      execution).      [23XF:      (      alpha,      P      )     \mapsto
  \mathtt{MorphismFromSourceToCokernelObjectWithGivenCokernelObject}(alpha,
  P)[123X.[133X
  
  [1X7.6-189 AddMorphismFromSourceToPushout[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToPushout[110X.  Optionally,  a  weight  (default:  100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  morphisms ) \mapsto \mathtt{MorphismFromSourceToPushout}(morphisms)[123X.[133X
  
  [1X7.6-190 AddMorphismFromSourceToPushoutWithGivenPushout[101X
  
  [33X[1;0Y[29X[2XAddMorphismFromSourceToPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismFromSourceToPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismFromSourceToPushoutWithGivenPushout[110X.  Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:           (           morphisms,           P           )          \mapsto
  \mathtt{MorphismFromSourceToPushoutWithGivenPushout}(morphisms, P)[123X.[133X
  
  [1X7.6-191 AddMorphismsOfExternalHom[101X
  
  [33X[1;0Y[29X[2XAddMorphismsOfExternalHom[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMorphismsOfExternalHom[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMorphismsOfExternalHom[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{MorphismsOfExternalHom}(arg2, arg3)[123X.[133X
  
  [1X7.6-192 AddMultiplyWithElementOfCommutativeSemiringForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddMultiplyWithElementOfCommutativeSemiringForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddMultiplyWithElementOfCommutativeSemiringForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XMultiplyWithElementOfCommutativeSemiringForMorphisms[110X.  Optionally,  a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster      execution).      [23XF:      (      r,      alpha      )     \mapsto
  \mathtt{MultiplyWithElementOfCommutativeSemiringForMorphisms}(r, alpha)[123X.[133X
  
  [1X7.6-193 AddObjectConstructor[101X
  
  [33X[1;0Y[29X[2XAddObjectConstructor[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddObjectConstructor[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XObjectConstructor[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{ObjectConstructor}(arg2)[123X.[133X
  
  [1X7.6-194 AddObjectDatum[101X
  
  [33X[1;0Y[29X[2XAddObjectDatum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddObjectDatum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the basic operation [10XObjectDatum[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:   (   arg2   )   \mapsto
  \mathtt{ObjectDatum}(arg2)[123X.[133X
  
  [1X7.6-195 AddPostCompose[101X
  
  [33X[1;0Y[29X[2XAddPostCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPostCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the basic operation [10XPostCompose[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (  beta,  alpha  )  \mapsto
  \mathtt{PostCompose}(beta, alpha)[123X.[133X
  
  [1X7.6-196 AddPostComposeList[101X
  
  [33X[1;0Y[29X[2XAddPostComposeList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPostComposeList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to the category for the basic operation [10XPostComposeList[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster execution). [23XF: ( source, list_of_morphisms, range )
  \mapsto \mathtt{PostComposeList}(source, list_of_morphisms, range)[123X.[133X
  
  [1X7.6-197 AddPostInverseForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddPostInverseForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPostInverseForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XPostInverseForMorphisms[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{PostInverseForMorphisms}(alpha)[123X.[133X
  
  [1X7.6-198 AddPreCompose[101X
  
  [33X[1;0Y[29X[2XAddPreCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPreCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic operation [10XPreCompose[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (  alpha,  beta  )  \mapsto
  \mathtt{PreCompose}(alpha, beta)[123X.[133X
  
  [1X7.6-199 AddPreComposeList[101X
  
  [33X[1;0Y[29X[2XAddPreComposeList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPreComposeList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XPreComposeList[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster execution). [23XF: ( source, list_of_morphisms, range )
  \mapsto \mathtt{PreComposeList}(source, list_of_morphisms, range)[123X.[133X
  
  [1X7.6-200 AddPreInverseForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddPreInverseForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPreInverseForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XPreInverseForMorphisms[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{PreInverseForMorphisms}(alpha)[123X.[133X
  
  [1X7.6-201 AddProjectionInFactorOfDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfDirectProduct[110X.  Optionally,  a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower  weight  =  less complex = faster execution). [23XF: (
  objects, k ) \mapsto \mathtt{ProjectionInFactorOfDirectProduct}(objects, k)[123X.[133X
  
  [1X7.6-202 AddProjectionInFactorOfDirectProductWithGivenDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectProductWithGivenDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectProductWithGivenDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfDirectProductWithGivenDirectProduct[110X.    Optionally,    a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster     execution).     [23XF:     (     objects,     k,    P    )    \mapsto
  \mathtt{ProjectionInFactorOfDirectProductWithGivenDirectProduct}(objects, k,
  P)[123X.[133X
  
  [1X7.6-203 AddProjectionInFactorOfDirectSum[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfDirectSum[110X.  Optionally,  a  weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  k ) \mapsto \mathtt{ProjectionInFactorOfDirectSum}(objects, k)[123X.[133X
  
  [1X7.6-204 AddProjectionInFactorOfDirectSumWithGivenDirectSum[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfDirectSumWithGivenDirectSum[110X.    Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     objects,     k,    P    )    \mapsto
  \mathtt{ProjectionInFactorOfDirectSumWithGivenDirectSum}(objects, k, P)[123X.[133X
  
  [1X7.6-205 AddProjectionInFactorOfFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfFiberProduct[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  morphisms,  k ) \mapsto \mathtt{ProjectionInFactorOfFiberProduct}(morphisms,
  k)[123X.[133X
  
  [1X7.6-206 AddProjectionInFactorOfFiberProductWithGivenFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddProjectionInFactorOfFiberProductWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionInFactorOfFiberProductWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionInFactorOfFiberProductWithGivenFiberProduct[110X.  Optionally, a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (    morphisms,    k,    P    )    \mapsto
  \mathtt{ProjectionInFactorOfFiberProductWithGivenFiberProduct}(morphisms, k,
  P)[123X.[133X
  
  [1X7.6-207 AddProjectionOntoCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionOntoCoequalizer[110X.  Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex = faster execution). [23XF: ( Y,
  morphisms ) \mapsto \mathtt{ProjectionOntoCoequalizer}(Y, morphisms)[123X.[133X
  
  [1X7.6-208 AddProjectionOntoCoequalizerOfIdentityAndAutomorphisms[101X
  
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionOntoCoequalizerOfIdentityAndAutomorphisms[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     Y,     automorphisms    )    \mapsto
  \mathtt{ProjectionOntoCoequalizerOfIdentityAndAutomorphisms}(Y,
  automorphisms)[123X.[133X
  
  [1X7.6-209 AddProjectionOntoCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionOntoCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster  execution).  [23XF:  (  Y,  automorphisms, P ) \mapsto
  \mathtt{ProjectionOntoCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer}(Y,
  automorphisms, P)[123X.[133X
  
  [1X7.6-210 AddProjectionOntoCoequalizerWithGivenCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectionOntoCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectionOntoCoequalizerWithGivenCoequalizer[110X.    Optionally,    a    weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (    Y,    morphisms,    P    )    \mapsto
  \mathtt{ProjectionOntoCoequalizerWithGivenCoequalizer}(Y, morphisms, P)[123X.[133X
  
  [1X7.6-211 AddProjectiveCoverObject[101X
  
  [33X[1;0Y[29X[2XAddProjectiveCoverObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectiveCoverObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectiveCoverObject[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{ProjectiveCoverObject}(arg2)[123X.[133X
  
  [1X7.6-212 AddProjectiveDimension[101X
  
  [33X[1;0Y[29X[2XAddProjectiveDimension[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectiveDimension[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XProjectiveDimension[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{ProjectiveDimension}(arg2)[123X.[133X
  
  [1X7.6-213 AddProjectiveLift[101X
  
  [33X[1;0Y[29X[2XAddProjectiveLift[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddProjectiveLift[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XProjectiveLift[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (  alpha,  beta  )  \mapsto
  \mathtt{ProjectiveLift}(alpha, beta)[123X.[133X
  
  [1X7.6-214 AddPushout[101X
  
  [33X[1;0Y[29X[2XAddPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given   function  [23XF[123X  to  the  category  for  the  basic  operation  [10XPushout[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   morphisms   )   \mapsto
  \mathtt{Pushout}(morphisms)[123X.[133X
  
  [1X7.6-215 AddPushoutFunctorial[101X
  
  [33X[1;0Y[29X[2XAddPushoutFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPushoutFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function [23XF[123X to the category for the basic operation [10XPushoutFunctorial[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster execution). [23XF: ( morphisms, L, morphismsp ) \mapsto
  \mathtt{PushoutFunctorial}(morphisms, L, morphismsp)[123X.[133X
  
  [1X7.6-216 AddPushoutFunctorialWithGivenPushouts[101X
  
  [33X[1;0Y[29X[2XAddPushoutFunctorialWithGivenPushouts[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddPushoutFunctorialWithGivenPushouts[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XPushoutFunctorialWithGivenPushouts[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower weight = less complex = faster execution). [23XF: ( P,
  morphisms,         L,         morphismsp,         Pp        )        \mapsto
  \mathtt{PushoutFunctorialWithGivenPushouts}(P,   morphisms,  L,  morphismsp,
  Pp)[123X.[133X
  
  [1X7.6-217 AddRandomMorphismByInteger[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismByInteger[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismByInteger[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismByInteger[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less complex = faster execution). [23XF: ( n )
  \mapsto \mathtt{RandomMorphismByInteger}(n)[123X.[133X
  
  [1X7.6-218 AddRandomMorphismByList[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismByList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismByList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismByList[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( L ) \mapsto
  \mathtt{RandomMorphismByList}(L)[123X.[133X
  
  [1X7.6-219 AddRandomMorphismWithFixedRangeByInteger[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedRangeByInteger[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedRangeByInteger[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedRangeByInteger[110X.  Optionally,  a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( B, n ) \mapsto \mathtt{RandomMorphismWithFixedRangeByInteger}(B, n)[123X.[133X
  
  [1X7.6-220 AddRandomMorphismWithFixedRangeByList[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedRangeByList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedRangeByList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedRangeByList[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the function (lower weight = less complex = faster execution). [23XF: ( B, L
  ) \mapsto \mathtt{RandomMorphismWithFixedRangeByList}(B, L)[123X.[133X
  
  [1X7.6-221 AddRandomMorphismWithFixedSourceAndRangeByInteger[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceAndRangeByInteger[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceAndRangeByInteger[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedSourceAndRangeByInteger[110X.    Optionally,    a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster      execution).      [23XF:      (     A,     B,     n     )     \mapsto
  \mathtt{RandomMorphismWithFixedSourceAndRangeByInteger}(A, B, n)[123X.[133X
  
  [1X7.6-222 AddRandomMorphismWithFixedSourceAndRangeByList[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceAndRangeByList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceAndRangeByList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedSourceAndRangeByList[110X.  Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:          (          A,          B,          L          )          \mapsto
  \mathtt{RandomMorphismWithFixedSourceAndRangeByList}(A, B, L)[123X.[133X
  
  [1X7.6-223 AddRandomMorphismWithFixedSourceByInteger[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceByInteger[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceByInteger[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedSourceByInteger[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( A, n ) \mapsto \mathtt{RandomMorphismWithFixedSourceByInteger}(A, n)[123X.[133X
  
  [1X7.6-224 AddRandomMorphismWithFixedSourceByList[101X
  
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceByList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomMorphismWithFixedSourceByList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomMorphismWithFixedSourceByList[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the function (lower weight = less complex = faster execution). [23XF: ( A, L
  ) \mapsto \mathtt{RandomMorphismWithFixedSourceByList}(A, L)[123X.[133X
  
  [1X7.6-225 AddRandomObjectByInteger[101X
  
  [33X[1;0Y[29X[2XAddRandomObjectByInteger[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomObjectByInteger[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XRandomObjectByInteger[110X.  Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower weight = less complex = faster execution). [23XF: ( n ) \mapsto
  \mathtt{RandomObjectByInteger}(n)[123X.[133X
  
  [1X7.6-226 AddRandomObjectByList[101X
  
  [33X[1;0Y[29X[2XAddRandomObjectByList[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddRandomObjectByList[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XRandomObjectByList[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster    execution).    [23XF:    (    L    )   \mapsto
  \mathtt{RandomObjectByList}(L)[123X.[133X
  
  [1X7.6-227 AddSetOfGeneratingMorphismsOfCategory[101X
  
  [33X[1;0Y[29X[2XAddSetOfGeneratingMorphismsOfCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSetOfGeneratingMorphismsOfCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSetOfGeneratingMorphismsOfCategory[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower  weight = less complex = faster execution). [23XF: ( )
  \mapsto \mathtt{SetOfGeneratingMorphismsOfCategory}()[123X.[133X
  
  [1X7.6-228 AddSetOfMorphismsOfFiniteCategory[101X
  
  [33X[1;0Y[29X[2XAddSetOfMorphismsOfFiniteCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSetOfMorphismsOfFiniteCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSetOfMorphismsOfFiniteCategory[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( )
  \mapsto \mathtt{SetOfMorphismsOfFiniteCategory}()[123X.[133X
  
  [1X7.6-229 AddSetOfObjectsOfCategory[101X
  
  [33X[1;0Y[29X[2XAddSetOfObjectsOfCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSetOfObjectsOfCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSetOfObjectsOfCategory[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  = less complex = faster execution). [23XF: ( ) \mapsto
  \mathtt{SetOfObjectsOfCategory}()[123X.[133X
  
  [1X7.6-230 AddSimplifyEndo[101X
  
  [33X[1;0Y[29X[2XAddSimplifyEndo[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyEndo[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XSimplifyEndo[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex   =   faster   execution).   [23XF:   (   mor,   n   )   \mapsto
  \mathtt{SimplifyEndo}(mor, n)[123X.[133X
  
  [1X7.6-231 AddSimplifyEndo_IsoFromInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyEndo_IsoFromInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyEndo_IsoFromInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyEndo_IsoFromInputObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifyEndo_IsoFromInputObject}(mor, n)[123X.[133X
  
  [1X7.6-232 AddSimplifyEndo_IsoToInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyEndo_IsoToInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyEndo_IsoToInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyEndo_IsoToInputObject[110X.  Optionally,  a  weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifyEndo_IsoToInputObject}(mor, n)[123X.[133X
  
  [1X7.6-233 AddSimplifyMorphism[101X
  
  [33X[1;0Y[29X[2XAddSimplifyMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X to the category for the basic operation [10XSimplifyMorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex   =   faster   execution).   [23XF:   (   mor,   n   )   \mapsto
  \mathtt{SimplifyMorphism}(mor, n)[123X.[133X
  
  [1X7.6-234 AddSimplifyObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XSimplifyObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   A,   n   )   \mapsto
  \mathtt{SimplifyObject}(A, n)[123X.[133X
  
  [1X7.6-235 AddSimplifyObject_IsoFromInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyObject_IsoFromInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyObject_IsoFromInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyObject_IsoFromInputObject[110X.  Optionally,  a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the function (lower weight = less complex = faster execution). [23XF: ( A, n
  ) \mapsto \mathtt{SimplifyObject_IsoFromInputObject}(A, n)[123X.[133X
  
  [1X7.6-236 AddSimplifyObject_IsoToInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyObject_IsoToInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyObject_IsoToInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyObject_IsoToInputObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( A, n )
  \mapsto \mathtt{SimplifyObject_IsoToInputObject}(A, n)[123X.[133X
  
  [1X7.6-237 AddSimplifyRange[101X
  
  [33X[1;0Y[29X[2XAddSimplifyRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category for the basic operation [10XSimplifyRange[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex   =   faster   execution).   [23XF:   (   mor,   n   )   \mapsto
  \mathtt{SimplifyRange}(mor, n)[123X.[133X
  
  [1X7.6-238 AddSimplifyRange_IsoFromInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyRange_IsoFromInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyRange_IsoFromInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyRange_IsoFromInputObject[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifyRange_IsoFromInputObject}(mor, n)[123X.[133X
  
  [1X7.6-239 AddSimplifyRange_IsoToInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifyRange_IsoToInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifyRange_IsoToInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifyRange_IsoToInputObject[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifyRange_IsoToInputObject}(mor, n)[123X.[133X
  
  [1X7.6-240 AddSimplifySource[101X
  
  [33X[1;0Y[29X[2XAddSimplifySource[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySource[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XSimplifySource[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex   =   faster   execution).   [23XF:   (   mor,   n   )   \mapsto
  \mathtt{SimplifySource}(mor, n)[123X.[133X
  
  [1X7.6-241 AddSimplifySourceAndRange[101X
  
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySourceAndRange[110X. Optionally, a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifySourceAndRange}(mor, n)[123X.[133X
  
  [1X7.6-242 AddSimplifySourceAndRange_IsoFromInputRange[101X
  
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoFromInputRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoFromInputRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySourceAndRange_IsoFromInputRange[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF: ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoFromInputRange}(mor,
  n)[123X.[133X
  
  [1X7.6-243 AddSimplifySourceAndRange_IsoFromInputSource[101X
  
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoFromInputSource[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoFromInputSource[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySourceAndRange_IsoFromInputSource[110X.  Optionally,  a  weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:            (            mor,            n            )            \mapsto
  \mathtt{SimplifySourceAndRange_IsoFromInputSource}(mor, n)[123X.[133X
  
  [1X7.6-244 AddSimplifySourceAndRange_IsoToInputRange[101X
  
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoToInputRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoToInputRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySourceAndRange_IsoToInputRange[110X.  Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:  (  mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputRange}(mor,
  n)[123X.[133X
  
  [1X7.6-245 AddSimplifySourceAndRange_IsoToInputSource[101X
  
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoToInputSource[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySourceAndRange_IsoToInputSource[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySourceAndRange_IsoToInputSource[110X. Optionally, a weight (default: 100)
  can  be  specified  which  should  roughly  correspond  to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:  ( mor, n ) \mapsto \mathtt{SimplifySourceAndRange_IsoToInputSource}(mor,
  n)[123X.[133X
  
  [1X7.6-246 AddSimplifySource_IsoFromInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifySource_IsoFromInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySource_IsoFromInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySource_IsoFromInputObject[110X.  Optionally,  a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the function (lower weight = less complex = faster execution). [23XF: ( mor,
  n ) \mapsto \mathtt{SimplifySource_IsoFromInputObject}(mor, n)[123X.[133X
  
  [1X7.6-247 AddSimplifySource_IsoToInputObject[101X
  
  [33X[1;0Y[29X[2XAddSimplifySource_IsoToInputObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSimplifySource_IsoToInputObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSimplifySource_IsoToInputObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( mor, n )
  \mapsto \mathtt{SimplifySource_IsoToInputObject}(mor, n)[123X.[133X
  
  [1X7.6-248 AddSolveLinearSystemInAbCategory[101X
  
  [33X[1;0Y[29X[2XAddSolveLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSolveLinearSystemInAbCategory[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSolveLinearSystemInAbCategory[110X.  Optionally,  a  weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight = less complex = faster execution). [23XF: ( arg2,
  arg3,  arg4  )  \mapsto  \mathtt{SolveLinearSystemInAbCategory}(arg2,  arg3,
  arg4)[123X.[133X
  
  [1X7.6-249 AddSomeInjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddSomeInjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeInjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeInjectiveObject[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{SomeInjectiveObject}(arg2)[123X.[133X
  
  [1X7.6-250 AddSomeIsomorphismBetweenObjects[101X
  
  [33X[1;0Y[29X[2XAddSomeIsomorphismBetweenObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeIsomorphismBetweenObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeIsomorphismBetweenObjects[110X.  Optionally,  a  weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  object_1,                 object_2                 )                 \mapsto
  \mathtt{SomeIsomorphismBetweenObjects}(object_1, object_2)[123X.[133X
  
  [1X7.6-251 AddSomeProjectiveObject[101X
  
  [33X[1;0Y[29X[2XAddSomeProjectiveObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeProjectiveObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeProjectiveObject[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( arg2 )
  \mapsto \mathtt{SomeProjectiveObject}(arg2)[123X.[133X
  
  [1X7.6-252 AddSomeReductionBySplitEpiSummand[101X
  
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeReductionBySplitEpiSummand[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function (lower weight = less complex = faster execution). [23XF: ( alpha )
  \mapsto \mathtt{SomeReductionBySplitEpiSummand}(alpha)[123X.[133X
  
  [1X7.6-253 AddSomeReductionBySplitEpiSummand_MorphismFromInputRange[101X
  
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand_MorphismFromInputRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand_MorphismFromInputRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeReductionBySplitEpiSummand_MorphismFromInputRange[110X.  Optionally, a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster        execution).       [23XF:       (       alpha       )       \mapsto
  \mathtt{SomeReductionBySplitEpiSummand_MorphismFromInputRange}(alpha)[123X.[133X
  
  [1X7.6-254 AddSomeReductionBySplitEpiSummand_MorphismToInputRange[101X
  
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand_MorphismToInputRange[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSomeReductionBySplitEpiSummand_MorphismToInputRange[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSomeReductionBySplitEpiSummand_MorphismToInputRange[110X.  Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster        execution).       [23XF:       (       alpha       )       \mapsto
  \mathtt{SomeReductionBySplitEpiSummand_MorphismToInputRange}(alpha)[123X.[133X
  
  [1X7.6-255 AddSubtractionForMorphisms[101X
  
  [33X[1;0Y[29X[2XAddSubtractionForMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSubtractionForMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XSubtractionForMorphisms[110X.   Optionally,   a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  beta ) \mapsto \mathtt{SubtractionForMorphisms}(alpha, beta)[123X.[133X
  
  [1X7.6-256 AddSumOfMorphisms[101X
  
  [33X[1;0Y[29X[2XAddSumOfMorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddSumOfMorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XSumOfMorphisms[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less  complex  =  faster execution). [23XF: ( source, list_of_morphisms, range )
  \mapsto \mathtt{SumOfMorphisms}(source, list_of_morphisms, range)[123X.[133X
  
  [1X7.6-257 AddTerminalObject[101X
  
  [33X[1;0Y[29X[2XAddTerminalObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddTerminalObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the category for the basic operation [10XTerminalObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less complex = faster execution). [23XF: ( ) \mapsto \mathtt{TerminalObject}()[123X.[133X
  
  [1X7.6-258 AddTerminalObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddTerminalObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddTerminalObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XTerminalObjectFunctorial[110X.   Optionally,  a  weight  (default:  100)  can  be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  = faster execution). [23XF: ( )
  \mapsto \mathtt{TerminalObjectFunctorial}()[123X.[133X
  
  [1X7.6-259 AddTerminalObjectFunctorialWithGivenTerminalObjects[101X
  
  [33X[1;0Y[29X[2XAddTerminalObjectFunctorialWithGivenTerminalObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddTerminalObjectFunctorialWithGivenTerminalObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XTerminalObjectFunctorialWithGivenTerminalObjects[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:      (      P,      Pp      )      \mapsto
  \mathtt{TerminalObjectFunctorialWithGivenTerminalObjects}(P, Pp)[123X.[133X
  
  [1X7.6-260 AddUniversalMorphismFromCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoequalizer[110X. Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex = faster execution). [23XF: ( Y,
  morphisms,  T,  tau  )  \mapsto \mathtt{UniversalMorphismFromCoequalizer}(Y,
  morphisms, T, tau)[123X.[133X
  
  [1X7.6-261 AddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphisms[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphisms[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoequalizerOfIdentityAndAutomorphisms[110X.   Optionally,  a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster   execution).   [23XF:   (   Y,   automorphisms,   T,   tau   )   \mapsto
  \mathtt{UniversalMorphismFromCoequalizerOfIdentityAndAutomorphisms}(Y,
  automorphisms, T, tau)[123X.[133X
  
  [1X7.6-262 AddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less complex = faster execution). [23XF: ( Y, automorphisms, T, tau, P ) \mapsto
  \mathtt{UniversalMorphismFromCoequalizerOfIdentityAndAutomorphismsWithGivenCoequalizer}(Y,
  automorphisms, T, tau, P)[123X.[133X
  
  [1X7.6-263 AddUniversalMorphismFromCoequalizerWithGivenCoequalizer[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoequalizerWithGivenCoequalizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoequalizerWithGivenCoequalizer[110X.  Optionally,  a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   Y,   morphisms,   T,   tau,   P   )  \mapsto
  \mathtt{UniversalMorphismFromCoequalizerWithGivenCoequalizer}(Y,  morphisms,
  T, tau, P)[123X.[133X
  
  [1X7.6-264 AddUniversalMorphismFromCoproduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoproduct[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  T, tau ) \mapsto \mathtt{UniversalMorphismFromCoproduct}(objects, T, tau)[123X.[133X
  
  [1X7.6-265 AddUniversalMorphismFromCoproductWithGivenCoproduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoproductWithGivenCoproduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromCoproductWithGivenCoproduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromCoproductWithGivenCoproduct[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster    execution).    [23XF:    (    objects,    T,    tau,   P   )   \mapsto
  \mathtt{UniversalMorphismFromCoproductWithGivenCoproduct}(objects,  T,  tau,
  P)[123X.[133X
  
  [1X7.6-266 AddUniversalMorphismFromDirectSum[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromDirectSum[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  T, tau ) \mapsto \mathtt{UniversalMorphismFromDirectSum}(objects, T, tau)[123X.[133X
  
  [1X7.6-267 AddUniversalMorphismFromDirectSumWithGivenDirectSum[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromDirectSumWithGivenDirectSum[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster    execution).    [23XF:    (    objects,    T,    tau,   P   )   \mapsto
  \mathtt{UniversalMorphismFromDirectSumWithGivenDirectSum}(objects,  T,  tau,
  P)[123X.[133X
  
  [1X7.6-268 AddUniversalMorphismFromImage[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromImage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromImage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromImage[110X.  Optionally,  a  weight  (default:  100)  can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  tau ) \mapsto \mathtt{UniversalMorphismFromImage}(alpha, tau)[123X.[133X
  
  [1X7.6-269 AddUniversalMorphismFromImageWithGivenImageObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromImageWithGivenImageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromImageWithGivenImageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromImageWithGivenImageObject[110X.    Optionally,    a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     alpha,     tau,    I    )    \mapsto
  \mathtt{UniversalMorphismFromImageWithGivenImageObject}(alpha, tau, I)[123X.[133X
  
  [1X7.6-270 AddUniversalMorphismFromInitialObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromInitialObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromInitialObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromInitialObject[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( T )
  \mapsto \mathtt{UniversalMorphismFromInitialObject}(T)[123X.[133X
  
  [1X7.6-271 AddUniversalMorphismFromInitialObjectWithGivenInitialObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromInitialObjectWithGivenInitialObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromInitialObjectWithGivenInitialObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromInitialObjectWithGivenInitialObject[110X.    Optionally,   a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster       execution).       [23XF:       (      T,      P      )      \mapsto
  \mathtt{UniversalMorphismFromInitialObjectWithGivenInitialObject}(T, P)[123X.[133X
  
  [1X7.6-272 AddUniversalMorphismFromPushout[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromPushout[110X.  Optionally,  a  weight  (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex  =  faster  execution). [23XF: (
  morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromPushout}(morphisms,
  T, tau)[123X.[133X
  
  [1X7.6-273 AddUniversalMorphismFromPushoutWithGivenPushout[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromPushoutWithGivenPushout[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromPushoutWithGivenPushout[110X. Optionally, a weight (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:       (       morphisms,       T,       tau,       P       )      \mapsto
  \mathtt{UniversalMorphismFromPushoutWithGivenPushout}(morphisms, T, tau, P)[123X.[133X
  
  [1X7.6-274 AddUniversalMorphismFromZeroObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromZeroObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less complex = faster execution). [23XF: ( T )
  \mapsto \mathtt{UniversalMorphismFromZeroObject}(T)[123X.[133X
  
  [1X7.6-275 AddUniversalMorphismFromZeroObjectWithGivenZeroObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismFromZeroObjectWithGivenZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismFromZeroObjectWithGivenZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismFromZeroObjectWithGivenZeroObject[110X.   Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:       (      T,      P      )      \mapsto
  \mathtt{UniversalMorphismFromZeroObjectWithGivenZeroObject}(T, P)[123X.[133X
  
  [1X7.6-276 AddUniversalMorphismIntoCoimage[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoCoimage[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoCoimage[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoCoimage[110X.  Optionally,  a  weight  (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower weight = less complex = faster execution). [23XF: ( alpha,
  tau ) \mapsto \mathtt{UniversalMorphismIntoCoimage}(alpha, tau)[123X.[133X
  
  [1X7.6-277 AddUniversalMorphismIntoCoimageWithGivenCoimageObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoCoimageWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoCoimageWithGivenCoimageObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoCoimageWithGivenCoimageObject[110X.   Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster     execution).     [23XF:     (     alpha,     tau,    C    )    \mapsto
  \mathtt{UniversalMorphismIntoCoimageWithGivenCoimageObject}(alpha, tau, C)[123X.[133X
  
  [1X7.6-278 AddUniversalMorphismIntoDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoDirectProduct[110X.  Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower  weight  =  less complex = faster execution). [23XF: (
  objects,              T,              tau              )             \mapsto
  \mathtt{UniversalMorphismIntoDirectProduct}(objects, T, tau)[123X.[133X
  
  [1X7.6-279 AddUniversalMorphismIntoDirectProductWithGivenDirectProduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectProductWithGivenDirectProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectProductWithGivenDirectProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoDirectProductWithGivenDirectProduct[110X.    Optionally,   a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster    execution).    [23XF:    (    objects,    T,    tau,   P   )   \mapsto
  \mathtt{UniversalMorphismIntoDirectProductWithGivenDirectProduct}(objects,
  T, tau, P)[123X.[133X
  
  [1X7.6-280 AddUniversalMorphismIntoDirectSum[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoDirectSum[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the function (lower weight = less complex = faster execution). [23XF: ( objects,
  T, tau ) \mapsto \mathtt{UniversalMorphismIntoDirectSum}(objects, T, tau)[123X.[133X
  
  [1X7.6-281 AddUniversalMorphismIntoDirectSumWithGivenDirectSum[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoDirectSumWithGivenDirectSum[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoDirectSumWithGivenDirectSum[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster    execution).    [23XF:    (    objects,    T,    tau,   P   )   \mapsto
  \mathtt{UniversalMorphismIntoDirectSumWithGivenDirectSum}(objects,  T,  tau,
  P)[123X.[133X
  
  [1X7.6-282 AddUniversalMorphismIntoEqualizer[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoEqualizer[110X.  Optionally,  a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less  complex = faster execution). [23XF: ( Y,
  morphisms,   T,  tau  )  \mapsto  \mathtt{UniversalMorphismIntoEqualizer}(Y,
  morphisms, T, tau)[123X.[133X
  
  [1X7.6-283 AddUniversalMorphismIntoEqualizerWithGivenEqualizer[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoEqualizerWithGivenEqualizer[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoEqualizerWithGivenEqualizer[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoEqualizerWithGivenEqualizer[110X.   Optionally,   a   weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster   execution).   [23XF:   (   Y,   morphisms,   T,   tau,   P   )  \mapsto
  \mathtt{UniversalMorphismIntoEqualizerWithGivenEqualizer}(Y,  morphisms,  T,
  tau, P)[123X.[133X
  
  [1X7.6-284 AddUniversalMorphismIntoFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoFiberProduct[110X.  Optionally,  a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function  (lower  weight  =  less complex = faster execution). [23XF: (
  morphisms,              T,             tau             )             \mapsto
  \mathtt{UniversalMorphismIntoFiberProduct}(morphisms, T, tau)[123X.[133X
  
  [1X7.6-285 AddUniversalMorphismIntoFiberProductWithGivenFiberProduct[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoFiberProductWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoFiberProductWithGivenFiberProduct[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoFiberProductWithGivenFiberProduct[110X. Optionally, a weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster    execution).    [23XF:    (    morphisms,   T,   tau,   P   )   \mapsto
  \mathtt{UniversalMorphismIntoFiberProductWithGivenFiberProduct}(morphisms,
  T, tau, P)[123X.[133X
  
  [1X7.6-286 AddUniversalMorphismIntoTerminalObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoTerminalObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoTerminalObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoTerminalObject[110X. Optionally, a weight (default: 100) can
  be specified which should roughly correspond to the computational complexity
  of  the  function (lower weight = less complex = faster execution). [23XF: ( T )
  \mapsto \mathtt{UniversalMorphismIntoTerminalObject}(T)[123X.[133X
  
  [1X7.6-287 AddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoTerminalObjectWithGivenTerminalObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoTerminalObjectWithGivenTerminalObject[110X.   Optionally,  a
  weight  (default:  100)  can be specified which should roughly correspond to
  the  computational complexity of the function (lower weight = less complex =
  faster       execution).       [23XF:       (      T,      P      )      \mapsto
  \mathtt{UniversalMorphismIntoTerminalObjectWithGivenTerminalObject}(T, P)[123X.[133X
  
  [1X7.6-288 AddUniversalMorphismIntoZeroObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoZeroObject[110X.  Optionally, a weight (default: 100) can be
  specified which should roughly correspond to the computational complexity of
  the  function  (lower  weight  =  less complex = faster execution). [23XF: ( T )
  \mapsto \mathtt{UniversalMorphismIntoZeroObject}(T)[123X.[133X
  
  [1X7.6-289 AddUniversalMorphismIntoZeroObjectWithGivenZeroObject[101X
  
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoZeroObjectWithGivenZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddUniversalMorphismIntoZeroObjectWithGivenZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XUniversalMorphismIntoZeroObjectWithGivenZeroObject[110X.   Optionally,  a  weight
  (default:  100)  can  be  specified  which  should roughly correspond to the
  computational  complexity  of  the  function  (lower weight = less complex =
  faster       execution).       [23XF:       (      T,      P      )      \mapsto
  \mathtt{UniversalMorphismIntoZeroObjectWithGivenZeroObject}(T, P)[123X.[133X
  
  [1X7.6-290 AddVerticalPostCompose[101X
  
  [33X[1;0Y[29X[2XAddVerticalPostCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddVerticalPostCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XVerticalPostCompose[110X.  Optionally,  a  weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function (lower weight = less complex = faster execution). [23XF: ( arg2, arg3 )
  \mapsto \mathtt{VerticalPostCompose}(arg2, arg3)[123X.[133X
  
  [1X7.6-291 AddVerticalPreCompose[101X
  
  [33X[1;0Y[29X[2XAddVerticalPreCompose[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddVerticalPreCompose[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given function [23XF[123X to the category for the basic operation [10XVerticalPreCompose[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less   complex   =   faster   execution).   [23XF:   (   arg2,  arg3  )  \mapsto
  \mathtt{VerticalPreCompose}(arg2, arg3)[123X.[133X
  
  [1X7.6-292 AddZeroMorphism[101X
  
  [33X[1;0Y[29X[2XAddZeroMorphism[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddZeroMorphism[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for the basic operation [10XZeroMorphism[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less    complex    =    faster   execution).   [23XF:   (   a,   b   )   \mapsto
  \mathtt{ZeroMorphism}(a, b)[123X.[133X
  
  [1X7.6-293 AddZeroObject[101X
  
  [33X[1;0Y[29X[2XAddZeroObject[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddZeroObject[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given  function  [23XF[123X  to  the  category  for  the  basic operation [10XZeroObject[110X.
  Optionally,  a  weight  (default: 100) can be specified which should roughly
  correspond  to  the computational complexity of the function (lower weight =
  less complex = faster execution). [23XF: ( ) \mapsto \mathtt{ZeroObject}()[123X.[133X
  
  [1X7.6-294 AddZeroObjectFunctorial[101X
  
  [33X[1;0Y[29X[2XAddZeroObjectFunctorial[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddZeroObjectFunctorial[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XZeroObjectFunctorial[110X.  Optionally,  a weight (default: 100) can be specified
  which  should  roughly  correspond  to  the  computational complexity of the
  function  (lower  weight  = less complex = faster execution). [23XF: ( ) \mapsto
  \mathtt{ZeroObjectFunctorial}()[123X.[133X
  
  [1X7.6-295 AddZeroObjectFunctorialWithGivenZeroObjects[101X
  
  [33X[1;0Y[29X[2XAddZeroObjectFunctorialWithGivenZeroObjects[102X( [3XC[103X, [3XF[103X ) [32X operation[133X
  [33X[1;0Y[29X[2XAddZeroObjectFunctorialWithGivenZeroObjects[102X( [3XC[103X, [3XF[103X, [3Xweight[103X ) [32X operation[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YThe  arguments  are  a  category [23XC[123X and a function [23XF[123X. This operation adds the
  given    function    [23XF[123X   to   the   category   for   the   basic   operation
  [10XZeroObjectFunctorialWithGivenZeroObjects[110X.  Optionally,  a  weight  (default:
  100)  can  be specified which should roughly correspond to the computational
  complexity of the function (lower weight = less complex = faster execution).
  [23XF:  (  P,  Pp ) \mapsto \mathtt{ZeroObjectFunctorialWithGivenZeroObjects}(P,
  Pp)[123X.[133X
  
