Quelle BasicFunctors.gi Sprache: unbekannt

# SPDX-License-Identifier: GPL-2.0-or-later
# homalg: A homological algebra meta-package for computable Abelian categories
#
# Implementations
#

##  Implementations for basic functors.

####################################
#
# install global functions/variables:
#
####################################

##
## additive functors [HS. Prop. II.9.5] preserves chain complexes [HS. p. 118]
## half exact functors are additive [HS. p. 132 & Ex. IV.5.8]
## a right adjoint functor is left exact [W. Thm. 2.6.1]
## a left adjoint functor is right exact [W. Thm. 2.6.1]
##

##
## Cokernel
##

##
InstallMethod( CokernelNaturalGeneralizedIsomorphism,
        "for homalg static morphisms",
        [ IsStaticMorphismOfFinitelyGeneratedObjectsRep ],

  function( phi )
    local coker, emb;

    coker := Cokernel( phi );

    ## sometimes an object is automatically assigned to a morphism as its Cokernel:
    ## this happens when M is resolved with F_0 --(d_0)--> M --> 0,
    ## then M is automatically assigned as the cokernel of d_0,
    ## and the component coker!.NaturalGeneralizedEmbedding is not set
    if IsBound( coker!.NaturalGeneralizedEmbedding ) then
        emb := NaturalGeneralizedEmbedding( coker );
    fi;

    ## since the cokernel object can very well be predefined as the outcome of a different functor than Cokernel
    ## (for example Resolution (of objects and complexes) sets CokernelEpi automatically!):
    if not ( IsBound( emb ) and IsIdenticalObj( Range( emb ), Source( phi ) ) ) then

        emb := InverseOfGeneralizedMorphismWithFullDomain( CokernelEpi( phi ) );

    fi;

    return emb;

end );

##
## ImageObject
##

##
InstallMethod( ImageObjectEpi,
        "for homalg static morphisms",
        [ IsStaticMorphismOfFinitelyGeneratedObjectsRep ],

  function( phi )
    local emb, epi, ker_emb;

    emb := ImageObjectEmb( phi );

    epi := phi / emb; ## lift

    ## check assertion
    Assert( 5, IsMorphism( epi ) );
    SetIsMorphism( epi, true );
    Assert( 5, IsEpimorphism( epi ) );
    SetIsEpimorphism( epi, true );

    ## Abelian category: [HS, Prop. II.9.6]
    if HasKernelEmb( phi ) then
        ker_emb := KernelEmb( phi );
        SetKernelEmb( epi, ker_emb );
        if not HasCokernelEpi( ker_emb ) then
            SetCokernelEpi( ker_emb, epi );
        fi;
    fi;

    if HasIsMonomorphism( phi )  then

        ## check assertion
        Assert( 5, IsIsomorphism( epi ) = IsMonomorphism( phi ) );

        SetIsIsomorphism( epi, IsMonomorphism( phi ) );

    fi;

    return epi;

end );

##
## Kernel
##

##
InstallMethod( Kernel,
        "LIMOR: for homalg morphisms",
        [ IsHomalgStaticMorphism ], 10001,

  function( psi )

    if HasKernelEmb( psi ) then
        return Source( KernelEmb( psi ) );
    fi;

    TryNextMethod( );

end );

