diff --git a/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gd b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gd
new file mode 100644
index 0000000000..adcabc0a2b
--- /dev/null
+++ b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gd
@@ -0,0 +1,147 @@
+#############################################################################
+##
+## GradedModulePresentationsbyFreyd
+##
+## Copyright 2019,  Martin Bies,       ULB Brussels
+##
+#! @Chapter Functors in the CAP category of graded module presentations  by use of Freyd categories
+##
+#############################################################################
+
+
+# an attribute for homalg_matrices, that allows to represent that matrix 'smaller'
+DeclareAttribute( "LessGradedGeneratorsTransformationTripleLeft",
+                  IsHomalgMatrix );
+DeclareAttribute( "LessGradedGeneratorsTransformationTripleRight",
+                  IsHomalgMatrix );
+
+
+#######################################################
+##
+#! @Section Functor less_generators for FpGradedModules
+##
+#######################################################
+
+#! @Description
+#! The argument is a graded left or right module presentation $M$. We then return a presentation of this
+#! module which uses less generators.
+#! @Returns a graded left or right module presentation
+#! @Arguments M
+DeclareOperation( "LessGradedGenerators",
+                  [ IsFpGradedLeftOrRightModulesObject ] );
+
+#! @Description
+#! The argument is a graded left or right module presentation morphism $a$. We then return a presentation of this
+#! morphism which uses less generators.
+#! @Returns a graded left or right module presentation morphism
+#! @Arguments a
+DeclareOperation( "LessGradedGenerators",
+                  [ IsFpGradedLeftOrRightModulesMorphism ] );
+
+# a function that computes the functor 'LessGenerators' for both left and right presentations
+DeclareGlobalFunction( "FunctorLessGradedGenerators" );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a left 
+#! presentation in FpGradedLeftModules as input and computes a presentation having less generators.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorLessGradedGeneratorsLeft",
+                  IsHomalgGradedRing );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a right 
+#! presentation in FpGradedRightModules as input and computes a presentation having less generators.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorLessGradedGeneratorsRight",
+                  IsHomalgGradedRing );
+
+
+
+
+######################################################
+##
+#! @Section Functor StandardModule for FpGradedModules
+##
+######################################################
+
+#! @Description
+#! The argument is a graded left or right module presentation $M$. We then try to reduce the relations and
+#! thereby return a new presentation - the Standard module.
+#! @Returns a graded left or right module presentation
+#! @Arguments M
+DeclareOperation( "GradedStandardModule",
+                  [ IsFpGradedLeftOrRightModulesObject ] );
+
+#! @Description
+#! The argument is a graded left or right module presentation morphism $a$. We then try to reduce the relations
+#! and thereby return a new presentation, which we term the Standard module morphism.
+#! @Returns a graded left or right module presentation morphism
+#! @Arguments a
+DeclareOperation( "GradedStandardModule",
+                  [ IsFpGradedLeftOrRightModulesMorphism ] );
+
+# a function that computes the functor 'StandardModule' for both left and right presentations
+DeclareGlobalFunction( "FunctorGradedStandardModule" );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a left
+#! presentation in FpGradedLeftModules as input and computes its standard presentation.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorGradedStandardModuleLeft",
+                  IsHomalgGradedRing );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a right
+#! presentation in FpGradedRightModules as input and computes its standard presentation.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorGradedStandardModuleRight",
+                  IsHomalgGradedRing );
+
+
+
+##############################################################
+##
+#! @Section Functor ByASmallerPresentation for FpGradedModules
+##
+##############################################################
+
+#! @Description
+#! The argument is a graded left or right module presentation $M$. We then return a smaller presentation of this
+#! module. This is obtained by first applying 'LessGenerators' and then 'StandardModule'.
+#! @Returns a graded left or right module presentation
+#! @Arguments M
+DeclareOperation( "ByASmallerPresentation",
+                  [ IsFpGradedLeftOrRightModulesObject ] );
+
+#! @Description
+#! The argument is a graded left or right module presentation morphism $a$. We then return a smaller presentation of this
+#! morphism. This is obtained by first applying 'LessGenerators' and then 'StandardModule'.
+#! @Returns a graded left or right module presentation morphism
+#! @Arguments a
+DeclareOperation( "ByASmallerPresentation",
+                  [ IsFpGradedLeftOrRightModulesMorphism ] );
+
+# a function that computes the functor 'LessGenerators' for both left and right presentations
+DeclareGlobalFunction( "FunctorByASmallerPresentation" );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a left
+#! presentation in FpGradedLeftModules as input and computes a smaller presentation. The latter is achieved by
+#! first applying 'LessGenerators' and then acting with 'StandardModule'.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorByASmallerPresentationLeft",
+                  IsHomalgGradedRing );
+
+#! @Description
+#! The argument is a homalg graded ring $R$. The output is functor which takes a right
+#! presentation in FpGradedRightModules as input and computes a smaller presentation. The latter is achieved by
+#! first applying 'LessGenerators' and then acting with 'StandardModule'.
+#! @Returns a functor
+#! @Arguments R
+DeclareAttribute( "FunctorByASmallerPresentationRight",
+                  IsHomalgGradedRing );
diff --git a/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gi b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gi
new file mode 100644
index 0000000000..adf3b685a3
--- /dev/null
+++ b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gi
@@ -0,0 +1,447 @@
+#############################################################################
+##
+## GradedModulePresentationsbyFreyd
+##
+## Copyright 2019,  Martin Bies,       ULB Brussels
+##
+## Functors in the CAP category of graded module presentations for CAP by use of Freyd categories
+##
+#############################################################################
+
+
+
+################################################
+##
+## Section Functor LessGenerators
+##
+################################################
+
+# Here we make use of the function 'SimplerEquivalentMatrix' from MatricesForHomalg, Basic.gi
+# This function accepts a matrix M and produces a simpler matrix M2 from it. Optionally it can compute matrices
+# U, UI, V and VI such that the following holds true:
+# M * V = UI * M2 and U * M = M2 * VI
+# For left-modules (R -M-> G and R2 -M2-> G2) this corresponds to having the following commutative diagrams:
+
+# R --- UI ---> R2               R <--- U ---- R2
+# |             |                |             |
+# M             M2               M             M2
+# |             |                |             |
+# v             v                v             v
+# G --- V ----> G2               G <--- VI --- G2
+
+# and for right-modules to the diagram
+
+# R --- VI ---> R2               R <--- V ---- R2
+# |             |                |             |
+# M             M2               M             M2
+# |             |                |             |
+# v             v                v             v
+# G --- U ----> G2               G <--- UI --- G2
+
+# So if we want to describe the transformation from the origional module into a simpler module we wish to compute
+# left-modules: V (and VI)
+# right-modules: U ( and UI)
+
+# This is achieved from the following code (initialise V, VI, U and UI as HomalgVoidMatrices first)
+# left-modules: SimplerEquivalentMatrix( M, V, VI, "", "" );
+# right-modules: SimplerEquivalentMatrix( M, U, UI, "", "", "" );
+# Note the different number of empty strings in this function - this is crucial!
+
+# That said, we have the following methods
+
+# FIXME: WHY ARE U, UI, V, VI HOMOGENEOUS?
+
+##
+InstallMethod( LessGradedGeneratorsTransformationTripleLeft,
+               [ IsHomalgMatrix ],
+  function( matrix )
+    local V, VI, smaller_matrix;
+
+    # initialise the transformation matrices
+    V := HomalgVoidMatrix( HomalgRing( matrix ) );
+    VI := HomalgVoidMatrix( HomalgRing( matrix ) );
+
+    # compute M' and thereby set values for T and T^{-1}
+    smaller_matrix := SimplerEquivalentMatrix( matrix, V, VI, "", "" );
+
+    # return the triple of desired information
+    return [ smaller_matrix, V, VI ];
+
+end );
+
+##
+InstallMethod( LessGradedGeneratorsTransformationTripleRight,
+               [ IsHomalgMatrix ],
+  function( matrix )
+    local U, UI, smaller_matrix;
+
+    # initialise the transformation matrices
+    U := HomalgVoidMatrix( HomalgRing( matrix ) );
+    UI := HomalgVoidMatrix( HomalgRing( matrix ) );
+
+    # compute M' and thereby set values for T and T^{-1}
+    smaller_matrix := SimplerEquivalentMatrix( matrix, U, UI, "", "", "" );
+
+    # return the triple of desired information
+    return [ smaller_matrix, U, UI ];
+
+end );
+
+
+##
+InstallMethod( LessGradedGenerators,
+               [ IsFpGradedLeftOrRightModulesObject ],
+  function( module_presentation )
+    local TI, range_prime, Mprime;
+
+    # recall that we look at the following diagram
+    # Source( object) --- MappingMatrix M ---> Range( object )
+    #     |                                            |
+    #     ?                                            T
+    #     |                                            |
+    #     v                                            v
+    # Source( object' ) -- MappingMatrix M' ---> Range( object' )
+
+    # now deduce the bottom line
+    if IsFpGradedLeftModulesObject( module_presentation ) then
+
+      TI := LessGradedGeneratorsTransformationTripleLeft(
+                UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) )[ 3 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedRows(
+                                 TI, Range( RelationMorphism( module_presentation ) ) ) );
+      Mprime := ReducedSyzygiesOfRows( TI, UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) );
+      return FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedRows( Mprime, range_prime ) );
+
+    else
+
+      TI := LessGradedGeneratorsTransformationTripleRight(
+                UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) )[ 3 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedCols( 
+                                 TI, Range( RelationMorphism( module_presentation ) ) ) );
+      Mprime := ReducedSyzygiesOfColumns( TI, UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) );
+      return FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedCols( Mprime, range_prime ) );
+
+    fi;
+
+end );
+
+
+##
+InstallMethod( LessGradedGenerators,
+               [ IsFpGradedLeftOrRightModulesMorphism ],
+  function( morphism )
+    local source_transformation_triple, range_transformation_triple, TI, range_prime, Mprime, new_source, new_range, 
+         morphism_matrix, new_morphism_matrix, new_morphism;
+
+    # compute the transformation of source and range
+    if IsFpGradedLeftModulesMorphism( morphism ) then
+      source_transformation_triple := LessGradedGeneratorsTransformationTripleLeft(
+                                        UnderlyingHomalgMatrix( RelationMorphism( Source( morphism ) ) ) );
+      range_transformation_triple := LessGradedGeneratorsTransformationTripleLeft(
+                                        UnderlyingHomalgMatrix( RelationMorphism( Range( morphism ) ) ) );
+    else
+      source_transformation_triple := LessGradedGeneratorsTransformationTripleRight(
+                                        UnderlyingHomalgMatrix( RelationMorphism( Source( morphism ) ) ) );
+      range_transformation_triple := LessGradedGeneratorsTransformationTripleRight(
+                                        UnderlyingHomalgMatrix( RelationMorphism( Range( morphism ) ) ) );
+    fi;
+
+    # and extract the underlying homalg matrix of the morphism
+    morphism_matrix := UnderlyingHomalgMatrix( RelationMorphism( morphism ) );
+
+    # and compute the new mapping matrix
+    if IsFpGradedLeftModulesMorphism( morphism ) then
+
+      # compute the new source
+      TI := source_transformation_triple[ 3 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedRows( TI, Range( RelationMorphism( Source( morphism ) ) ) ) );
+      Mprime := ReducedSyzygiesOfRows( TI, UnderlyingHomalgMatrix( RelationMorphism( Source( morphism ) ) ) );
+      new_source := FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedRows( Mprime, range_prime ) );
+
+      # and the new range
+      TI := range_transformation_triple[ 3 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedRows( TI, Range( RelationMorphism( Range( morphism ) ) ) ) );
+      Mprime := ReducedSyzygiesOfRows( TI, UnderlyingHomalgMatrix( RelationMorphism( Range( morphism ) ) ) );
+      new_range := FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedRows( Mprime, range_prime ) );
+
+      # compute the new mapping matrix
+      new_morphism_matrix := source_transformation_triple[ 3 ] * morphism_matrix * range_transformation_triple[ 2 ];
+
+    else
+
+      # compute the new source
+      TI := source_transformation_triple[ 2 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedCols( TI, Range( RelationMorphism( Source( morphism ) ) ) ) );
+      Mprime := ReducedSyzygiesOfColumns( TI, UnderlyingHomalgMatrix( RelationMorphism( Source( morphism ) ) ) );
+      new_range := FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedCols( Mprime, range_prime ) );
+
+      # and the new range
+      TI := range_transformation_triple[ 2 ];
+      range_prime := Source( DeduceMapFromMatrixAndRangeForGradedCols( TI, Range( RelationMorphism( Range( morphism ) ) ) ) );
+      Mprime := ReducedSyzygiesOfColumns( TI, UnderlyingHomalgMatrix( RelationMorphism( Range( morphism ) ) ) );
+      new_range := FreydCategoryObject( DeduceMapFromMatrixAndRangeForGradedCols( Mprime, range_prime ) );
+
+      # compute the new mapping matrix
+      new_morphism_matrix := range_transformation_triple[ 3 ] * morphism_matrix * source_transformation_triple[ 2 ];
+
+    fi;
+
+    # wrap this information to form morphism datum of the corresponding morphism in the Freyd category
+    new_morphism := FreydCategoryMorphism( Range( RelationMorphism( new_source ) ),
+                                           new_morphism_matrix,
+                                           Range( RelationMorphism( new_range ) ) );
+
+    # and return the Freyd morphism
+    return FreydCategoryMorphism( new_source, new_morphism, new_range );
+
+end );
+
+
+##
+InstallGlobalFunction( FunctorLessGradedGenerators,
+  function( graded_ring, left )
+    local category, functor;
+
+    # first compute the category under consideration
+    if left = true then
+      category := FpGradedLeftModules( graded_ring );
+    else
+      category := FpGradedRightModules( graded_ring );
+    fi;
+
+    # then initialise the functor
+    functor := CapFunctor( Concatenation( "Less generators for ", Name( category ) ), category, category );
+
+    # and add the functor operation on objects
+    AddObjectFunction( functor,
+      function( object )
+
+        return LessGradedGenerators( object );
+
+    end );
+
+    # and on morphisms
+    AddMorphismFunction( functor,
+      function( new_source, morphism, new_range )
+
+        return LessGradedGenerators( morphism );
+
+    end );
+
+    # then return the functor
+    return functor;
+
+end );
+
+##
+InstallMethod( FunctorLessGradedGeneratorsLeft,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorLessGradedGenerators( graded_ring, true );
+
+end );
+
+##
+InstallMethod( FunctorLessGradedGeneratorsRight,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorLessGradedGenerators( graded_ring, false );
+
+end );
+
+
+
+#################################################
+##
+## Section Functor StandardModule for S-fpgrmod
+##
+#################################################
+
+##
+InstallMethod( GradedStandardModule,
+               [ IsFpGradedLeftOrRightModulesObject ],
+  function( module_presentation )
+    local matrix, new_underlying_morphism;
+
+    # compute a new presentation matrix
+    if IsFpGradedLeftModulesObject( module_presentation ) then
+
+      matrix := ReducedBasisOfRowModule( UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) );
+      new_underlying_morphism := DeduceMapFromMatrixAndRangeForGradedRows( matrix, Range( RelationMorphism( module_presentation ) ) );
+
+    else
+
+      matrix := ReducedBasisOfColumnModule( UnderlyingHomalgMatrix( RelationMorphism( module_presentation ) ) );
+      new_underlying_morphism := DeduceMapFromMatrixAndRangeForGradedCols( matrix, Range( RelationMorphism( module_presentation ) ) );
+
+    fi;
+
+    # and return the new object
+    return FreydCategoryObject( new_underlying_morphism );
+
+end );
+
+##
+InstallMethod( GradedStandardModule,
+               [ IsFpGradedLeftOrRightModulesMorphism ],
+  function( morphism )
+    local new_source, new_range, new_underlying_morphism;
+
+    # compute the new underlying morphism
+    new_source := GradedStandardModule( Source( morphism ) );
+    new_range := GradedStandardModule( Range( morphism ) );
+    new_underlying_morphism := FreydCategoryMorphism(
+                                                      Range( RelationMorphism( new_source ) ),
+                                                      UnderlyingHomalgMatrix( RelationMorphism( morphism ) ),
+                                                      Range( RelationMorphism( new_range ) )
+                                                     );
+
+    # and return the corresponding morphism
+    return FreydCategoryMorphism( new_source, new_underlying_morphism, new_range );
+
+end );
+
+##
+InstallGlobalFunction( FunctorGradedStandardModule,
+  function( graded_ring, left )
+    local category, functor;
+
+    # first compute the category under consideration
+    if left = true then
+      category := FpGradedLeftModules( graded_ring );
+    else
+      category := FpGradedRightModules( graded_ring );
+    fi;
+
+    # then initialise the functor
+    functor := CapFunctor( Concatenation( "Graded standard module for ", Name( category ) ), category, category );
+
+    # now define the functor operation on the objects
+    AddObjectFunction( functor,
+      function( object )
+
+        return GradedStandardModule( object );
+
+    end );
+
+    # now define the functor operation on the morphisms
+    AddMorphismFunction( functor,
+      function( new_source, morphism, new_range )
+        local new_underlying_morphism;
+
+        # compute the new underlying morphism
+        new_underlying_morphism := FreydCategoryMorphism(
+                                                      Range( RelationMorphism( new_source ) ),
+                                                      UnderlyingHomalgMatrix( RelationMorphism( morphism ) ),
+                                                      Range( RelationMorphism( new_range ) )
+                                                     );
+
+        # and return the corresponding morphism
+        return FreydCategoryMorphism( new_source, new_underlying_morphism, new_range );
+
+    end );
+
+    # finally return the functor
+    return functor;
+
+end );
+
+##
+InstallMethod( FunctorGradedStandardModuleLeft,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorGradedStandardModule( graded_ring, true );
+
+end );
+
+##
+InstallMethod( FunctorGradedStandardModuleRight,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorGradedStandardModule( graded_ring, false );
+
+end );
+
+
+
+#############################################################
+##
+## Section Functor ByASmallerPresentation for FpGradedModules
+##
+#############################################################
+
+##
+InstallMethod( ByASmallerPresentation,
+               [ IsFpGradedLeftOrRightModulesObject ],
+  function( module_presentation )
+
+    return GradedStandardModule( LessGradedGenerators( module_presentation ) );
+
+end );
+
+##
+InstallMethod( ByASmallerPresentation,
+               [ IsFpGradedLeftOrRightModulesMorphism ],
+  function( morphism )
+
+    return GradedStandardModule( LessGradedGenerators( morphism ) );
+
+end );
+
+##
+InstallGlobalFunction( FunctorByASmallerPresentation,
+  function( graded_ring, left )
+    local category, functor;
+
+    # first compute the category under consideration
+    if left = true then
+      category := FpGradedLeftModules( graded_ring );
+    else
+      category := FpGradedRightModules( graded_ring );
+    fi;
+
+    # then initialise the functor
+    functor := CapFunctor( Concatenation( "ByASmallerPresentation for ", Name( category ) ), category, category );
+
+    # and add the functor operation on objects
+    AddObjectFunction( functor,
+      function( object )
+
+        return ByASmallerPresentation( object );
+
+    end );
+
+    AddMorphismFunction( functor,
+      function( new_source, morphism, new_range )
+
+        return ByASmallerPresentation( morphism );
+
+    end );
+
+    # then return the functor
+    return functor;
+
+end );
+
+##
+InstallMethod( FunctorByASmallerPresentationLeft,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorByASmallerPresentation( graded_ring, true );
+
+end );
+
+
+##
+InstallMethod( FunctorByASmallerPresentationRight,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return FunctorByASmallerPresentation( graded_ring, false );
+
+end );
diff --git a/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gd b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gd
new file mode 100644
index 0000000000..ba08574643
--- /dev/null
+++ b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gd
@@ -0,0 +1,36 @@
+#############################################################################
+##
+## GradedModulePresentationsbyFreyd
+##
+## Copyright 2019,  Martin Bies,       ULB Brussels
+##
+#! @Chapter Natural transformations for FPGradedModules
+##
+#############################################################################
+
+
+####################################################################################
+##
+#! @Section Natural isomorphism from identity functor to the standard module functor
+##
+####################################################################################
+
+# a function that computes the natural isomorphism $1 \Rightarrow \mathrm{StandardModule}$ for both
+# left and right presentations
+DeclareGlobalFunction( "NaturalIsomorphismFromIdentityToGradedStandardModule" );
+
+#! @Description
+#! The argument is a homalg graded ring $S$. The output is the natural morphism from the identity functor
+#! to the left standard module functor.
+#! @Returns a natural transformation $\mathrm{Id} \Rightarrow \mathrm{StandardModuleLeft}$
+#! @Arguments S
+DeclareAttribute( "NaturalIsomorphismFromIdentityToGradedStandardModuleLeft",
+                  IsHomalgGradedRing );
+
+#! @Description
+#! The argument is a homalg ring $S$. The output is the natural morphism from the identity functor
+#! to the right standard module functor.
+#! @Returns a natural transformation $\mathrm{Id} \Rightarrow \mathrm{StandardModuleRight}$
+#! @Arguments S
+DeclareAttribute( "NaturalIsomorphismFromIdentityToGradedStandardModuleRight",
+                  IsHomalgGradedRing );
diff --git a/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gi b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gi
new file mode 100644
index 0000000000..db84dbfe06
--- /dev/null
+++ b/FreydCategoriesForCAP/gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gi
@@ -0,0 +1,80 @@
+#############################################################################
+##
+## GradedModulePresentationsbyFreyd
+##
+## Copyright 2019,  Martin Bies,       ULB Brussels
+##
+## Chapter Natural transformations for FP Graded Modules
+##
+#############################################################################
+
+
+####################################################################################
+##
+##  Section Natural isomorphism from identity functor to the standard module functor
+##
+####################################################################################
+
+# a function that computes the natural isomorphism 1 => StandardModule for both
+# left and right presentations
+InstallGlobalFunction( NaturalIsomorphismFromIdentityToGradedStandardModule,
+  function( graded_ring, left )
+    local category, standard_module_functor, natural_transformation;
+
+    if left = true then
+      category := FpGradedLeftModules( graded_ring );
+      standard_module_functor := FunctorGradedStandardModuleLeft( graded_ring );
+    else
+      category := FpGradedRightModules( graded_ring );
+      standard_module_functor := FunctorGradedStandardModuleRight( graded_ring );
+    fi;
+
+    # initialise the natural_transformation
+    natural_transformation := NaturalTransformation( Concatenation( "Natural isomorphism from Id to ",
+                                                     Name( standard_module_functor ) ),
+                                                     IdentityMorphism( AsCatObject( category ) ),
+                                                     standard_module_functor
+                                                    );
+
+    # add component of natural_transformation over object
+    AddNaturalTransformationFunction( natural_transformation,
+      function( id_object, object, standard_object )
+        local matrix, underlying_morphism;
+
+        matrix := HomalgIdentityMatrix( Rank( Range( RelationMorphism( id_object ) ) ), graded_ring );
+
+        underlying_morphism := GradedRowOrColumnMorphism(
+                                                      Range( UnderlyingMorphism( id_object ) ),
+                                                      matrix,
+                                                      Range( UnderlyingMorphism( standard_object ) )
+                                                     );
+
+        return FreydCategoryMorphism( id_object, underlying_morphism, standard_object );
+
+    end );
+
+    # inform CAP that this is a natural isomorphism
+    SetIsIsomorphism( natural_transformation, true );
+
+    # and finally return this transformation
+    return natural_transformation;
+
+end );
+
+# natural isomorphism 1 => Standard module for left presentations
+InstallMethod( NaturalIsomorphismFromIdentityToGradedStandardModuleLeft,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return NaturalIsomorphismFromIdentityToGradedStandardModule( graded_ring, true );
+
+end );
+
+# natural isomorphism 1 => Standard module for right presentations
+InstallMethod( NaturalIsomorphismFromIdentityToGradedStandardModuleRight,
+               [ IsHomalgGradedRing ],
+  function( graded_ring )
+
+    return NaturalIsomorphismFromIdentityToGradedStandardModule( graded_ring, false );
+
+end );
diff --git a/FreydCategoriesForCAP/init.g b/FreydCategoriesForCAP/init.g
index df3bee4a80..ef3820a174 100644
--- a/FreydCategoriesForCAP/init.g
+++ b/FreydCategoriesForCAP/init.g
@@ -30,3 +30,7 @@ ReadPackage( "FreydCategoriesForCAP", "gap/AdelmanCategory.gd" );
 ReadPackage( "FreydCategoriesForCAP", "gap/QuiverRows.gd" );
 
 ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreyd.gd" );
+
+ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gd" );
+
+ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gd" );
diff --git a/FreydCategoriesForCAP/read.g b/FreydCategoriesForCAP/read.g
index ef2089f2c2..2fc945eec2 100644
--- a/FreydCategoriesForCAP/read.g
+++ b/FreydCategoriesForCAP/read.g
@@ -31,3 +31,7 @@ ReadPackage( "FreydCategoriesForCAP", "gap/AdelmanCategory.gi" );
 ReadPackage( "FreydCategoriesForCAP", "gap/QuiverRows.gi" );
 
 ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreyd.gi" );
+
+ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydFunctors.gi" );
+
+ReadPackage( "FreydCategoriesForCAP", "gap/GradedModulePresentationsByFreyd/GradedModulePresentationsByFreydNaturalTransformations.gi" );