diff --git a/TriangulatedCategories/PackageInfo.g b/TriangulatedCategories/PackageInfo.g
index 26db561d..3727ffa1 100644
--- a/TriangulatedCategories/PackageInfo.g
+++ b/TriangulatedCategories/PackageInfo.g
@@ -10,7 +10,7 @@ SetPackageInfo( rec(
 
 PackageName := "TriangulatedCategories",
 Subtitle := "Framework for triangulated categories",
-Version := "2024.09-01",
+Version := "2024.09-02",
 Date := (function ( ) if IsBound( GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE ) then return GAPInfo.SystemEnvironment.GAP_PKG_RELEASE_DATE; else return Concatenation( ~.Version{[ 1 .. 4 ]}, "-", ~.Version{[ 6, 7 ]}, "-01" ); fi; end)( ),
 License := "GPL-2.0-or-later",
 
diff --git a/TriangulatedCategories/gap/MethodRecord.autogen.gd b/TriangulatedCategories/gap/MethodRecord.autogen.gd
index 5b696980..58a55734 100644
--- a/TriangulatedCategories/gap/MethodRecord.autogen.gd
+++ b/TriangulatedCategories/gap/MethodRecord.autogen.gd
@@ -3,635 +3,635 @@
 #
 # Declarations
 #
-# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecord.gi
+# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi
 
 #! @Chapter operations for triangulated categories
 
 #! @Section Add-methods
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `CounitOfShiftAdjunctionWithGivenObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, r ) \mapsto \mathtt{CounitOfShiftAdjunctionWithGivenObject}(s, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddCounitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddCounitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddCounitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddCounitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `DomainMorphismByOctahedralAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4, arg5, arg6 ) \mapsto \mathtt{DomainMorphismByOctahedralAxiomWithGivenObjects}(arg2, arg3, arg4, arg5, arg6)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddDomainMorphismByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddDomainMorphismByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddDomainMorphismByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddDomainMorphismByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseOfCounitOfShiftAdjunctionWithGivenObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, r ) \mapsto \mathtt{InverseOfCounitOfShiftAdjunctionWithGivenObject}(s, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseOfCounitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseOfCounitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseOfCounitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseOfCounitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseOfUnitOfShiftAdjunctionWithGivenObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, r ) \mapsto \mathtt{InverseOfUnitOfShiftAdjunctionWithGivenObject}(s, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseOfUnitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseOfUnitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseOfUnitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseOfUnitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseShiftExpandingIsomorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, L, r ) \mapsto \mathtt{InverseShiftExpandingIsomorphismWithGivenObjects}(s, L, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseShiftExpandingIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseShiftExpandingIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseShiftExpandingIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseShiftExpandingIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseShiftFactoringIsomorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, L, r ) \mapsto \mathtt{InverseShiftFactoringIsomorphismWithGivenObjects}(s, L, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseShiftFactoringIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseShiftFactoringIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseShiftFactoringIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseShiftFactoringIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseShiftOfMorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, alpha, r ) \mapsto \mathtt{InverseShiftOfMorphismWithGivenObjects}(s, alpha, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseShiftOfMorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseShiftOfMorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseShiftOfMorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseShiftOfMorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `InverseShiftOfObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2 ) \mapsto \mathtt{InverseShiftOfObject}(arg2)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddInverseShiftOfObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddInverseShiftOfObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddInverseShiftOfObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddInverseShiftOfObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `IsExactTriangle`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4 ) \mapsto \mathtt{IsExactTriangle}(arg2, arg3, arg4)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddIsExactTriangle",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddIsExactTriangle",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddIsExactTriangle",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddIsExactTriangle",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismBetweenStandardConeObjectsWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( cone_alpha, list, cone_alpha_prime ) \mapsto \mathtt{MorphismBetweenStandardConeObjectsWithGivenObjects}(cone_alpha, list, cone_alpha_prime)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismBetweenStandardConeObjectsWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismBetweenStandardConeObjectsWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismBetweenStandardConeObjectsWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismBetweenStandardConeObjectsWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismFromConeObjectByOctahedralAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4, arg5, arg6 ) \mapsto \mathtt{MorphismFromConeObjectByOctahedralAxiomWithGivenObjects}(arg2, arg3, arg4, arg5, arg6)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismFromStandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( alpha ) \mapsto \mathtt{MorphismFromStandardConeObject}(alpha)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismFromStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismFromStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismFromStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismFromStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismFromStandardConeObjectWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( cone_alpha, alpha, sh_source_alpha ) \mapsto \mathtt{MorphismFromStandardConeObjectWithGivenObjects}(cone_alpha, alpha, sh_source_alpha)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismFromStandardConeObjectWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismFromStandardConeObjectWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismFromStandardConeObjectWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismFromStandardConeObjectWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismIntoConeObjectByOctahedralAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4, arg5, arg6 ) \mapsto \mathtt{MorphismIntoConeObjectByOctahedralAxiomWithGivenObjects}(arg2, arg3, arg4, arg5, arg6)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismIntoStandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( alpha ) \mapsto \mathtt{MorphismIntoStandardConeObject}(alpha)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismIntoStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismIntoStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismIntoStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismIntoStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `MorphismIntoStandardConeObjectWithGivenStandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( alpha, cone ) \mapsto \mathtt{MorphismIntoStandardConeObjectWithGivenStandardConeObject}(alpha, cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddMorphismIntoStandardConeObjectWithGivenStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddMorphismIntoStandardConeObjectWithGivenStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddMorphismIntoStandardConeObjectWithGivenStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddMorphismIntoStandardConeObjectWithGivenStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftExpandingIsomorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, L, r ) \mapsto \mathtt{ShiftExpandingIsomorphismWithGivenObjects}(s, L, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftExpandingIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftExpandingIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftExpandingIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftExpandingIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftFactoringIsomorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, L, r ) \mapsto \mathtt{ShiftFactoringIsomorphismWithGivenObjects}(s, L, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftFactoringIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftFactoringIsomorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftFactoringIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftFactoringIsomorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftOfMorphismByInteger`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3 ) \mapsto \mathtt{ShiftOfMorphismByInteger}(arg2, arg3)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftOfMorphismByInteger",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftOfMorphismByInteger",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftOfMorphismByInteger",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftOfMorphismByInteger",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftOfMorphismByIntegerWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4, arg5 ) \mapsto \mathtt{ShiftOfMorphismByIntegerWithGivenObjects}(arg2, arg3, arg4, arg5)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftOfMorphismByIntegerWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftOfMorphismByIntegerWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftOfMorphismByIntegerWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftOfMorphismByIntegerWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftOfMorphismWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3, arg4 ) \mapsto \mathtt{ShiftOfMorphismWithGivenObjects}(arg2, arg3, arg4)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftOfMorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftOfMorphismWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftOfMorphismWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftOfMorphismWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftOfObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2 ) \mapsto \mathtt{ShiftOfObject}(arg2)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftOfObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftOfObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftOfObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftOfObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `ShiftOfObjectByInteger`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2, arg3 ) \mapsto \mathtt{ShiftOfObjectByInteger}(arg2, arg3)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddShiftOfObjectByInteger",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddShiftOfObjectByInteger",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddShiftOfObjectByInteger",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddShiftOfObjectByInteger",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `StandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( arg2 ) \mapsto \mathtt{StandardConeObject}(arg2)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `UnitOfShiftAdjunctionWithGivenObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( s, r ) \mapsto \mathtt{UnitOfShiftAdjunctionWithGivenObject}(s, r)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddUnitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddUnitOfShiftAdjunctionWithGivenObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddUnitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddUnitOfShiftAdjunctionWithGivenObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismFromStandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( alpha, iota, pi ) \mapsto \mathtt{WitnessIsomorphismFromStandardConeObject}(alpha, iota, pi)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( st_cone, f, cone ) \mapsto \mathtt{WitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects}(st_cone, f, cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( st_cone, f, g, h, cone_g ) \mapsto \mathtt{WitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects}(st_cone, f, g, h, cone_g)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( st_cone, f, cone ) \mapsto \mathtt{WitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects}(st_cone, f, cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismIntoStandardConeObject`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( alpha, iota, pi ) \mapsto \mathtt{WitnessIsomorphismIntoStandardConeObject}(alpha, iota, pi)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObject",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObject",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObject",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObject",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( cone, f, st_cone ) \mapsto \mathtt{WitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects}(cone, f, st_cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( cone_g, f, g, h, st_cone ) \mapsto \mathtt{WitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects}(cone_g, f, g, h, st_cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );
 
+#! @BeginGroup
 #! @Description
 #! The arguments are a category $C$ and a function $F$.
 #! This operation adds the given function $F$
 #! to the category for the basic operation `WitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects`.
+#! Optionally, a weight (default: 100) can be specified which should roughly correspond
+#! to the computational complexity of the function (lower weight = less complex = faster execution).
 #! $F: ( cone, f, st_cone ) \mapsto \mathtt{WitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects}(cone, f, st_cone)$.
 #! @Returns nothing
 #! @Arguments C, F
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction ] );
 
+#! @Arguments C, F, weight
 DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects",
                   [ IsCapCategory, IsFunction, IsInt ] );
+#! @EndGroup
 
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList, IsInt ] );
-
-DeclareOperation( "AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects",
-                  [ IsCapCategory, IsList ] );