Quelle MethodRecordInstallations.autogen.gi Sprache: unbekannt

# SPDX-License-Identifier: GPL-2.0-or-later
# CAP: Categories, Algorithms, Programming
#
# Implementations
#
# THIS FILE IS AUTOMATICALLY GENERATED, SEE CAP_project/CAP/gap/MethodRecordTools.gi

## AdditionForMorphisms
InstallMethod( AddAdditionForMorphisms,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "AdditionForMorphisms", category, func, -1 );

end );

InstallMethod( AddAdditionForMorphisms,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "AdditionForMorphisms", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## AdditiveGenerators
InstallMethod( AddAdditiveGenerators,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "AdditiveGenerators", category, func, -1 );

end );

InstallMethod( AddAdditiveGenerators,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "AdditiveGenerators", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## AdditiveInverseForMorphisms
InstallMethod( AddAdditiveInverseForMorphisms,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "AdditiveInverseForMorphisms", category, func, -1 );

end );

InstallMethod( AddAdditiveInverseForMorphisms,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "AdditiveInverseForMorphisms", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## AstrictionToCoimage
InstallMethod( AddAstrictionToCoimage,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "AstrictionToCoimage", category, func, -1 );

end );

InstallMethod( AddAstrictionToCoimage,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "AstrictionToCoimage", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## AstrictionToCoimageWithGivenCoimageObject
InstallMethod( AddAstrictionToCoimageWithGivenCoimageObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "AstrictionToCoimageWithGivenCoimageObject", category, func, -1 );

end );

InstallMethod( AddAstrictionToCoimageWithGivenCoimageObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "AstrictionToCoimageWithGivenCoimageObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( AstrictionToCoimageWithGivenCoimageObject,
                    "AstrictionToCoimageWithGivenCoimageObject by calling AstrictionToCoimage with the WithGiven argument(s) dropped",
                    [
                        [ AstrictionToCoimage, 1 ],
                    ],
  function( cat, alpha, C )

    return AstrictionToCoimage( cat, alpha );

end : is_with_given_derivation := true );

AddDerivationToCAP( AstrictionToCoimage,
                    "AstrictionToCoimage by calling AstrictionToCoimageWithGivenCoimageObject with the WithGiven object(s)",
                    [
                        [ AstrictionToCoimageWithGivenCoimageObject, 1 ],
                        [ CoimageObject, 1 ],
                    ],
  function( cat, alpha )

    return AstrictionToCoimageWithGivenCoimageObject( cat, alpha, CoimageObject( cat, alpha ) );

end : is_with_given_derivation := true );

## BasisOfExternalHom
InstallMethod( AddBasisOfExternalHom,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "BasisOfExternalHom", category, func, -1 );

end );