##
BindGlobal( "_Functor_Kernel_OnObjects", ### defines: Kernel(Emb)
  function( psi )
    local S, ker_subobject, ker, emb, img_epi, T, coker, im;

    S := Source( psi );

    ## in case of modules: this involves computing relative syzygies:
    ker_subobject := KernelSubobject( psi );

    ## in case of f.p. modules: this involves a second syzygies computation:
    ## (the number of generators of ker might be less than the number of generators of ker_subobject)
    ker := UnderlyingObject( ker_subobject );

    ## IsMonomorphism?
    if HasIsZero( ker ) then
        SetIsMonomorphism( psi, IsZero( ker ) );
    fi;

    ## the natural embedding of ker in Source( psi ):
    emb := EmbeddingInSuperObject( ker_subobject );

    ## set the attribute KernelEmb (specific for Kernel):
    SetKernelEmb( psi, emb );

    #=====# end of the core procedure #=====#

    ## Abelian category: [HS, Prop. II.9.6]
    if HasImageObjectEpi( psi ) then
        img_epi := ImageObjectEpi( psi );
        SetCokernelEpi( emb, img_epi );
        if not HasKernelEmb( img_epi ) then
            SetKernelEmb( img_epi, emb );
        fi;
    elif HasIsEpimorphism( psi ) and IsEpimorphism( psi ) then
        SetCokernelEpi( emb, psi );
    fi;

    ## save the natural embedding in the kernel (thanks GAP):
    ker!.NaturalGeneralizedEmbedding := emb;

    ## figure out an upper bound for the projective dimension of ker:
    if not HasProjectiveDimension( ker ) and HasIsProjective( S ) and IsProjective( S ) then
        T := Range( psi );
        if HasIsProjective( T ) and IsProjective( T ) then  ## typical for M^* which is a K_2(D(M)) (up to projective equivalence)
            SetUpperBoundForProjectiveDimension( ker, -2 ); ## since ker = K_2( coker )
            if HasCokernelEpi( psi ) then
                coker := Range( CokernelEpi( psi ) ); ## S & T projective, then pd( ker ) = pd( coker ) - 2
                if HasProjectiveDimension( coker ) then
                    SetProjectiveDimension( ker, Maximum( 0, ProjectiveDimension( coker ) - 2 ) );
                elif IsBound( coker!.UpperBoundForProjectiveDimension ) then
                    SetUpperBoundForProjectiveDimension( ker, coker!.UpperBoundForProjectiveDimension - 2 );
                fi;
            elif HasImageObjectEmb( psi ) then
                im := Source( ImageObjectEmb( psi ) ); ## S projective, then pd( ker ) = pd( im ) - 1
                if HasProjectiveDimension( im ) then
                    SetProjectiveDimension( ker, Maximum( 0, ProjectiveDimension( im ) - 1 ) );
                elif IsBound( im!.UpperBoundForProjectiveDimension ) then
                    SetUpperBoundForProjectiveDimension( ker, im!.UpperBoundForProjectiveDimension - 1 );
                fi;
            fi;
        else
            SetUpperBoundForProjectiveDimension( ker, -1 ); ## since ker = K_1( im )
            if HasImageObjectEmb( psi ) then
                im := Source( ImageObjectEmb( psi ) ); ## S projective, then pd( ker ) = pd( im ) - 1
                if HasProjectiveDimension( im ) then
                    SetProjectiveDimension( ker, Maximum( 0, ProjectiveDimension( im ) - 1 ) );
                elif IsBound( im!.UpperBoundForProjectiveDimension ) then
                    SetUpperBoundForProjectiveDimension( ker, im!.UpperBoundForProjectiveDimension - 1 );
                fi;
            fi;
        fi;
    fi;

    return ker;

end );

##  <#GAPDoc Label="functor_Kernel:code">
##      <Listing Type="Code"><![CDATA[
BindGlobal( "functor_Kernel",
        CreateHomalgFunctor(
                [ "name", "Kernel" ],
                [ "category", HOMALG.category ],
                [ "operation", "Kernel" ],
                [ "natural_transformation", "KernelEmb" ],
                [ "special", true ],
                [ "number_of_arguments", 1 ],
                [ "1", [ [ "covariant" ],
                        [ IsStaticMorphismOfFinitelyGeneratedObjectsRep,
                          [ IsHomalgChainMorphism, IsKernelSquare ] ] ] ],
                [ "OnObjects", _Functor_Kernel_OnObjects ]
                )
        );
##  ]]></Listing>
##  <#/GAPDoc>

functor_Kernel!.ContainerForWeakPointersOnComputedBasicMorphisms :=
  ContainerForWeakPointers( TheTypeContainerForWeakPointersOnComputedValuesOfFunctor );

##
## DefectOfExactness
##

