diff --git a/StableCategories/PackageInfo.g b/StableCategories/PackageInfo.g index 1afc463a..575cf7cf 100644 --- a/StableCategories/PackageInfo.g +++ b/StableCategories/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "StableCategories", Subtitle := "Stable categories of additive categories", -Version := "2023.03-01", +Version := "2024.09-01", 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", @@ -70,7 +70,7 @@ PackageDoc := rec( Dependencies := rec( GAP := ">= 4.12.1", - NeededOtherPackages := [ [ "CAP", ">= 2022.10-09" ], + NeededOtherPackages := [ [ "CAP", ">= 2024.09-12" ], [ "GAPDoc", ">= 1.5" ], [ "TriangulatedCategories", ">= 2021.11-01" ], [ "QuotientCategories", ">= 2020.07.05" ], diff --git a/StableCategories/gap/FrobeniusCategories.gi b/StableCategories/gap/FrobeniusCategories.gi index efcd83d3..554d1b9d 100644 --- a/StableCategories/gap/FrobeniusCategories.gi +++ b/StableCategories/gap/FrobeniusCategories.gi @@ -238,6 +238,16 @@ return_type := "morphism" ) CAP_INTERNAL_ENHANCE_NAME_RECORD( FROBENIUS_CATEGORIES_METHOD_NAME_RECORD ); +CAP_INTERNAL_GENERATE_DECLARATIONS_AND_INSTALLATIONS_FROM_METHOD_NAME_RECORD( + FROBENIUS_CATEGORIES_METHOD_NAME_RECORD, + "StableCategories", + "FrobeniusCategories", + "operations for Frobenius categories", + "Add-methods" +); + +CAP_INTERNAL_REGISTER_METHOD_NAME_RECORD_OF_PACKAGE( FROBENIUS_CATEGORIES_METHOD_NAME_RECORD, "StableCategories" ); + CAP_INTERNAL_INSTALL_ADDS_FROM_RECORD( FROBENIUS_CATEGORIES_METHOD_NAME_RECORD ); ######################################## diff --git a/StableCategories/gap/StableCategories.gi b/StableCategories/gap/StableCategories.gi index 1613e4ac..6a44dfb6 100644 --- a/StableCategories/gap/StableCategories.gi +++ b/StableCategories/gap/StableCategories.gi @@ -127,6 +127,16 @@ WitnessForBeingColiftableAlongMorphismToColiftingObject := rec( CAP_INTERNAL_ENHANCE_NAME_RECORD( STABLE_CATEGORIES_METHOD_NAME_RECORD ); +CAP_INTERNAL_GENERATE_DECLARATIONS_AND_INSTALLATIONS_FROM_METHOD_NAME_RECORD( + STABLE_CATEGORIES_METHOD_NAME_RECORD, + "StableCategories", + "StableCategories", + "operations for stable categories", + "Add-methods" +); + +CAP_INTERNAL_REGISTER_METHOD_NAME_RECORD_OF_PACKAGE( STABLE_CATEGORIES_METHOD_NAME_RECORD, "StableCategories" ); + CAP_INTERNAL_INSTALL_ADDS_FROM_RECORD( STABLE_CATEGORIES_METHOD_NAME_RECORD ); ######################## diff --git a/TriangulatedCategories/PackageInfo.g b/TriangulatedCategories/PackageInfo.g index 3727ffa1..13d26f06 100644 --- a/TriangulatedCategories/PackageInfo.g +++ b/TriangulatedCategories/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "TriangulatedCategories", Subtitle := "Framework for triangulated categories", -Version := "2024.09-02", +Version := "2024.09-03", 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", @@ -70,7 +70,7 @@ PackageDoc := rec( Dependencies := rec( GAP := ">= 4.12.1", - NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], [ "CAP", ">= 2022.10-09" ] ], + NeededOtherPackages := [ [ "GAPDoc", ">= 1.5" ], [ "CAP", ">= 2024.09-12" ] ], SuggestedOtherPackages := [ ], ExternalConditions := [ ], ), diff --git a/TriangulatedCategories/gap/MethodRecord.gi b/TriangulatedCategories/gap/MethodRecord.gi index 9fdc2a40..2cc91a1b 100644 --- a/TriangulatedCategories/gap/MethodRecord.gi +++ b/TriangulatedCategories/gap/MethodRecord.gi @@ -263,10 +263,10 @@ InverseShiftFactoringIsomorphismWithGivenObjects := rec( CAP_INTERNAL_ENHANCE_NAME_RECORD( TRIANGULATED_CATEGORIES_METHOD_NAME_RECORD ); -CAP_INTERNAL_GENERATE_DOCUMENTATION_FROM_METHOD_NAME_RECORD( +CAP_INTERNAL_GENERATE_DECLARATIONS_AND_INSTALLATIONS_FROM_METHOD_NAME_RECORD( TRIANGULATED_CATEGORIES_METHOD_NAME_RECORD, "TriangulatedCategories", - "MethodRecord.autogen.gd", + "MethodRecord", "operations for triangulated categories", "Add-methods" ); diff --git a/TriangulatedCategories/gap/MethodRecord.autogen.gd b/TriangulatedCategories/gap/MethodRecordDeclarations.autogen.gd similarity index 100% rename from TriangulatedCategories/gap/MethodRecord.autogen.gd rename to TriangulatedCategories/gap/MethodRecordDeclarations.autogen.gd diff --git a/TriangulatedCategories/gap/MethodRecordInstallations.autogen.gi b/TriangulatedCategories/gap/MethodRecordInstallations.autogen.gi new file mode 100644 index 00000000..72fb1983 --- /dev/null +++ b/TriangulatedCategories/gap/MethodRecordInstallations.autogen.gi @@ -0,0 +1,878 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# TriangulatedCategories: Framework for triangulated categories +# +# Implementations +# +# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi + +## CounitOfShiftAdjunctionWithGivenObject +InstallMethod( AddCounitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "CounitOfShiftAdjunctionWithGivenObject", category, func, -1 ); + +end ); + +InstallMethod( AddCounitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "CounitOfShiftAdjunctionWithGivenObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## DomainMorphismByOctahedralAxiomWithGivenObjects +InstallMethod( AddDomainMorphismByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "DomainMorphismByOctahedralAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddDomainMorphismByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "DomainMorphismByOctahedralAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseOfCounitOfShiftAdjunctionWithGivenObject +InstallMethod( AddInverseOfCounitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseOfCounitOfShiftAdjunctionWithGivenObject", category, func, -1 ); + +end ); + +InstallMethod( AddInverseOfCounitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseOfCounitOfShiftAdjunctionWithGivenObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseOfUnitOfShiftAdjunctionWithGivenObject +InstallMethod( AddInverseOfUnitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseOfUnitOfShiftAdjunctionWithGivenObject", category, func, -1 ); + +end ); + +InstallMethod( AddInverseOfUnitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseOfUnitOfShiftAdjunctionWithGivenObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseShiftExpandingIsomorphismWithGivenObjects +InstallMethod( AddInverseShiftExpandingIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseShiftExpandingIsomorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddInverseShiftExpandingIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseShiftExpandingIsomorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseShiftFactoringIsomorphismWithGivenObjects +InstallMethod( AddInverseShiftFactoringIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseShiftFactoringIsomorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddInverseShiftFactoringIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseShiftFactoringIsomorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseShiftOfMorphismWithGivenObjects +InstallMethod( AddInverseShiftOfMorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseShiftOfMorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddInverseShiftOfMorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseShiftOfMorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## InverseShiftOfObject +InstallMethod( AddInverseShiftOfObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "InverseShiftOfObject", category, func, -1 ); + +end ); + +InstallMethod( AddInverseShiftOfObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "InverseShiftOfObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## IsExactTriangle +InstallMethod( AddIsExactTriangle, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "IsExactTriangle", category, func, -1 ); + +end ); + +InstallMethod( AddIsExactTriangle, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "IsExactTriangle", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismBetweenStandardConeObjectsWithGivenObjects +InstallMethod( AddMorphismBetweenStandardConeObjectsWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismBetweenStandardConeObjectsWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismBetweenStandardConeObjectsWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismBetweenStandardConeObjectsWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismFromConeObjectByOctahedralAxiomWithGivenObjects +InstallMethod( AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismFromConeObjectByOctahedralAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismFromConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismFromConeObjectByOctahedralAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismFromStandardConeObject +InstallMethod( AddMorphismFromStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismFromStandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismFromStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismFromStandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismFromStandardConeObjectWithGivenObjects +InstallMethod( AddMorphismFromStandardConeObjectWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismFromStandardConeObjectWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismFromStandardConeObjectWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismFromStandardConeObjectWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( MorphismFromStandardConeObjectWithGivenObjects, + "MorphismFromStandardConeObjectWithGivenObjects by calling MorphismFromStandardConeObject with the WithGiven argument(s) dropped", + [ + [ MorphismFromStandardConeObject, 1 ], + ], + function( cat, cone_alpha, alpha, sh_source_alpha ) + + return MorphismFromStandardConeObject( cat, alpha ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( MorphismFromStandardConeObject, + "MorphismFromStandardConeObject by calling MorphismFromStandardConeObjectWithGivenObjects with the WithGiven object(s)", + [ + [ MorphismFromStandardConeObjectWithGivenObjects, 1 ], + [ StandardConeObject, 1 ], + [ ShiftOfObject, 1 ], + ], + function( cat, alpha ) + + return MorphismFromStandardConeObjectWithGivenObjects( cat, StandardConeObject( cat, alpha ), alpha, ShiftOfObject( cat, Source( alpha ) ) ); + +end : is_with_given_derivation := true ); + +## MorphismIntoConeObjectByOctahedralAxiomWithGivenObjects +InstallMethod( AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismIntoConeObjectByOctahedralAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismIntoConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismIntoConeObjectByOctahedralAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismIntoStandardConeObject +InstallMethod( AddMorphismIntoStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismIntoStandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismIntoStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismIntoStandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## MorphismIntoStandardConeObjectWithGivenStandardConeObject +InstallMethod( AddMorphismIntoStandardConeObjectWithGivenStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "MorphismIntoStandardConeObjectWithGivenStandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddMorphismIntoStandardConeObjectWithGivenStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "MorphismIntoStandardConeObjectWithGivenStandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +AddDerivationToCAP( MorphismIntoStandardConeObjectWithGivenStandardConeObject, + "MorphismIntoStandardConeObjectWithGivenStandardConeObject by calling MorphismIntoStandardConeObject with the WithGiven argument(s) dropped", + [ + [ MorphismIntoStandardConeObject, 1 ], + ], + function( cat, alpha, cone ) + + return MorphismIntoStandardConeObject( cat, alpha ); + +end : is_with_given_derivation := true ); + +AddDerivationToCAP( MorphismIntoStandardConeObject, + "MorphismIntoStandardConeObject by calling MorphismIntoStandardConeObjectWithGivenStandardConeObject with the WithGiven object(s)", + [ + [ MorphismIntoStandardConeObjectWithGivenStandardConeObject, 1 ], + [ StandardConeObject, 1 ], + ], + function( cat, alpha ) + + return MorphismIntoStandardConeObjectWithGivenStandardConeObject( cat, alpha, StandardConeObject( cat, alpha ) ); + +end : is_with_given_derivation := true ); + +## ShiftExpandingIsomorphismWithGivenObjects +InstallMethod( AddShiftExpandingIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftExpandingIsomorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddShiftExpandingIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftExpandingIsomorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftFactoringIsomorphismWithGivenObjects +InstallMethod( AddShiftFactoringIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftFactoringIsomorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddShiftFactoringIsomorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftFactoringIsomorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftOfMorphismByInteger +InstallMethod( AddShiftOfMorphismByInteger, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftOfMorphismByInteger", category, func, -1 ); + +end ); + +InstallMethod( AddShiftOfMorphismByInteger, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftOfMorphismByInteger", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftOfMorphismByIntegerWithGivenObjects +InstallMethod( AddShiftOfMorphismByIntegerWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftOfMorphismByIntegerWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddShiftOfMorphismByIntegerWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftOfMorphismByIntegerWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftOfMorphismWithGivenObjects +InstallMethod( AddShiftOfMorphismWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftOfMorphismWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddShiftOfMorphismWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftOfMorphismWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftOfObject +InstallMethod( AddShiftOfObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftOfObject", category, func, -1 ); + +end ); + +InstallMethod( AddShiftOfObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftOfObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## ShiftOfObjectByInteger +InstallMethod( AddShiftOfObjectByInteger, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "ShiftOfObjectByInteger", category, func, -1 ); + +end ); + +InstallMethod( AddShiftOfObjectByInteger, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "ShiftOfObjectByInteger", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## StandardConeObject +InstallMethod( AddStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "StandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "StandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## UnitOfShiftAdjunctionWithGivenObject +InstallMethod( AddUnitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "UnitOfShiftAdjunctionWithGivenObject", category, func, -1 ); + +end ); + +InstallMethod( AddUnitOfShiftAdjunctionWithGivenObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "UnitOfShiftAdjunctionWithGivenObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismFromStandardConeObject +InstallMethod( AddWitnessIsomorphismFromStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismFromStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByInverseRotationAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByOctahedralAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismFromStandardConeObjectByRotationAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismIntoStandardConeObject +InstallMethod( AddWitnessIsomorphismIntoStandardConeObject, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObject", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismIntoStandardConeObject, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByInverseRotationAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByOctahedralAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); + +## WitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction ], + + function( category, func ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects", category, func, -1 ); + +end ); + +InstallMethod( AddWitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects, + [ IsCapCategory, IsFunction, IsInt ], + + FunctionWithNamedArguments( + [ + [ "IsPrecompiledDerivation", false ], + ], + function( CAP_NAMED_ARGUMENTS, category, func, weight ) + + AddCapOperation( "WitnessIsomorphismIntoStandardConeObjectByRotationAxiomWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation ); + + end + ) +); diff --git a/TriangulatedCategories/init.g b/TriangulatedCategories/init.g index 5b659f70..f8b481ac 100644 --- a/TriangulatedCategories/init.g +++ b/TriangulatedCategories/init.g @@ -5,6 +5,6 @@ # ReadPackage( "TriangulatedCategories", "gap/MethodRecord.gd"); -ReadPackage( "TriangulatedCategories", "gap/MethodRecord.autogen.gd"); +ReadPackage( "TriangulatedCategories", "gap/MethodRecordDeclarations.autogen.gd"); ReadPackage( "TriangulatedCategories", "gap/CategoryOfTriangles.gd"); ReadPackage( "TriangulatedCategories", "gap/Functors.gd"); diff --git a/TriangulatedCategories/read.g b/TriangulatedCategories/read.g index 17b6b9d2..23fce2c9 100644 --- a/TriangulatedCategories/read.g +++ b/TriangulatedCategories/read.g @@ -4,6 +4,7 @@ # Reading the implementation part of the package. # ReadPackage( "TriangulatedCategories", "gap/MethodRecord.gi"); +ReadPackage( "TriangulatedCategories", "gap/MethodRecordInstallations.autogen.gi"); ReadPackage( "TriangulatedCategories", "gap/DerivedMethods.gi"); ReadPackage( "TriangulatedCategories", "gap/CategoryOfTriangles.gi"); ReadPackage( "TriangulatedCategories", "gap/Functors.gi");