InstallMethod( AddBasisOfExternalHom,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "BasisOfExternalHom", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory
InstallMethod( AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", category, func, -1 );

end );

InstallMethod( AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory
InstallMethod( AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", category, func, -1 );

end );

InstallMethod( AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoastrictionToImage
InstallMethod( AddCoastrictionToImage,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoastrictionToImage", category, func, -1 );

end );

InstallMethod( AddCoastrictionToImage,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoastrictionToImage", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoastrictionToImageWithGivenImageObject
InstallMethod( AddCoastrictionToImageWithGivenImageObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoastrictionToImageWithGivenImageObject", category, func, -1 );

end );

InstallMethod( AddCoastrictionToImageWithGivenImageObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoastrictionToImageWithGivenImageObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CoastrictionToImageWithGivenImageObject,
                    "CoastrictionToImageWithGivenImageObject by calling CoastrictionToImage with the WithGiven argument(s) dropped",
                    [
                        [ CoastrictionToImage, 1 ],
                    ],
  function( cat, alpha, I )

    return CoastrictionToImage( cat, alpha );

end : is_with_given_derivation := true );

AddDerivationToCAP( CoastrictionToImage,
                    "CoastrictionToImage by calling CoastrictionToImageWithGivenImageObject with the WithGiven object(s)",
                    [
                        [ CoastrictionToImageWithGivenImageObject, 1 ],
                        [ ImageObject, 1 ],
                    ],
  function( cat, alpha )

    return CoastrictionToImageWithGivenImageObject( cat, alpha, ImageObject( cat, alpha ) );

end : is_with_given_derivation := true );

## CoefficientsOfMorphism
InstallMethod( AddCoefficientsOfMorphism,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoefficientsOfMorphism", category, func, -1 );

end );

InstallMethod( AddCoefficientsOfMorphism,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoefficientsOfMorphism", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## Coequalizer
InstallMethod( AddCoequalizer,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "Coequalizer", category, func, -1 );

end );

InstallMethod( AddCoequalizer,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "Coequalizer", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoequalizerFunctorial
InstallMethod( AddCoequalizerFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoequalizerFunctorial", category, func, -1 );

end );

InstallMethod( AddCoequalizerFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoequalizerFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoequalizerFunctorialWithGivenCoequalizers
InstallMethod( AddCoequalizerFunctorialWithGivenCoequalizers,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoequalizerFunctorialWithGivenCoequalizers", category, func, -1 );

end );

InstallMethod( AddCoequalizerFunctorialWithGivenCoequalizers,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoequalizerFunctorialWithGivenCoequalizers", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CoequalizerFunctorialWithGivenCoequalizers,
                    "CoequalizerFunctorialWithGivenCoequalizers by calling CoequalizerFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ CoequalizerFunctorial, 1 ],
                    ],
  function( cat, P, morphisms, mu, morphismsp, Pp )

    return CoequalizerFunctorial( cat, morphisms, mu, morphismsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( CoequalizerFunctorial,
                    "CoequalizerFunctorial by calling CoequalizerFunctorialWithGivenCoequalizers with the WithGiven object(s)",
                    [
                        [ CoequalizerFunctorialWithGivenCoequalizers, 1 ],
                        [ Coequalizer, 2 ],
                    ],
  function( cat, morphisms, mu, morphismsp )

    return CoequalizerFunctorialWithGivenCoequalizers( cat, Coequalizer( cat, Source( mu ), morphisms ), morphisms, mu, morphismsp, Coequalizer( cat, Range( mu ), morphismsp ) );

end : is_with_given_derivation := true );

## CoimageObject
InstallMethod( AddCoimageObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoimageObject", category, func, -1 );

end );

InstallMethod( AddCoimageObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoimageObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoimageObjectFunctorial
InstallMethod( AddCoimageObjectFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoimageObjectFunctorial", category, func, -1 );

end );

InstallMethod( AddCoimageObjectFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoimageObjectFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoimageObjectFunctorialWithGivenCoimageObjects
InstallMethod( AddCoimageObjectFunctorialWithGivenCoimageObjects,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoimageObjectFunctorialWithGivenCoimageObjects", category, func, -1 );

end );

InstallMethod( AddCoimageObjectFunctorialWithGivenCoimageObjects,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoimageObjectFunctorialWithGivenCoimageObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CoimageObjectFunctorialWithGivenCoimageObjects,
                    "CoimageObjectFunctorialWithGivenCoimageObjects by calling CoimageObjectFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ CoimageObjectFunctorial, 1 ],
                    ],
  function( cat, C, alpha, mu, alphap, Cp )

    return CoimageObjectFunctorial( cat, alpha, mu, alphap );

end : is_with_given_derivation := true );

AddDerivationToCAP( CoimageObjectFunctorial,
                    "CoimageObjectFunctorial by calling CoimageObjectFunctorialWithGivenCoimageObjects with the WithGiven object(s)",
                    [
                        [ CoimageObjectFunctorialWithGivenCoimageObjects, 1 ],
                        [ CoimageObject, 2 ],
                    ],
  function( cat, alpha, mu, alphap )

    return CoimageObjectFunctorialWithGivenCoimageObjects( cat, CoimageObject( cat, alpha ), alpha, mu, alphap, CoimageObject( cat, alphap ) );

end : is_with_given_derivation := true );

## CoimageProjection
InstallMethod( AddCoimageProjection,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoimageProjection", category, func, -1 );

end );

InstallMethod( AddCoimageProjection,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoimageProjection", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoimageProjectionWithGivenCoimageObject
InstallMethod( AddCoimageProjectionWithGivenCoimageObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoimageProjectionWithGivenCoimageObject", category, func, -1 );

end );

InstallMethod( AddCoimageProjectionWithGivenCoimageObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoimageProjectionWithGivenCoimageObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CoimageProjectionWithGivenCoimageObject,
                    "CoimageProjectionWithGivenCoimageObject by calling CoimageProjection with the WithGiven argument(s) dropped",
                    [
                        [ CoimageProjection, 1 ],
                    ],
  function( cat, alpha, C )

    return CoimageProjection( cat, alpha );

end : is_with_given_derivation := true );

AddDerivationToCAP( CoimageProjection,
                    "CoimageProjection by calling CoimageProjectionWithGivenCoimageObject with the WithGiven object(s)",
                    [
                        [ CoimageProjectionWithGivenCoimageObject, 1 ],
                        [ CoimageObject, 1 ],
                    ],
  function( cat, alpha )

    return CoimageProjectionWithGivenCoimageObject( cat, alpha, CoimageObject( cat, alpha ) );

end : is_with_given_derivation := true );

## CokernelColift
InstallMethod( AddCokernelColift,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelColift", category, func, -1 );

end );

InstallMethod( AddCokernelColift,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelColift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CokernelColiftWithGivenCokernelObject
InstallMethod( AddCokernelColiftWithGivenCokernelObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelColiftWithGivenCokernelObject", category, func, -1 );

end );

InstallMethod( AddCokernelColiftWithGivenCokernelObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelColiftWithGivenCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CokernelColiftWithGivenCokernelObject,
                    "CokernelColiftWithGivenCokernelObject by calling CokernelColift with the WithGiven argument(s) dropped",
                    [
                        [ CokernelColift, 1 ],
                    ],
  function( cat, alpha, T, tau, P )

    return CokernelColift( cat, alpha, T, tau );

end : is_with_given_derivation := true );

AddDerivationToCAP( CokernelColift,
                    "CokernelColift by calling CokernelColiftWithGivenCokernelObject with the WithGiven object(s)",
                    [
                        [ CokernelColiftWithGivenCokernelObject, 1 ],
                        [ CokernelObject, 1 ],
                    ],
  function( cat, alpha, T, tau )

    return CokernelColiftWithGivenCokernelObject( cat, alpha, T, tau, CokernelObject( cat, alpha ) );

end : is_with_given_derivation := true );

## CokernelObject
InstallMethod( AddCokernelObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelObject", category, func, -1 );

end );

InstallMethod( AddCokernelObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CokernelObjectFunctorial
InstallMethod( AddCokernelObjectFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelObjectFunctorial", category, func, -1 );

end );

InstallMethod( AddCokernelObjectFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelObjectFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CokernelObjectFunctorialWithGivenCokernelObjects
InstallMethod( AddCokernelObjectFunctorialWithGivenCokernelObjects,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelObjectFunctorialWithGivenCokernelObjects", category, func, -1 );

end );

InstallMethod( AddCokernelObjectFunctorialWithGivenCokernelObjects,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelObjectFunctorialWithGivenCokernelObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CokernelObjectFunctorialWithGivenCokernelObjects,
                    "CokernelObjectFunctorialWithGivenCokernelObjects by calling CokernelObjectFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ CokernelObjectFunctorial, 1 ],
                    ],
  function( cat, P, alpha, mu, alphap, Pp )

    return CokernelObjectFunctorial( cat, alpha, mu, alphap );

end : is_with_given_derivation := true );

AddDerivationToCAP( CokernelObjectFunctorial,
                    "CokernelObjectFunctorial by calling CokernelObjectFunctorialWithGivenCokernelObjects with the WithGiven object(s)",
                    [
                        [ CokernelObjectFunctorialWithGivenCokernelObjects, 1 ],
                        [ CokernelObject, 2 ],
                    ],
  function( cat, alpha, mu, alphap )

    return CokernelObjectFunctorialWithGivenCokernelObjects( cat, CokernelObject( cat, alpha ), alpha, mu, alphap, CokernelObject( cat, alphap ) );

end : is_with_given_derivation := true );

## CokernelProjection
InstallMethod( AddCokernelProjection,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelProjection", category, func, -1 );

end );

InstallMethod( AddCokernelProjection,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelProjection", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CokernelProjectionWithGivenCokernelObject
InstallMethod( AddCokernelProjectionWithGivenCokernelObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CokernelProjectionWithGivenCokernelObject", category, func, -1 );

end );

InstallMethod( AddCokernelProjectionWithGivenCokernelObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CokernelProjectionWithGivenCokernelObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CokernelProjectionWithGivenCokernelObject,
                    "CokernelProjectionWithGivenCokernelObject by calling CokernelProjection with the WithGiven argument(s) dropped",
                    [
                        [ CokernelProjection, 1 ],
                    ],
  function( cat, alpha, P )

    return CokernelProjection( cat, alpha );

end : is_with_given_derivation := true );

AddDerivationToCAP( CokernelProjection,
                    "CokernelProjection by calling CokernelProjectionWithGivenCokernelObject with the WithGiven object(s)",
                    [
                        [ CokernelProjectionWithGivenCokernelObject, 1 ],
                        [ CokernelObject, 1 ],
                    ],
  function( cat, alpha )

    return CokernelProjectionWithGivenCokernelObject( cat, alpha, CokernelObject( cat, alpha ) );

end : is_with_given_derivation := true );

## Colift
InstallMethod( AddColift,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "Colift", category, func, -1 );

end );

InstallMethod( AddColift,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "Colift", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## ColiftAlongEpimorphism
InstallMethod( AddColiftAlongEpimorphism,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "ColiftAlongEpimorphism", category, func, -1 );

end );

InstallMethod( AddColiftAlongEpimorphism,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "ColiftAlongEpimorphism", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## ComponentOfMorphismFromCoproduct
InstallMethod( AddComponentOfMorphismFromCoproduct,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "ComponentOfMorphismFromCoproduct", category, func, -1 );

end );

InstallMethod( AddComponentOfMorphismFromCoproduct,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "ComponentOfMorphismFromCoproduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## ComponentOfMorphismFromDirectSum
InstallMethod( AddComponentOfMorphismFromDirectSum,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "ComponentOfMorphismFromDirectSum", category, func, -1 );

end );

InstallMethod( AddComponentOfMorphismFromDirectSum,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "ComponentOfMorphismFromDirectSum", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## ComponentOfMorphismIntoDirectProduct
InstallMethod( AddComponentOfMorphismIntoDirectProduct,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "ComponentOfMorphismIntoDirectProduct", category, func, -1 );

end );

InstallMethod( AddComponentOfMorphismIntoDirectProduct,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "ComponentOfMorphismIntoDirectProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## ComponentOfMorphismIntoDirectSum
InstallMethod( AddComponentOfMorphismIntoDirectSum,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "ComponentOfMorphismIntoDirectSum", category, func, -1 );

end );

InstallMethod( AddComponentOfMorphismIntoDirectSum,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "ComponentOfMorphismIntoDirectSum", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## Coproduct
InstallMethod( AddCoproduct,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "Coproduct", category, func, -1 );

end );

InstallMethod( AddCoproduct,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "Coproduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoproductFunctorial
InstallMethod( AddCoproductFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoproductFunctorial", category, func, -1 );

end );

InstallMethod( AddCoproductFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoproductFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## CoproductFunctorialWithGivenCoproducts
InstallMethod( AddCoproductFunctorialWithGivenCoproducts,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "CoproductFunctorialWithGivenCoproducts", category, func, -1 );

end );

InstallMethod( AddCoproductFunctorialWithGivenCoproducts,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "CoproductFunctorialWithGivenCoproducts", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( CoproductFunctorialWithGivenCoproducts,
                    "CoproductFunctorialWithGivenCoproducts by calling CoproductFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ CoproductFunctorial, 1 ],
                    ],
  function( cat, P, objects, L, objectsp, Pp )

    return CoproductFunctorial( cat, objects, L, objectsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( CoproductFunctorial,
                    "CoproductFunctorial by calling CoproductFunctorialWithGivenCoproducts with the WithGiven object(s)",
                    [
                        [ CoproductFunctorialWithGivenCoproducts, 1 ],
                        [ Coproduct, 2 ],
                    ],
  function( cat, objects, L, objectsp )

    return CoproductFunctorialWithGivenCoproducts( cat, Coproduct( cat, objects ), objects, L, objectsp, Coproduct( cat, objectsp ) );

end : is_with_given_derivation := true );

## DirectProduct
InstallMethod( AddDirectProduct,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectProduct", category, func, -1 );

end );

InstallMethod( AddDirectProduct,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## DirectProductFunctorial
InstallMethod( AddDirectProductFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectProductFunctorial", category, func, -1 );

end );

InstallMethod( AddDirectProductFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectProductFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## DirectProductFunctorialWithGivenDirectProducts
InstallMethod( AddDirectProductFunctorialWithGivenDirectProducts,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectProductFunctorialWithGivenDirectProducts", category, func, -1 );

end );

InstallMethod( AddDirectProductFunctorialWithGivenDirectProducts,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectProductFunctorialWithGivenDirectProducts", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( DirectProductFunctorialWithGivenDirectProducts,
                    "DirectProductFunctorialWithGivenDirectProducts by calling DirectProductFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ DirectProductFunctorial, 1 ],
                    ],
  function( cat, P, objects, L, objectsp, Pp )

    return DirectProductFunctorial( cat, objects, L, objectsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( DirectProductFunctorial,
                    "DirectProductFunctorial by calling DirectProductFunctorialWithGivenDirectProducts with the WithGiven object(s)",
                    [
                        [ DirectProductFunctorialWithGivenDirectProducts, 1 ],
                        [ DirectProduct, 2 ],
                    ],
  function( cat, objects, L, objectsp )

    return DirectProductFunctorialWithGivenDirectProducts( cat, DirectProduct( cat, objects ), objects, L, objectsp, DirectProduct( cat, objectsp ) );

end : is_with_given_derivation := true );

## DirectSum
InstallMethod( AddDirectSum,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectSum", category, func, -1 );

end );

InstallMethod( AddDirectSum,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectSum", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## DirectSumFunctorial
InstallMethod( AddDirectSumFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectSumFunctorial", category, func, -1 );

end );

InstallMethod( AddDirectSumFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectSumFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## DirectSumFunctorialWithGivenDirectSums
InstallMethod( AddDirectSumFunctorialWithGivenDirectSums,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DirectSumFunctorialWithGivenDirectSums", category, func, -1 );

end );

InstallMethod( AddDirectSumFunctorialWithGivenDirectSums,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DirectSumFunctorialWithGivenDirectSums", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( DirectSumFunctorialWithGivenDirectSums,
                    "DirectSumFunctorialWithGivenDirectSums by calling DirectSumFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ DirectSumFunctorial, 1 ],
                    ],
  function( cat, P, objects, L, objectsp, Pp )

    return DirectSumFunctorial( cat, objects, L, objectsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( DirectSumFunctorial,
                    "DirectSumFunctorial by calling DirectSumFunctorialWithGivenDirectSums with the WithGiven object(s)",
                    [
                        [ DirectSumFunctorialWithGivenDirectSums, 1 ],
                        [ DirectSum, 2 ],
                    ],
  function( cat, objects, L, objectsp )

    return DirectSumFunctorialWithGivenDirectSums( cat, DirectSum( cat, objects ), objects, L, objectsp, DirectSum( cat, objectsp ) );

end : is_with_given_derivation := true );

## DistinguishedObjectOfHomomorphismStructure
InstallMethod( AddDistinguishedObjectOfHomomorphismStructure,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "DistinguishedObjectOfHomomorphismStructure", category, func, -1 );

end );

InstallMethod( AddDistinguishedObjectOfHomomorphismStructure,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "DistinguishedObjectOfHomomorphismStructure", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EmbeddingOfEqualizer
InstallMethod( AddEmbeddingOfEqualizer,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EmbeddingOfEqualizer", category, func, -1 );

end );

InstallMethod( AddEmbeddingOfEqualizer,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EmbeddingOfEqualizer", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EmbeddingOfEqualizerWithGivenEqualizer
InstallMethod( AddEmbeddingOfEqualizerWithGivenEqualizer,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EmbeddingOfEqualizerWithGivenEqualizer", category, func, -1 );

end );

InstallMethod( AddEmbeddingOfEqualizerWithGivenEqualizer,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EmbeddingOfEqualizerWithGivenEqualizer", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( EmbeddingOfEqualizerWithGivenEqualizer,
                    "EmbeddingOfEqualizerWithGivenEqualizer by calling EmbeddingOfEqualizer with the WithGiven argument(s) dropped",
                    [
                        [ EmbeddingOfEqualizer, 1 ],
                    ],
  function( cat, Y, morphisms, P )

    return EmbeddingOfEqualizer( cat, Y, morphisms );

end : is_with_given_derivation := true );

AddDerivationToCAP( EmbeddingOfEqualizer,
                    "EmbeddingOfEqualizer by calling EmbeddingOfEqualizerWithGivenEqualizer with the WithGiven object(s)",
                    [
                        [ EmbeddingOfEqualizerWithGivenEqualizer, 1 ],
                        [ Equalizer, 1 ],
                    ],
  function( cat, Y, morphisms )

    return EmbeddingOfEqualizerWithGivenEqualizer( cat, Y, morphisms, Equalizer( cat, Y, morphisms ) );

end : is_with_given_derivation := true );

## EpimorphismFromProjectiveCoverObject
InstallMethod( AddEpimorphismFromProjectiveCoverObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EpimorphismFromProjectiveCoverObject", category, func, -1 );

end );

InstallMethod( AddEpimorphismFromProjectiveCoverObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EpimorphismFromProjectiveCoverObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject
InstallMethod( AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject", category, func, -1 );

end );

InstallMethod( AddEpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject,
                    "EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject by calling EpimorphismFromProjectiveCoverObject with the WithGiven argument(s) dropped",
                    [
                        [ EpimorphismFromProjectiveCoverObject, 1 ],
                    ],
  function( cat, A, P )

    return EpimorphismFromProjectiveCoverObject( cat, A );

end : is_with_given_derivation := true );

AddDerivationToCAP( EpimorphismFromProjectiveCoverObject,
                    "EpimorphismFromProjectiveCoverObject by calling EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject with the WithGiven object(s)",
                    [
                        [ EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject, 1 ],
                        [ ProjectiveCoverObject, 1 ],
                    ],
  function( cat, A )

    return EpimorphismFromProjectiveCoverObjectWithGivenProjectiveCoverObject( cat, A, ProjectiveCoverObject( cat, A ) );

end : is_with_given_derivation := true );

## EpimorphismFromSomeProjectiveObject
InstallMethod( AddEpimorphismFromSomeProjectiveObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EpimorphismFromSomeProjectiveObject", category, func, -1 );

end );

InstallMethod( AddEpimorphismFromSomeProjectiveObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EpimorphismFromSomeProjectiveObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
InstallMethod( AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject", category, func, -1 );

end );

InstallMethod( AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject,
                    "EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject by calling EpimorphismFromSomeProjectiveObject with the WithGiven argument(s) dropped",
                    [
                        [ EpimorphismFromSomeProjectiveObject, 1 ],
                    ],
  function( cat, A, P )

    return EpimorphismFromSomeProjectiveObject( cat, A );

end : is_with_given_derivation := true );

AddDerivationToCAP( EpimorphismFromSomeProjectiveObject,
                    "EpimorphismFromSomeProjectiveObject by calling EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject with the WithGiven object(s)",
                    [
                        [ EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject, 1 ],
                        [ SomeProjectiveObject, 1 ],
                    ],
  function( cat, A )

    return EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject( cat, A, SomeProjectiveObject( cat, A ) );

end : is_with_given_derivation := true );

## Equalizer
InstallMethod( AddEqualizer,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "Equalizer", category, func, -1 );

end );

InstallMethod( AddEqualizer,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "Equalizer", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EqualizerFunctorial
InstallMethod( AddEqualizerFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EqualizerFunctorial", category, func, -1 );

end );

InstallMethod( AddEqualizerFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EqualizerFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## EqualizerFunctorialWithGivenEqualizers
InstallMethod( AddEqualizerFunctorialWithGivenEqualizers,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "EqualizerFunctorialWithGivenEqualizers", category, func, -1 );

end );

InstallMethod( AddEqualizerFunctorialWithGivenEqualizers,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "EqualizerFunctorialWithGivenEqualizers", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( EqualizerFunctorialWithGivenEqualizers,
                    "EqualizerFunctorialWithGivenEqualizers by calling EqualizerFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ EqualizerFunctorial, 1 ],
                    ],
  function( cat, P, morphisms, mu, morphismsp, Pp )

    return EqualizerFunctorial( cat, morphisms, mu, morphismsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( EqualizerFunctorial,
                    "EqualizerFunctorial by calling EqualizerFunctorialWithGivenEqualizers with the WithGiven object(s)",
                    [
                        [ EqualizerFunctorialWithGivenEqualizers, 1 ],
                        [ Equalizer, 2 ],
                    ],
  function( cat, morphisms, mu, morphismsp )

    return EqualizerFunctorialWithGivenEqualizers( cat, Equalizer( cat, Source( mu ), morphisms ), morphisms, mu, morphismsp, Equalizer( cat, Range( mu ), morphismsp ) );

end : is_with_given_derivation := true );

## FiberProduct
InstallMethod( AddFiberProduct,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "FiberProduct", category, func, -1 );

end );

InstallMethod( AddFiberProduct,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "FiberProduct", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## FiberProductFunctorial
InstallMethod( AddFiberProductFunctorial,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "FiberProductFunctorial", category, func, -1 );

end );

InstallMethod( AddFiberProductFunctorial,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "FiberProductFunctorial", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## FiberProductFunctorialWithGivenFiberProducts
InstallMethod( AddFiberProductFunctorialWithGivenFiberProducts,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "FiberProductFunctorialWithGivenFiberProducts", category, func, -1 );

end );

InstallMethod( AddFiberProductFunctorialWithGivenFiberProducts,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "FiberProductFunctorialWithGivenFiberProducts", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( FiberProductFunctorialWithGivenFiberProducts,
                    "FiberProductFunctorialWithGivenFiberProducts by calling FiberProductFunctorial with the WithGiven argument(s) dropped",
                    [
                        [ FiberProductFunctorial, 1 ],
                    ],
  function( cat, P, morphisms, L, morphismsp, Pp )

    return FiberProductFunctorial( cat, morphisms, L, morphismsp );

end : is_with_given_derivation := true );

AddDerivationToCAP( FiberProductFunctorial,
                    "FiberProductFunctorial by calling FiberProductFunctorialWithGivenFiberProducts with the WithGiven object(s)",
                    [
                        [ FiberProductFunctorialWithGivenFiberProducts, 1 ],
                        [ FiberProduct, 2 ],
                    ],
  function( cat, morphisms, L, morphismsp )

    return FiberProductFunctorialWithGivenFiberProducts( cat, FiberProduct( cat, morphisms ), morphisms, L, morphismsp, FiberProduct( cat, morphismsp ) );

end : is_with_given_derivation := true );

## HomologyObject
InstallMethod( AddHomologyObject,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HomologyObject", category, func, -1 );

end );

InstallMethod( AddHomologyObject,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HomologyObject", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## HomologyObjectFunctorialWithGivenHomologyObjects
InstallMethod( AddHomologyObjectFunctorialWithGivenHomologyObjects,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HomologyObjectFunctorialWithGivenHomologyObjects", category, func, -1 );

end );

InstallMethod( AddHomologyObjectFunctorialWithGivenHomologyObjects,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HomologyObjectFunctorialWithGivenHomologyObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## HomomorphismStructureOnMorphisms
InstallMethod( AddHomomorphismStructureOnMorphisms,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HomomorphismStructureOnMorphisms", category, func, -1 );

end );

InstallMethod( AddHomomorphismStructureOnMorphisms,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HomomorphismStructureOnMorphisms", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## HomomorphismStructureOnMorphismsWithGivenObjects
InstallMethod( AddHomomorphismStructureOnMorphismsWithGivenObjects,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HomomorphismStructureOnMorphismsWithGivenObjects", category, func, -1 );

end );

InstallMethod( AddHomomorphismStructureOnMorphismsWithGivenObjects,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HomomorphismStructureOnMorphismsWithGivenObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

AddDerivationToCAP( HomomorphismStructureOnMorphismsWithGivenObjects,
                    "HomomorphismStructureOnMorphismsWithGivenObjects by calling HomomorphismStructureOnMorphisms with the WithGiven argument(s) dropped",
                    [
                        [ HomomorphismStructureOnMorphisms, 1 ],
                    ],
  function( cat, source, alpha, beta, range )

    return HomomorphismStructureOnMorphisms( cat, alpha, beta );

end : is_with_given_derivation := true );

AddDerivationToCAP( HomomorphismStructureOnMorphisms,
                    "HomomorphismStructureOnMorphisms by calling HomomorphismStructureOnMorphismsWithGivenObjects with the WithGiven object(s)",
                    [
                        [ HomomorphismStructureOnMorphismsWithGivenObjects, 1 ],
                        [ HomomorphismStructureOnObjects, 2 ],
                    ],
  function( cat, alpha, beta )

    return HomomorphismStructureOnMorphismsWithGivenObjects( cat, HomomorphismStructureOnObjects( cat, Range( alpha ), Source( beta ) ), alpha, beta, HomomorphismStructureOnObjects( cat, Source( alpha ), Range( beta ) ) );

end : is_with_given_derivation := true );

## HomomorphismStructureOnObjects
InstallMethod( AddHomomorphismStructureOnObjects,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HomomorphismStructureOnObjects", category, func, -1 );

end );

InstallMethod( AddHomomorphismStructureOnObjects,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HomomorphismStructureOnObjects", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## HorizontalPostCompose
InstallMethod( AddHorizontalPostCompose,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HorizontalPostCompose", category, func, -1 );

end );

InstallMethod( AddHorizontalPostCompose,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HorizontalPostCompose", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## HorizontalPreCompose
InstallMethod( AddHorizontalPreCompose,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "HorizontalPreCompose", category, func, -1 );

end );

InstallMethod( AddHorizontalPreCompose,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "HorizontalPreCompose", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## IdentityMorphism
InstallMethod( AddIdentityMorphism,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "IdentityMorphism", category, func, -1 );

end );

InstallMethod( AddIdentityMorphism,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "IdentityMorphism", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

## IdentityTwoCell
InstallMethod( AddIdentityTwoCell,
               [ IsCapCategory, IsFunction ],

  function( category, func )

    AddCapOperation( "IdentityTwoCell", category, func, -1 );

end );

InstallMethod( AddIdentityTwoCell,
               [ IsCapCategory, IsFunction, IsInt ],

    FunctionWithNamedArguments(
        [
            [ "IsPrecompiledDerivation", false ],
        ],
        function( CAP_NAMED_ARGUMENTS, category, func, weight )

            AddCapOperation( "IdentityTwoCell", category, func, weight : IsPrecompiledDerivation := CAP_NAMED_ARGUMENTS.IsPrecompiledDerivation );

        end
    )
);

--> --------------------

--> maximum size reached

--> --------------------

Quelle MethodRecordInstallations.autogen.gi Sprache: unbekannt

[ zur Elbe Produktseite wechseln0.43Quellennavigators Analyse erneut starten ]