From 362fe99c288504f7efe33dde3aafdd73ac8396a8 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Thu, 12 Sep 2024 08:40:49 +0200 Subject: [PATCH] Adjust to CAP 2024.09-08 --- TriangulatedCategories/PackageInfo.g | 2 +- .../gap/MethodRecord.autogen.gd | 332 +++++++++--------- 2 files changed, 167 insertions(+), 167 deletions(-) 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 ] );