BindGlobal( "_Functor_DefectOfExactness_OnObjects", ### defines: DefectOfExactness (DefectOfHoms)
  function( phi, psi )
    local pre, post;

    if IsHomalgLeftObjectOrMorphismOfLeftObjects( phi ) and IsHomalgLeftObjectOrMorphismOfLeftObjects( psi ) then
        pre := phi;
        post := psi;
        if not AreComposableMorphisms( pre, post ) then
            Error( "the two morphisms are not composable, ",
                   "since the target of the left one and ",
                   "the source of right one are not \033[01midentical\033[0m\n" );
        fi;
    elif IsHomalgRightObjectOrMorphismOfRightObjects( phi ) and IsHomalgRightObjectOrMorphismOfRightObjects( psi ) then
        pre := psi;
        post := phi;
        if not AreComposableMorphisms( post, pre ) then
            Error( "the two morphisms are not composable, ",
                   "since the source of the left one and ",
                   "the target of the right one are not \033[01midentical\033[0m\n" );
        fi;
    else
        Error( "the two morphisms must either be both left or both right morphisms\n" );
    fi;

    return KernelSubobject( post ) / ImageSubobject( pre );

end );

##  <#GAPDoc Label="Functor_DefectOfExactness:code">
##      <Listing Type="Code"><![CDATA[
BindGlobal( "functor_DefectOfExactness",
        CreateHomalgFunctor(
                [ "name", "DefectOfExactness" ],
                [ "category", HOMALG.category ],
                [ "operation", "DefectOfExactness" ],
                [ "special", true ],
                [ "number_of_arguments", 2 ],
                [ "1", [ [ "covariant" ],
                        [ IsStaticMorphismOfFinitelyGeneratedObjectsRep,
                          [ IsHomalgChainMorphism, IsLambekPairOfSquares ] ] ] ],
                [ "2", [ [ "covariant" ],
                        [ IsStaticMorphismOfFinitelyGeneratedObjectsRep ] ] ],
                [ "OnObjects", _Functor_DefectOfExactness_OnObjects ]
                )
        );
##  ]]></Listing>
##  <#/GAPDoc>

functor_DefectOfExactness!.ContainerForWeakPointersOnComputedBasicObjects :=
  ContainerForWeakPointers( TheTypeContainerForWeakPointersOnComputedValuesOfFunctor );

functor_DefectOfExactness!.ContainerForWeakPointersOnComputedBasicMorphisms :=
  ContainerForWeakPointers( TheTypeContainerForWeakPointersOnComputedValuesOfFunctor );

## for convenience
InstallMethod( DefectOfExactness,
        "for homalg two-morphisms complexes",
        [ IsHomalgComplex and IsATwoSequence ],

  function( cpx_post_pre )
    local pre, post;

    pre := HighestDegreeMorphism( cpx_post_pre );
    post := LowestDegreeMorphism( cpx_post_pre );

    if IsHomalgLeftObjectOrMorphismOfLeftObjects( cpx_post_pre ) then
        return DefectOfExactness( pre, post );
    else
        return DefectOfExactness( post, pre );
    fi;

end );

##
InstallMethod( InternalHom,
        "for two homalg objects or morphisms",
        [ IsHomalgObjectOrMorphism, IsHomalgObjectOrMorphism ],

  function( obj_or_mor_1, obj_or_mor_2 )

    return CallOperationFromCategory( "InternalHom", [ obj_or_mor_1, obj_or_mor_2 ] );

end );

##
InstallMethod( InternalHom,
        "for a homalg object or morphism",
        [ IsHomalgObjectOrMorphism ],

  function( obj_or_mor )

    return CallOperationFromCategory( "InternalHom", [ obj_or_mor ] );

end );

##
InstallMethod( InternalExt,
        "for an integer and two homalg objects or morphisms",
        [ IsInt, IsHomalgObjectOrMorphism, IsHomalgObjectOrMorphism ],

  function( c, obj_or_mor_1, obj_or_mor_2 )

    return CallOperationFromCategory( "InternalExt", [ c, obj_or_mor_1, obj_or_mor_2 ] );

end );

