diff --git a/FpCategories/PackageInfo.g b/FpCategories/PackageInfo.g index 56385ed9c..1bb566686 100644 --- a/FpCategories/PackageInfo.g +++ b/FpCategories/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "FpCategories", Subtitle := "Finitely presented categories by generating quivers and relations", -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", @@ -85,7 +85,7 @@ Dependencies := rec( GAP := ">= 4.13.0", NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], - [ "CAP", ">= 2024.09-05" ], + [ "CAP", ">= 2024.09-08" ], [ "ToolsForCategoricalTowers", ">= 2024.03-02" ], [ "QuotientCategories", ">= 2024.02-01" ], [ "FinSetsForCAP", ">= 2023.10-03" ], diff --git a/FpCategories/gap/Tools.autogen.gd b/FpCategories/gap/Tools.autogen.gd index b1d1f0a65..81c79776c 100644 --- a/FpCategories/gap/Tools.autogen.gd +++ b/FpCategories/gap/Tools.autogen.gd @@ -3,27 +3,27 @@ # # 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 Futher CAP operations #! @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 `SetOfGeneratingMorphismsOfCategory`. +#! Optionally, 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: ( ) \mapsto \mathtt{SetOfGeneratingMorphismsOfCategory}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSetOfGeneratingMorphismsOfCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSetOfGeneratingMorphismsOfCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSetOfGeneratingMorphismsOfCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSetOfGeneratingMorphismsOfCategory", - [ IsCapCategory, IsList ] ); diff --git a/FunctorCategories/PackageInfo.g b/FunctorCategories/PackageInfo.g index d4b2561d3..de5549fb7 100644 --- a/FunctorCategories/PackageInfo.g +++ b/FunctorCategories/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "FunctorCategories", Subtitle := "Categories of functors", -Version := "2024.09-04", +Version := "2024.09-05", Date := ~.Version{[ 1 .. 10 ]}, 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)( ), @@ -89,7 +89,7 @@ Dependencies := rec( NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], [ "ToolsForHomalg", ">= 2022.12-01" ], - [ "CAP", ">= 2024.09-05" ], + [ "CAP", ">= 2024.09-08" ], [ "MonoidalCategories", ">= 2024.06-02" ], [ "CartesianCategories", ">= 2024.06-03" ], [ "ToolsForCategoricalTowers", ">= 2024.03-02" ], diff --git a/FunctorCategories/gap/Tools.autogen.gd b/FunctorCategories/gap/Tools.autogen.gd index f885f9b5d..b1ef61139 100644 --- a/FunctorCategories/gap/Tools.autogen.gd +++ b/FunctorCategories/gap/Tools.autogen.gd @@ -3,27 +3,27 @@ # # 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 Futher CAP operations #! @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 `IsReflexive`. +#! Optionally, 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{IsReflexive}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsReflexive", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsReflexive", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsReflexive", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsReflexive", - [ IsCapCategory, IsList ] ); diff --git a/Locales/PackageInfo.g b/Locales/PackageInfo.g index 03c5afb6b..7abdb31b4 100644 --- a/Locales/PackageInfo.g +++ b/Locales/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "Locales", Subtitle := "Locales, frames, coframes, meet semi-lattices of locally closed subsets, and Boolean algebras of constructible sets", -Version := "2024.09-05", +Version := "2024.09-06", Date := ~.Version{[ 1 .. 10 ]}, 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", @@ -102,7 +102,7 @@ Dependencies := rec( NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], [ "ToolsForHomalg", ">= 2021.12-02" ], - [ "CAP", ">= 2024.09-05" ], + [ "CAP", ">= 2024.09-08" ], [ "CompilerForCAP", ">= 2022.08-10" ], [ "MonoidalCategories", ">= 2024.02-02" ], [ "CartesianCategories", ">= 2024.02-02" ], diff --git a/Locales/gap/BooleanAlgebra.autogen.gd b/Locales/gap/BooleanAlgebra.autogen.gd index ec4eaf9d1..cd3848782 100644 --- a/Locales/gap/BooleanAlgebra.autogen.gd +++ b/Locales/gap/BooleanAlgebra.autogen.gd @@ -3,84 +3,84 @@ # # 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 Boolean algebras #! @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 `MorphismFromDoubleNegation`. +#! Optionally, 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: ( a ) \mapsto \mathtt{MorphismFromDoubleNegation}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismFromDoubleNegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismFromDoubleNegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismFromDoubleNegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismFromDoubleNegation", - [ 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 `MorphismFromDoubleNegationWithGivenDoubleNegation`. +#! Optionally, 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: ( a, s ) \mapsto \mathtt{MorphismFromDoubleNegationWithGivenDoubleNegation}(a, s)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismFromDoubleNegationWithGivenDoubleNegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismFromDoubleNegationWithGivenDoubleNegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismFromDoubleNegationWithGivenDoubleNegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismFromDoubleNegationWithGivenDoubleNegation", - [ 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 `MorphismToDoubleConegation`. +#! Optionally, 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: ( a ) \mapsto \mathtt{MorphismToDoubleConegation}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismToDoubleConegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismToDoubleConegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismToDoubleConegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismToDoubleConegation", - [ 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 `MorphismToDoubleConegationWithGivenDoubleConegation`. +#! Optionally, 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: ( a, r ) \mapsto \mathtt{MorphismToDoubleConegationWithGivenDoubleConegation}(a, r)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismToDoubleConegationWithGivenDoubleConegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismToDoubleConegationWithGivenDoubleConegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismToDoubleConegationWithGivenDoubleConegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismToDoubleConegationWithGivenDoubleConegation", - [ IsCapCategory, IsList ] ); diff --git a/Locales/gap/CoHeytingAlgebra.autogen.gd b/Locales/gap/CoHeytingAlgebra.autogen.gd index 54dfb153d..274134667 100644 --- a/Locales/gap/CoHeytingAlgebra.autogen.gd +++ b/Locales/gap/CoHeytingAlgebra.autogen.gd @@ -3,103 +3,103 @@ # # 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 Co-Heyting algebras #! @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 `ConegationOnMorphisms`. +#! Optionally, 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{ConegationOnMorphisms}(alpha)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddConegationOnMorphisms", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddConegationOnMorphisms", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddConegationOnMorphisms", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddConegationOnMorphisms", - [ 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 `ConegationOnMorphismsWithGivenConegations`. +#! Optionally, 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{ConegationOnMorphismsWithGivenConegations}(s, alpha, r)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddConegationOnMorphismsWithGivenConegations", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddConegationOnMorphismsWithGivenConegations", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddConegationOnMorphismsWithGivenConegations", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddConegationOnMorphismsWithGivenConegations", - [ 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 `ConegationOnObjects`. +#! Optionally, 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{ConegationOnObjects}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddConegationOnObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddConegationOnObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddConegationOnObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddConegationOnObjects", - [ 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 `MorphismFromDoubleConegation`. +#! Optionally, 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: ( a ) \mapsto \mathtt{MorphismFromDoubleConegation}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismFromDoubleConegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismFromDoubleConegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismFromDoubleConegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismFromDoubleConegation", - [ 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 `MorphismFromDoubleConegationWithGivenDoubleConegation`. +#! Optionally, 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: ( a, s ) \mapsto \mathtt{MorphismFromDoubleConegationWithGivenDoubleConegation}(a, s)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismFromDoubleConegationWithGivenDoubleConegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismFromDoubleConegationWithGivenDoubleConegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismFromDoubleConegationWithGivenDoubleConegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismFromDoubleConegationWithGivenDoubleConegation", - [ IsCapCategory, IsList ] ); diff --git a/Locales/gap/HeytingAlgebra.autogen.gd b/Locales/gap/HeytingAlgebra.autogen.gd index c0540a9c5..0788144da 100644 --- a/Locales/gap/HeytingAlgebra.autogen.gd +++ b/Locales/gap/HeytingAlgebra.autogen.gd @@ -3,103 +3,103 @@ # # 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 Heyting algebras #! @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 `MorphismToDoubleNegation`. +#! Optionally, 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: ( a ) \mapsto \mathtt{MorphismToDoubleNegation}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismToDoubleNegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismToDoubleNegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismToDoubleNegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismToDoubleNegation", - [ 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 `MorphismToDoubleNegationWithGivenDoubleNegation`. +#! Optionally, 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: ( a, r ) \mapsto \mathtt{MorphismToDoubleNegationWithGivenDoubleNegation}(a, r)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismToDoubleNegationWithGivenDoubleNegation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismToDoubleNegationWithGivenDoubleNegation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismToDoubleNegationWithGivenDoubleNegation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismToDoubleNegationWithGivenDoubleNegation", - [ 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 `NegationOnMorphisms`. +#! Optionally, 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{NegationOnMorphisms}(alpha)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddNegationOnMorphisms", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddNegationOnMorphisms", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddNegationOnMorphisms", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddNegationOnMorphisms", - [ 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 `NegationOnMorphismsWithGivenNegations`. +#! Optionally, 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{NegationOnMorphismsWithGivenNegations}(s, alpha, r)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddNegationOnMorphismsWithGivenNegations", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddNegationOnMorphismsWithGivenNegations", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddNegationOnMorphismsWithGivenNegations", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddNegationOnMorphismsWithGivenNegations", - [ 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 `NegationOnObjects`. +#! Optionally, 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{NegationOnObjects}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddNegationOnObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddNegationOnObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddNegationOnObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddNegationOnObjects", - [ IsCapCategory, IsList ] ); diff --git a/Locales/gap/Poset.autogen.gd b/Locales/gap/Poset.autogen.gd index d770d8b3a..04c3b27fa 100644 --- a/Locales/gap/Poset.autogen.gd +++ b/Locales/gap/Poset.autogen.gd @@ -3,27 +3,27 @@ # # 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 Posets (partially ordered sets) #! @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 `IsEqualForObjectsIfIsHomSetInhabited`. +#! Optionally, 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{IsEqualForObjectsIfIsHomSetInhabited}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsEqualForObjectsIfIsHomSetInhabited", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsEqualForObjectsIfIsHomSetInhabited", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsEqualForObjectsIfIsHomSetInhabited", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsEqualForObjectsIfIsHomSetInhabited", - [ IsCapCategory, IsList ] ); diff --git a/Locales/gap/Proset.autogen.gd b/Locales/gap/Proset.autogen.gd index cdedc2877..4411edcbb 100644 --- a/Locales/gap/Proset.autogen.gd +++ b/Locales/gap/Proset.autogen.gd @@ -3,46 +3,46 @@ # # 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 Prosets (preordered sets) #! @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 `AreIsomorphicForObjectsIfIsHomSetInhabited`. +#! Optionally, 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{AreIsomorphicForObjectsIfIsHomSetInhabited}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddAreIsomorphicForObjectsIfIsHomSetInhabited", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddAreIsomorphicForObjectsIfIsHomSetInhabited", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddAreIsomorphicForObjectsIfIsHomSetInhabited", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddAreIsomorphicForObjectsIfIsHomSetInhabited", - [ 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 `UniqueMorphism`. +#! Optionally, 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: ( A, B ) \mapsto \mathtt{UniqueMorphism}(A, B)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniqueMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniqueMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniqueMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniqueMorphism", - [ IsCapCategory, IsList ] ); diff --git a/ToolsForCategoricalTowers/PackageInfo.g b/ToolsForCategoricalTowers/PackageInfo.g index 1a6ddfe4a..44f951462 100644 --- a/ToolsForCategoricalTowers/PackageInfo.g +++ b/ToolsForCategoricalTowers/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "ToolsForCategoricalTowers", Subtitle := "Tools for CategoricalTowers", -Version := "2024.09-02", +Version := "2024.09-03", Date := ~.Version{[ 1 .. 10 ]}, 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)( ), @@ -71,7 +71,7 @@ PackageDoc := rec( Dependencies := rec( GAP := ">= 4.13.0", NeededOtherPackages := [ - [ "CAP", ">= 2024.09-05" ], + [ "CAP", ">= 2024.09-08" ], [ "MonoidalCategories", ">= 2024.06-01" ], [ "CartesianCategories", ">= 2024.06-01" ], [ "ToolsForHomalg", ">= 2021.11-01" ], diff --git a/ToolsForCategoricalTowers/gap/Tools.autogen.gd b/ToolsForCategoricalTowers/gap/Tools.autogen.gd index c9f334b53..029e0080e 100644 --- a/ToolsForCategoricalTowers/gap/Tools.autogen.gd +++ b/ToolsForCategoricalTowers/gap/Tools.autogen.gd @@ -3,597 +3,597 @@ # # 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 Futher CAP operations #! @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 `BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory`. +#! Optionally, 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{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2, arg3, arg4, arg5)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", - [ 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 `BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory`. +#! Optionally, 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{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", - [ 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 `BiasedRelativeWeakFiberProduct`. +#! Optionally, 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{BiasedRelativeWeakFiberProduct}(arg2, arg3, arg4)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddBiasedRelativeWeakFiberProduct", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddBiasedRelativeWeakFiberProduct", - [ 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 `Colimit`. +#! Optionally, 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: ( objects, decorated_morphisms ) \mapsto \mathtt{Colimit}(objects, decorated_morphisms)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddColimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddColimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddColimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddColimit", - [ 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 `EmbeddingOfSumOfImagesOfAllMorphisms`. +#! Optionally, 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: ( a, b ) \mapsto \mathtt{EmbeddingOfSumOfImagesOfAllMorphisms}(a, b)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfSumOfImagesOfAllMorphisms", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfSumOfImagesOfAllMorphisms", - [ 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 `InjectionOfCofactorOfColimit`. +#! Optionally, 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: ( objects, decorated_morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfColimit}(objects, decorated_morphisms, k)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddInjectionOfCofactorOfColimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddInjectionOfCofactorOfColimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddInjectionOfCofactorOfColimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddInjectionOfCofactorOfColimit", - [ 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 `InjectionOfCofactorOfColimitWithGivenColimit`. +#! Optionally, 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: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfColimitWithGivenColimit}(objects, decorated_morphisms, k, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddInjectionOfCofactorOfColimitWithGivenColimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddInjectionOfCofactorOfColimitWithGivenColimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddInjectionOfCofactorOfColimitWithGivenColimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddInjectionOfCofactorOfColimitWithGivenColimit", - [ 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 `IsWeakInitial`. +#! Optionally, 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{IsWeakInitial}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsWeakInitial", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsWeakInitial", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsWeakInitial", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsWeakInitial", - [ 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 `IsWeakTerminal`. +#! Optionally, 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{IsWeakTerminal}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsWeakTerminal", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsWeakTerminal", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsWeakTerminal", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsWeakTerminal", - [ 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 `Limit`. +#! Optionally, 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: ( objects, decorated_morphisms ) \mapsto \mathtt{Limit}(objects, decorated_morphisms)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLimit", - [ 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 `MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory`. +#! Optionally, 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{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory", - [ 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 `MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory`. +#! Optionally, 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{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory", - [ 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 `MorphismBetweenCoproducts`. +#! Optionally, 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: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenCoproducts}(source_diagram, pair, range_diagram)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismBetweenCoproducts", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismBetweenCoproducts", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismBetweenCoproducts", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismBetweenCoproducts", - [ 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 `MorphismBetweenCoproductsWithGivenCoproducts`. +#! Optionally, 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, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenCoproductsWithGivenCoproducts}(S, source_diagram, pair, range_diagram, T)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismBetweenCoproductsWithGivenCoproducts", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismBetweenCoproductsWithGivenCoproducts", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismBetweenCoproductsWithGivenCoproducts", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismBetweenCoproductsWithGivenCoproducts", - [ 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 `MorphismBetweenDirectProducts`. +#! Optionally, 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: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectProducts}(source_diagram, pair, range_diagram)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismBetweenDirectProducts", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismBetweenDirectProducts", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismBetweenDirectProducts", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismBetweenDirectProducts", - [ 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 `MorphismBetweenDirectProductsWithGivenDirectProducts`. +#! Optionally, 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, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectProductsWithGivenDirectProducts}(S, source_diagram, pair, range_diagram, T)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismBetweenDirectProductsWithGivenDirectProducts", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismBetweenDirectProductsWithGivenDirectProducts", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismBetweenDirectProductsWithGivenDirectProducts", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismBetweenDirectProductsWithGivenDirectProducts", - [ 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 `MorphismOntoSumOfImagesOfAllMorphisms`. +#! Optionally, 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: ( a, b ) \mapsto \mathtt{MorphismOntoSumOfImagesOfAllMorphisms}(a, b)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddMorphismOntoSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddMorphismOntoSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddMorphismOntoSumOfImagesOfAllMorphisms", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddMorphismOntoSumOfImagesOfAllMorphisms", - [ 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 `ProjectionInFactorOfLimit`. +#! Optionally, 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: ( objects, decorated_morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfLimit}(objects, decorated_morphisms, k)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionInFactorOfLimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionInFactorOfLimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionInFactorOfLimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionInFactorOfLimit", - [ 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 `ProjectionInFactorOfLimitWithGivenLimit`. +#! Optionally, 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: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfLimitWithGivenLimit}(objects, decorated_morphisms, k, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionInFactorOfLimitWithGivenLimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionInFactorOfLimitWithGivenLimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionInFactorOfLimitWithGivenLimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionInFactorOfLimitWithGivenLimit", - [ 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 `ProjectionOfBiasedRelativeWeakFiberProduct`. +#! Optionally, 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: ( a, b, c ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProduct}(a, b, c)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProduct", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProduct", - [ 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 `ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct`. +#! Optionally, 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: ( a, b, c, P ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", - [ 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 `RelativeLift`. +#! Optionally, 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: ( beta, alpha, nu ) \mapsto \mathtt{RelativeLift}(beta, alpha, nu)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeLift", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeLift", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeLift", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeLift", - [ 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 `SetOfMorphismsOfFiniteCategory`. +#! Optionally, 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: ( ) \mapsto \mathtt{SetOfMorphismsOfFiniteCategory}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSetOfMorphismsOfFiniteCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSetOfMorphismsOfFiniteCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSetOfMorphismsOfFiniteCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSetOfMorphismsOfFiniteCategory", - [ 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 `SetOfObjectsOfCategory`. +#! Optionally, 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: ( ) \mapsto \mathtt{SetOfObjectsOfCategory}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSetOfObjectsOfCategory", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSetOfObjectsOfCategory", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSetOfObjectsOfCategory", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSetOfObjectsOfCategory", - [ 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 `SumOfImagesOfAllMorphisms`. +#! Optionally, 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{SumOfImagesOfAllMorphisms}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSumOfImagesOfAllMorphisms", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSumOfImagesOfAllMorphisms", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSumOfImagesOfAllMorphisms", - [ 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 `UniversalMorphismFromColimit`. +#! Optionally, 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: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromColimit}(objects, decorated_morphisms, T, tau)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismFromColimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismFromColimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismFromColimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismFromColimit", - [ 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 `UniversalMorphismFromColimitWithGivenColimit`. +#! Optionally, 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: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromColimitWithGivenColimit}(objects, decorated_morphisms, T, tau, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismFromColimitWithGivenColimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismFromColimitWithGivenColimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismFromColimitWithGivenColimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismFromColimitWithGivenColimit", - [ 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 `UniversalMorphismIntoBiasedRelativeWeakFiberProduct`. +#! Optionally, 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: ( a, b, c, t ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProduct}(a, b, c, t)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct", - [ 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 `UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct`. +#! Optionally, 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: ( a, b, c, t, P ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, t, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct", - [ 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 `UniversalMorphismIntoLimit`. +#! Optionally, 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: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoLimit}(objects, decorated_morphisms, T, tau)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismIntoLimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismIntoLimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismIntoLimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismIntoLimit", - [ 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 `UniversalMorphismIntoLimitWithGivenLimit`. +#! Optionally, 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: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoLimitWithGivenLimit}(objects, decorated_morphisms, T, tau, P)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUniversalMorphismIntoLimitWithGivenLimit", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUniversalMorphismIntoLimitWithGivenLimit", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUniversalMorphismIntoLimitWithGivenLimit", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUniversalMorphismIntoLimitWithGivenLimit", - [ IsCapCategory, IsList ] ); diff --git a/Toposes/PackageInfo.g b/Toposes/PackageInfo.g index 0d151871c..d9de0b41f 100644 --- a/Toposes/PackageInfo.g +++ b/Toposes/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "Toposes", Subtitle := "Elementary toposes", -Version := "2024.09-01", +Version := "2024.09-02", Date := ~.Version{[ 1 .. 10 ]}, 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", @@ -113,7 +113,7 @@ Dependencies := rec( GAP := ">= 4.13.0", NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], - [ "CAP", ">= 2024.09-05" ], + [ "CAP", ">= 2024.09-08" ], [ "CartesianCategories", ">= 2024.06-01" ], ], SuggestedOtherPackages := [ diff --git a/Toposes/gap/Topos.autogen.gd b/Toposes/gap/Topos.autogen.gd index 2798121cf..70894717d 100644 --- a/Toposes/gap/Topos.autogen.gd +++ b/Toposes/gap/Topos.autogen.gd @@ -3,1509 +3,1509 @@ # # 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 Toposes #! @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 `CartesianSquareOfSubobjectClassifier`. +#! Optionally, 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: ( ) \mapsto \mathtt{CartesianSquareOfSubobjectClassifier}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddCartesianSquareOfSubobjectClassifier", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddCartesianSquareOfSubobjectClassifier", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddCartesianSquareOfSubobjectClassifier", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddCartesianSquareOfSubobjectClassifier", - [ 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 `ClassifyingMorphismOfSubobject`. +#! Optionally, 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{ClassifyingMorphismOfSubobject}(alpha)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddClassifyingMorphismOfSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddClassifyingMorphismOfSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddClassifyingMorphismOfSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddClassifyingMorphismOfSubobject", - [ 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 `ClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier`. +#! Optionally, 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, Omega ) \mapsto \mathtt{ClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier}(alpha, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddClassifyingMorphismOfSubobjectWithGivenSubobjectClassifier", - [ 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 `CoproductComplement`. +#! Optionally, 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: ( iota ) \mapsto \mathtt{CoproductComplement}(iota)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddCoproductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddCoproductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddCoproductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddCoproductComplement", - [ 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 `DirectProductComplement`. +#! Optionally, 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: ( pi ) \mapsto \mathtt{DirectProductComplement}(pi)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddDirectProductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddDirectProductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddDirectProductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddDirectProductComplement", - [ 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 `EmbeddingOfIntersectionSubobject`. +#! Optionally, 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: ( iota1, iota2 ) \mapsto \mathtt{EmbeddingOfIntersectionSubobject}(iota1, iota2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfIntersectionSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfIntersectionSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfIntersectionSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfIntersectionSubobject", - [ 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 `EmbeddingOfIntersectionSubobjectWithGivenIntersection`. +#! Optionally, 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: ( iota1, iota2, intersection ) \mapsto \mathtt{EmbeddingOfIntersectionSubobjectWithGivenIntersection}(iota1, iota2, intersection)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfIntersectionSubobjectWithGivenIntersection", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfIntersectionSubobjectWithGivenIntersection", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfIntersectionSubobjectWithGivenIntersection", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfIntersectionSubobjectWithGivenIntersection", - [ 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 `EmbeddingOfPseudoComplementSubobject`. +#! Optionally, 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: ( iota ) \mapsto \mathtt{EmbeddingOfPseudoComplementSubobject}(iota)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfPseudoComplementSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfPseudoComplementSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfPseudoComplementSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfPseudoComplementSubobject", - [ 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 `EmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement`. +#! Optionally, 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: ( iota, complement ) \mapsto \mathtt{EmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement}(iota, complement)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfPseudoComplementSubobjectWithGivenPseudoComplement", - [ 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 `EmbeddingOfRelativePseudoComplementSubobject`. +#! Optionally, 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: ( iota1, iota2 ) \mapsto \mathtt{EmbeddingOfRelativePseudoComplementSubobject}(iota1, iota2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobject", - [ 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 `EmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication`. +#! Optionally, 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: ( iota1, iota2, implication ) \mapsto \mathtt{EmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication}(iota1, iota2, implication)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfRelativePseudoComplementSubobjectWithGivenImplication", - [ 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 `EmbeddingOfUnionSubobject`. +#! Optionally, 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: ( iota1, iota2 ) \mapsto \mathtt{EmbeddingOfUnionSubobject}(iota1, iota2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfUnionSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfUnionSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfUnionSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfUnionSubobject", - [ 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 `EmbeddingOfUnionSubobjectWithGivenUnion`. +#! Optionally, 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: ( iota1, iota2, union ) \mapsto \mathtt{EmbeddingOfUnionSubobjectWithGivenUnion}(iota1, iota2, union)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddEmbeddingOfUnionSubobjectWithGivenUnion", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddEmbeddingOfUnionSubobjectWithGivenUnion", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddEmbeddingOfUnionSubobjectWithGivenUnion", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddEmbeddingOfUnionSubobjectWithGivenUnion", - [ 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 `ExactCoverWithGlobalElements`. +#! Optionally, 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{ExactCoverWithGlobalElements}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddExactCoverWithGlobalElements", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddExactCoverWithGlobalElements", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddExactCoverWithGlobalElements", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddExactCoverWithGlobalElements", - [ 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 `HasPushoutComplement`. +#! Optionally, 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{HasPushoutComplement}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddHasPushoutComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddHasPushoutComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddHasPushoutComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddHasPushoutComplement", - [ 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 `IndexOfNonliftableMorphismFromDistinguishedObject`. +#! Optionally, 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: ( iota ) \mapsto \mathtt{IndexOfNonliftableMorphismFromDistinguishedObject}(iota)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIndexOfNonliftableMorphismFromDistinguishedObject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIndexOfNonliftableMorphismFromDistinguishedObject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIndexOfNonliftableMorphismFromDistinguishedObject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIndexOfNonliftableMorphismFromDistinguishedObject", - [ 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 `InjectionOfCoproductComplement`. +#! Optionally, 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: ( iota ) \mapsto \mathtt{InjectionOfCoproductComplement}(iota)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddInjectionOfCoproductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddInjectionOfCoproductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddInjectionOfCoproductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddInjectionOfCoproductComplement", - [ 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 `InjectionOfCoproductComplementWithGivenCoproductComplement`. +#! Optionally, 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: ( iota, complement ) \mapsto \mathtt{InjectionOfCoproductComplementWithGivenCoproductComplement}(iota, complement)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddInjectionOfCoproductComplementWithGivenCoproductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddInjectionOfCoproductComplementWithGivenCoproductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddInjectionOfCoproductComplementWithGivenCoproductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddInjectionOfCoproductComplementWithGivenCoproductComplement", - [ 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 `IntersectionSubobject`. +#! Optionally, 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{IntersectionSubobject}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIntersectionSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIntersectionSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIntersectionSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIntersectionSubobject", - [ 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 `IsomorphismOntoCartesianSquareOfPowerObject`. +#! Optionally, 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: ( a ) \mapsto \mathtt{IsomorphismOntoCartesianSquareOfPowerObject}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObject", - [ 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 `IsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects`. +#! Optionally, 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: ( ExpaOmega2, a, PaxPa ) \mapsto \mathtt{IsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects}(ExpaOmega2, a, PaxPa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddIsomorphismOntoCartesianSquareOfPowerObjectWithGivenObjects", - [ 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 `LawvereTierneyEmbeddingsOfSubobjectClassifiers`. +#! Optionally, 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: ( ) \mapsto \mathtt{LawvereTierneyEmbeddingsOfSubobjectClassifiers}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLawvereTierneyEmbeddingsOfSubobjectClassifiers", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLawvereTierneyEmbeddingsOfSubobjectClassifiers", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLawvereTierneyEmbeddingsOfSubobjectClassifiers", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLawvereTierneyEmbeddingsOfSubobjectClassifiers", - [ 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 `LawvereTierneyLocalModalityOperators`. +#! Optionally, 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: ( ) \mapsto \mathtt{LawvereTierneyLocalModalityOperators}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLawvereTierneyLocalModalityOperators", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLawvereTierneyLocalModalityOperators", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLawvereTierneyLocalModalityOperators", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLawvereTierneyLocalModalityOperators", - [ 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 `LawvereTierneySubobjects`. +#! Optionally, 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: ( ) \mapsto \mathtt{LawvereTierneySubobjects}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLawvereTierneySubobjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLawvereTierneySubobjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLawvereTierneySubobjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLawvereTierneySubobjects", - [ 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 `LeftFiberMorphism`. +#! Optionally, 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: ( b, c ) \mapsto \mathtt{LeftFiberMorphism}(b, c)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLeftFiberMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLeftFiberMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLeftFiberMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLeftFiberMorphism", - [ 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 `LeftFiberMorphismWithGivenObjects`. +#! Optionally, 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: ( Pbxc_b, b, c, Pc ) \mapsto \mathtt{LeftFiberMorphismWithGivenObjects}(Pbxc_b, b, c, Pc)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLeftFiberMorphismWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLeftFiberMorphismWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLeftFiberMorphismWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLeftFiberMorphismWithGivenObjects", - [ 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 `ListOfSubobjects`. +#! Optionally, 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{ListOfSubobjects}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddListOfSubobjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddListOfSubobjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddListOfSubobjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddListOfSubobjects", - [ 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 `LowerSegmentOfRelation`. +#! Optionally, 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: ( a, b, mu ) \mapsto \mathtt{LowerSegmentOfRelation}(a, b, mu)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLowerSegmentOfRelation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLowerSegmentOfRelation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLowerSegmentOfRelation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLowerSegmentOfRelation", - [ 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 `LowerSegmentOfRelationWithGivenRange`. +#! Optionally, 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: ( a, b, mu, Pa ) \mapsto \mathtt{LowerSegmentOfRelationWithGivenRange}(a, b, mu, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddLowerSegmentOfRelationWithGivenRange", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddLowerSegmentOfRelationWithGivenRange", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddLowerSegmentOfRelationWithGivenRange", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddLowerSegmentOfRelationWithGivenRange", - [ 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 `NonliftableMorphismFromDistinguishedObject`. +#! Optionally, 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: ( iota ) \mapsto \mathtt{NonliftableMorphismFromDistinguishedObject}(iota)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddNonliftableMorphismFromDistinguishedObject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddNonliftableMorphismFromDistinguishedObject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddNonliftableMorphismFromDistinguishedObject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddNonliftableMorphismFromDistinguishedObject", - [ 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 `PLeftTransposeMorphism`. +#! Optionally, 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: ( a, b, f ) \mapsto \mathtt{PLeftTransposeMorphism}(a, b, f)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPLeftTransposeMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPLeftTransposeMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPLeftTransposeMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPLeftTransposeMorphism", - [ 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 `PLeftTransposeMorphismWithGivenRange`. +#! Optionally, 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: ( a, b, f, Pb ) \mapsto \mathtt{PLeftTransposeMorphismWithGivenRange}(a, b, f, Pb)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPLeftTransposeMorphismWithGivenRange", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPLeftTransposeMorphismWithGivenRange", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPLeftTransposeMorphismWithGivenRange", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPLeftTransposeMorphismWithGivenRange", - [ 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 `PRightTransposeMorphism`. +#! Optionally, 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: ( a, b, f ) \mapsto \mathtt{PRightTransposeMorphism}(a, b, f)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPRightTransposeMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPRightTransposeMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPRightTransposeMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPRightTransposeMorphism", - [ 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 `PRightTransposeMorphismWithGivenRange`. +#! Optionally, 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: ( a, b, f, Pa ) \mapsto \mathtt{PRightTransposeMorphismWithGivenRange}(a, b, f, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPRightTransposeMorphismWithGivenRange", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPRightTransposeMorphismWithGivenRange", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPRightTransposeMorphismWithGivenRange", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPRightTransposeMorphismWithGivenRange", - [ 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 `PowerObject`. +#! Optionally, 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{PowerObject}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObject", - [ 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 `PowerObjectFunctorial`. +#! Optionally, 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: ( f ) \mapsto \mathtt{PowerObjectFunctorial}(f)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectFunctorial", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectFunctorial", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectFunctorial", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectFunctorial", - [ 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 `PowerObjectFunctorialWithGivenPowerObjects`. +#! Optionally, 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: ( Pb, f, Pa ) \mapsto \mathtt{PowerObjectFunctorialWithGivenPowerObjects}(Pb, f, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectFunctorialWithGivenPowerObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectFunctorialWithGivenPowerObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectFunctorialWithGivenPowerObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectFunctorialWithGivenPowerObjects", - [ 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 `PowerObjectLeftEvaluationMorphism`. +#! Optionally, 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: ( a ) \mapsto \mathtt{PowerObjectLeftEvaluationMorphism}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectLeftEvaluationMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectLeftEvaluationMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectLeftEvaluationMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectLeftEvaluationMorphism", - [ 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 `PowerObjectLeftEvaluationMorphismWithGivenObjects`. +#! Optionally, 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: ( Pa_xa, a, Omega ) \mapsto \mathtt{PowerObjectLeftEvaluationMorphismWithGivenObjects}(Pa_xa, a, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectLeftEvaluationMorphismWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectLeftEvaluationMorphismWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectLeftEvaluationMorphismWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectLeftEvaluationMorphismWithGivenObjects", - [ 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 `PowerObjectRightEvaluationMorphism`. +#! Optionally, 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: ( a ) \mapsto \mathtt{PowerObjectRightEvaluationMorphism}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectRightEvaluationMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectRightEvaluationMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectRightEvaluationMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectRightEvaluationMorphism", - [ 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 `PowerObjectRightEvaluationMorphismWithGivenObjects`. +#! Optionally, 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: ( axPa, a, Omega ) \mapsto \mathtt{PowerObjectRightEvaluationMorphismWithGivenObjects}(axPa, a, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPowerObjectRightEvaluationMorphismWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPowerObjectRightEvaluationMorphismWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPowerObjectRightEvaluationMorphismWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPowerObjectRightEvaluationMorphismWithGivenObjects", - [ 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 `ProjectionInDirectProductComplement`. +#! Optionally, 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: ( pi ) \mapsto \mathtt{ProjectionInDirectProductComplement}(pi)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionInDirectProductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionInDirectProductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionInDirectProductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionInDirectProductComplement", - [ 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 `ProjectionInDirectProductComplementWithGivenDirectProductComplement`. +#! Optionally, 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: ( pi, complement ) \mapsto \mathtt{ProjectionInDirectProductComplementWithGivenDirectProductComplement}(pi, complement)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddProjectionInDirectProductComplementWithGivenDirectProductComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddProjectionInDirectProductComplementWithGivenDirectProductComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddProjectionInDirectProductComplementWithGivenDirectProductComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddProjectionInDirectProductComplementWithGivenDirectProductComplement", - [ 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 `PseudoComplementSubobject`. +#! Optionally, 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{PseudoComplementSubobject}(arg2)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPseudoComplementSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPseudoComplementSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPseudoComplementSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPseudoComplementSubobject", - [ 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 `PushoutComplement`. +#! Optionally, 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: ( l, m ) \mapsto \mathtt{PushoutComplement}(l, m)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddPushoutComplement", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddPushoutComplement", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddPushoutComplement", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddPushoutComplement", - [ 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 `RelativePseudoComplementSubobject`. +#! Optionally, 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{RelativePseudoComplementSubobject}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativePseudoComplementSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativePseudoComplementSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativePseudoComplementSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativePseudoComplementSubobject", - [ 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 `RelativeTruthMorphismOfAnd`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfAnd}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfAnd", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfAnd", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfAnd", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfAnd", - [ 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 `RelativeTruthMorphismOfAndWithGivenObjects`. +#! Optionally, 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: ( PaxPa, a, Pa ) \mapsto \mathtt{RelativeTruthMorphismOfAndWithGivenObjects}(PaxPa, a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfAndWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfAndWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfAndWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfAndWithGivenObjects", - [ 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 `RelativeTruthMorphismOfFalse`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfFalse}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfFalse", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfFalse", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfFalse", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfFalse", - [ 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 `RelativeTruthMorphismOfFalseWithGivenObjects`. +#! Optionally, 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: ( T, a, Pa ) \mapsto \mathtt{RelativeTruthMorphismOfFalseWithGivenObjects}(T, a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfFalseWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfFalseWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfFalseWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfFalseWithGivenObjects", - [ 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 `RelativeTruthMorphismOfImplies`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfImplies}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfImplies", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfImplies", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfImplies", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfImplies", - [ 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 `RelativeTruthMorphismOfImpliesWithGivenObjects`. +#! Optionally, 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: ( PaxPa, a, Pa ) \mapsto \mathtt{RelativeTruthMorphismOfImpliesWithGivenObjects}(PaxPa, a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfImpliesWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfImpliesWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfImpliesWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfImpliesWithGivenObjects", - [ 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 `RelativeTruthMorphismOfNot`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfNot}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfNot", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfNot", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfNot", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfNot", - [ 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 `RelativeTruthMorphismOfNotWithGivenObjects`. +#! Optionally, 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: ( Pa, a, Pa1 ) \mapsto \mathtt{RelativeTruthMorphismOfNotWithGivenObjects}(Pa, a, Pa1)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfNotWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfNotWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfNotWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfNotWithGivenObjects", - [ 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 `RelativeTruthMorphismOfOr`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfOr}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfOr", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfOr", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfOr", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfOr", - [ 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 `RelativeTruthMorphismOfOrWithGivenObjects`. +#! Optionally, 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: ( PaxPa, a, Pa ) \mapsto \mathtt{RelativeTruthMorphismOfOrWithGivenObjects}(PaxPa, a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfOrWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfOrWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfOrWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfOrWithGivenObjects", - [ 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 `RelativeTruthMorphismOfTrue`. +#! Optionally, 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: ( a ) \mapsto \mathtt{RelativeTruthMorphismOfTrue}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfTrue", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfTrue", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfTrue", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfTrue", - [ 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 `RelativeTruthMorphismOfTrueWithGivenObjects`. +#! Optionally, 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: ( T, a, Pa ) \mapsto \mathtt{RelativeTruthMorphismOfTrueWithGivenObjects}(T, a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRelativeTruthMorphismOfTrueWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRelativeTruthMorphismOfTrueWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRelativeTruthMorphismOfTrueWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRelativeTruthMorphismOfTrueWithGivenObjects", - [ 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 `RightFiberMorphism`. +#! Optionally, 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: ( b, c ) \mapsto \mathtt{RightFiberMorphism}(b, c)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRightFiberMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRightFiberMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRightFiberMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRightFiberMorphism", - [ 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 `RightFiberMorphismWithGivenObjects`. +#! Optionally, 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: ( cxPbxc, b, c, Pb ) \mapsto \mathtt{RightFiberMorphismWithGivenObjects}(cxPbxc, b, c, Pb)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddRightFiberMorphismWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddRightFiberMorphismWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddRightFiberMorphismWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddRightFiberMorphismWithGivenObjects", - [ 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 `SingletonMorphism`. +#! Optionally, 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: ( a ) \mapsto \mathtt{SingletonMorphism}(a)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSingletonMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSingletonMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSingletonMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSingletonMorphism", - [ 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 `SingletonMorphismWithGivenPowerObject`. +#! Optionally, 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: ( a, Pa ) \mapsto \mathtt{SingletonMorphismWithGivenPowerObject}(a, Pa)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSingletonMorphismWithGivenPowerObject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSingletonMorphismWithGivenPowerObject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSingletonMorphismWithGivenPowerObject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSingletonMorphismWithGivenPowerObject", - [ 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 `SubobjectClassifier`. +#! Optionally, 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: ( ) \mapsto \mathtt{SubobjectClassifier}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSubobjectClassifier", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSubobjectClassifier", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSubobjectClassifier", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSubobjectClassifier", - [ 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 `SubobjectOfClassifyingMorphism`. +#! Optionally, 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{SubobjectOfClassifyingMorphism}(alpha)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddSubobjectOfClassifyingMorphism", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddSubobjectOfClassifyingMorphism", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddSubobjectOfClassifyingMorphism", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddSubobjectOfClassifyingMorphism", - [ 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 `TruthMorphismOfAnd`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfAnd}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfAnd", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfAnd", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfAnd", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfAnd", - [ 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 `TruthMorphismOfAndWithGivenObjects`. +#! Optionally, 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: ( Omega2, Omega ) \mapsto \mathtt{TruthMorphismOfAndWithGivenObjects}(Omega2, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfAndWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfAndWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfAndWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfAndWithGivenObjects", - [ 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 `TruthMorphismOfFalse`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfFalse}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfFalse", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfFalse", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfFalse", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfFalse", - [ 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 `TruthMorphismOfFalseWithGivenObjects`. +#! Optionally, 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: ( T, Omega ) \mapsto \mathtt{TruthMorphismOfFalseWithGivenObjects}(T, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfFalseWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfFalseWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfFalseWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfFalseWithGivenObjects", - [ 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 `TruthMorphismOfImplies`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfImplies}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfImplies", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfImplies", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfImplies", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfImplies", - [ 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 `TruthMorphismOfImpliesWithGivenObjects`. +#! Optionally, 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: ( Omega2, Omega ) \mapsto \mathtt{TruthMorphismOfImpliesWithGivenObjects}(Omega2, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfImpliesWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfImpliesWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfImpliesWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfImpliesWithGivenObjects", - [ 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 `TruthMorphismOfNot`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfNot}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfNot", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfNot", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfNot", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfNot", - [ 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 `TruthMorphismOfNotWithGivenObjects`. +#! Optionally, 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: ( Omega, Omega1 ) \mapsto \mathtt{TruthMorphismOfNotWithGivenObjects}(Omega, Omega1)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfNotWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfNotWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfNotWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfNotWithGivenObjects", - [ 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 `TruthMorphismOfOr`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfOr}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfOr", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfOr", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfOr", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfOr", - [ 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 `TruthMorphismOfOrWithGivenObjects`. +#! Optionally, 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: ( Omega2, Omega ) \mapsto \mathtt{TruthMorphismOfOrWithGivenObjects}(Omega2, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfOrWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfOrWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfOrWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfOrWithGivenObjects", - [ 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 `TruthMorphismOfTrue`. +#! Optionally, 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: ( ) \mapsto \mathtt{TruthMorphismOfTrue}()$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfTrue", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfTrue", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfTrue", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfTrue", - [ 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 `TruthMorphismOfTrueWithGivenObjects`. +#! Optionally, 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: ( T, Omega ) \mapsto \mathtt{TruthMorphismOfTrueWithGivenObjects}(T, Omega)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddTruthMorphismOfTrueWithGivenObjects", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddTruthMorphismOfTrueWithGivenObjects", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddTruthMorphismOfTrueWithGivenObjects", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddTruthMorphismOfTrueWithGivenObjects", - [ 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 `UnionSubobject`. +#! Optionally, 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{UnionSubobject}(arg2, arg3)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUnionSubobject", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUnionSubobject", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUnionSubobject", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUnionSubobject", - [ 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 `UpperSegmentOfRelation`. +#! Optionally, 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: ( a, b, mu ) \mapsto \mathtt{UpperSegmentOfRelation}(a, b, mu)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUpperSegmentOfRelation", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUpperSegmentOfRelation", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUpperSegmentOfRelation", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUpperSegmentOfRelation", - [ 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 `UpperSegmentOfRelationWithGivenRange`. +#! Optionally, 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: ( a, b, mu, Pb ) \mapsto \mathtt{UpperSegmentOfRelationWithGivenRange}(a, b, mu, Pb)$. #! @Returns nothing #! @Arguments C, F DeclareOperation( "AddUpperSegmentOfRelationWithGivenRange", [ IsCapCategory, IsFunction ] ); +#! @Arguments C, F, weight DeclareOperation( "AddUpperSegmentOfRelationWithGivenRange", [ IsCapCategory, IsFunction, IsInt ] ); +#! @EndGroup -DeclareOperation( "AddUpperSegmentOfRelationWithGivenRange", - [ IsCapCategory, IsList, IsInt ] ); - -DeclareOperation( "AddUpperSegmentOfRelationWithGivenRange", - [ IsCapCategory, IsList ] );