##
InstallMethod( InternalExt,
        "for two homalg objects or morphisms",
        [ IsHomalgObjectOrMorphism, IsHomalgObjectOrMorphism ],

  function( obj_or_mor_1, obj_or_mor_2 )

    return CallOperationFromCategory( "InternalExt", [ obj_or_mor_1, obj_or_mor_2 ] );

end );

##
InstallMethod( InternalExt,
        "for an integer and a homalg object or morphism",
        [ IsInt, IsHomalgObjectOrMorphism ],

  function( c, obj_or_mor )

    return CallOperationFromCategory( "InternalExt", [ c, obj_or_mor ] );

end );

##
InstallMethod( InternalExt,
        "for a homalg object or morphism",
        [ IsHomalgObjectOrMorphism ],

  function( obj_or_mor )

    return CallOperationFromCategory( "InternalExt", [ obj_or_mor ] );

end );

##  <#GAPDoc Label="Functor_Dualize:code">
##      <Listing Type="Code"><![CDATA[
BindGlobal( "Functor_Dualize",
        CreateHomalgFunctor(
                [ "name", "Dualize" ],
                [ "category", HOMALG.category ],
                [ "operation", "Dualize" ],
                [ "number_of_arguments", 1 ],
                [ "1", [ [ "contravariant", "right adjoint", "distinguished" ] ] ]
                )
        );
##  ]]></Listing>
##  <#/GAPDoc>

##
## TensorProduct
##

## TensorProduct might have been defined elsewhere
if not IsBound( TensorProduct ) then

    DeclareGlobalFunction( "TensorProduct" );

    ##
    InstallGlobalFunction( TensorProduct,
      function ( arg )
        local  d;
        if Length( arg ) = 0  then
            Error( "<arg> must be nonempty" );
        elif Length( arg ) = 1 and IsList( arg[1] )  then
            if IsEmpty( arg[1] )  then
                Error( "<arg>[1] must be nonempty" );
            fi;
            arg := arg[1];
        fi;
        d := TensorProductOp( arg, arg[1] );
        if ForAll( arg, HasSize )  then
            if ForAll( arg, IsFinite )  then
                SetSize( d, Product( List( arg, Size ) ) );
            else
                SetSize( d, infinity );
            fi;
        fi;
        return d;
    end );
fi;

####################################
#
# methods for operations & attributes:
#
####################################

##
## Kernel( phi ) and KernelEmb( phi )
##

##  <#GAPDoc Label="functor_Kernel">
##  <ManSection>
##    <Var Name="functor_Kernel"/>
##    <Description>
##      The functor that associates to a map its kernel.
##      <#Include Label="functor_Kernel:code">
##    </Description>
##  </ManSection>
##  <#/GAPDoc>

##
InstallFunctor( functor_Kernel );

##
## DefectOfExactness( cpx_post_pre )
##

##  <#GAPDoc Label="functor_DefectOfExactness">
##  <ManSection>
##    <Var Name="functor_DefectOfExactness"/>
##    <Description>
##      The functor that associates to a pair of composable maps with a zero compositum the defect of exactness,
##      i.e. the kernel of the outer map modulo the image of the inner map.
##      <#Include Label="Functor_DefectOfExactness:code">
##    </Description>
##  </ManSection>
##  <#/GAPDoc>

##
InstallFunctor( functor_DefectOfExactness );

##
## Dualize( M )
##

##
InstallFunctor( Functor_Dualize );

##
## TensorProduct( M, N ) ( M * N )
##

if not IsOperation( TensorProduct ) then

    ## GAP 4.5 style
    ##
    InstallMethod( TensorProductOp,
            "for homalg objects",
            [ IsList, IsStructureObjectOrObjectOrMorphism ],

      function( L, M )

        return Iterated( L, TensorProductOp );

    end );

fi;

Quelle BasicFunctors.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.35 Sekunden (vorverarbeitet) ]