gap> ZZZ := HomalgRingOfIntegersInSingular();;
gap> fpres := LeftPresentations( ZZZ );;
gap> M1 := AsLeftPresentation( fpres, HomalgMatrix( [ [ "2" ] ], ZZZ ) );;
gap> M2 := AsLeftPresentation( fpres, HomalgMatrix( [ [ "3" ] ], ZZZ ) );;
gap> M3 := AsLeftPresentation( fpres, HomalgMatrix( [ [ "4" ] ], ZZZ ) );;
gap> M := DirectSum( M1, M2, M3 );;
gap> Display( Annihilator( M ) );
12

A monomorphism in Category of left presentations of Z
gap> fpres := RightPresentations( ZZZ );;
gap> M1 := AsRightPresentation( fpres, HomalgMatrix( [ [ "2" ] ], ZZZ ) );;
gap> M2 := AsRightPresentation( fpres, HomalgMatrix( [ [ "3" ] ], ZZZ ) );;
gap> M3 := AsRightPresentation( fpres, HomalgMatrix( [ [ "4" ] ], ZZZ ) );;
gap> M := DirectSum( M1, M2, M3 );;
gap> Display( Annihilator( M ) );
12

A monomorphism in Category of right presentations of Z

gap> Q := HomalgFieldOfRationalsInSingular();;
gap> R := Q * "x,y";
Q[x,y]
gap> fpres := LeftPresentations( R );;
gap> F := AsLeftPresentation( fpres, HomalgMatrix( [ [ 0 ] ], R ) );
<An object in Category of left presentations of Q[x,y]>
gap> I1 := AsLeftPresentation( fpres, HomalgMatrix( [ [ "x" ] ], R ) );;
gap> I2 := AsLeftPresentation( fpres, HomalgMatrix( [ [ "y" ] ], R ) );;
gap> Display( I1 );
x

An object in Category of left presentations of Q[x,y]
gap> Display( I2 );
y

An object in Category of left presentations of Q[x,y]
gap> eps1 := PresentationMorphism( F, HomalgMatrix( [ [ 1 ] ], R ), I1 );
<A morphism in Category of left presentations of Q[x,y]>
gap> eps2 := PresentationMorphism( F, HomalgMatrix( [ [ 1 ] ], R ), I2 );
<A morphism in Category of left presentations of Q[x,y]>
gap> kernelemb1 := KernelEmbedding( eps1 );
<A monomorphism in Category of left presentations of Q[x,y]>
gap> kernelemb2 := KernelEmbedding( eps2 );
<A monomorphism in Category of left presentations of Q[x,y]>
gap> P := FiberProduct( kernelemb1, kernelemb2 );;
gap> Display( P );
(an empty 0 x 1 matrix)

An object in Category of left presentations of Q[x,y]
gap> pi1 := ProjectionInFactorOfFiberProduct( [ kernelemb1, kernelemb2 ], 1 );
<A monomorphism in Category of left presentations of Q[x,y]>
gap> composite := PreCompose( pi1, kernelemb1 );
<A monomorphism in Category of left presentations of Q[x,y]>
gap> Display( composite );
x*y

A monomorphism in Category of left presentations of Q[x,y]

gap> Q := HomalgFieldOfRationalsInSingular();;
gap> R := Q * "x,y,z";;
gap> fpres := LeftPresentations( R );;
gap> M := HomalgMatrix( [ [ "x" ], [ "y" ], [ "z" ] ], 3, 1, R );;
gap> Ml := AsLeftPresentation( fpres, M );;
gap> eps := CoverByFreeModule( Ml );;
gap> iota1 := KernelEmbedding( eps );;
gap> Display( iota1 );
x,
y,
z 

A monomorphism in Category of left presentations of Q[x,y,z]
gap> Display( Source( iota1 ) );
0, -z,y,
-z,0, x,
-y,x, 0 

An object in Category of left presentations of Q[x,y,z]
gap> pi1 := CoverByFreeModule( Source( iota1 ) );;
gap> d1 := PreCompose( pi1, iota1 );;
gap> Display( d1 );
x,
y,
z 

A morphism in Category of left presentations of Q[x,y,z]
gap> iota2 := KernelEmbedding( d1 );;
gap> Display( iota2 );
0, -z,y,
-z,0, x,
-y,x, 0 

A monomorphism in Category of left presentations of Q[x,y,z]
gap> Display( Source( iota2 ) );;
x,-y,z

An object in Category of left presentations of Q[x,y,z]
gap> pi2 := CoverByFreeModule( Source( iota2 ) );;
gap> d2 := PreCompose( pi2, iota2 );;
gap> Display( d2 );
0, -z,y,
-z,0, x,
-y,x, 0 

A morphism in Category of left presentations of Q[x,y,z]
gap> iota3 := KernelEmbedding( d2 );;
gap> Display( iota3 );
x,-y,z

A monomorphism in Category of left presentations of Q[x,y,z]
gap> Display( Source( iota3 ) );
(an empty 0 x 1 matrix)

An object in Category of left presentations of Q[x,y,z]
gap> pi3 := CoverByFreeModule( Source( iota3 ) );;
gap> d3 := PreCompose( pi3, iota3 );;
gap> Display( d3 );
x,-y,z

A morphism in Category of left presentations of Q[x,y,z]
gap> N := HomalgMatrix( [ [ "x" ] ], 1, 1, R );;
gap> Nl := AsLeftPresentation( fpres, N );;
gap> d2Nl := TensorProductOnMorphisms( d2, IdentityMorphism( Nl ) );;
gap> d1Nl := TensorProductOnMorphisms( d1, IdentityMorphism( Nl ) );;
gap> IsZero( PreCompose( d2Nl, d1Nl ) );
true
gap> cycles := KernelEmbedding( d1Nl );;
gap> boundaries := ImageEmbedding( d2Nl );;
gap> boundaries_in_cyles := LiftAlongMonomorphism( cycles, boundaries );;
gap> homology := CokernelObject( boundaries_in_cyles );;
gap> LessGenFunctor := FunctorLessGeneratorsLeft( fpres );;
gap> homology := ApplyFunctor( LessGenFunctor, homology );;
gap> StdBasisFunctor := FunctorStandardModuleLeft( fpres );;
gap> homology := ApplyFunctor( StdBasisFunctor, homology );;
gap> Display( homology );
z,
y,
x 

An object in Category of left presentations of Q[x,y,z]

gap> ZZZ := HomalgRingOfIntegers();;
gap> fpres := LeftPresentations( ZZZ );;
gap> Ml := AsLeftPresentation( fpres, HomalgMatrix( [ [ 2 ] ], 1, 1, ZZZ ) );
<An object in Category of left presentations of Z>
gap> Nl := AsLeftPresentation( fpres, HomalgMatrix( [ [ 3 ] ], 1, 1, ZZZ ) );
<An object in Category of left presentations of Z>
gap> Tl := TensorProductOnObjects( Ml, Nl );
<An object in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( Tl ) );
[ [  3 ],
  [  2 ] ]
gap> IsZeroForObjects( Tl );
true
gap> Bl := Braiding( DirectSum( Ml, Nl ), DirectSum( Ml, Ml ) );
<A morphism in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( Bl ) );
[ [  1,  0,  0,  0 ],
  [  0,  0,  1,  0 ],
  [  0,  1,  0,  0 ],
  [  0,  0,  0,  1 ] ]
gap> IsWellDefined( Bl );
true
gap> Ul := TensorUnit( CapCategory( Ml ) );
<An object in Category of left presentations of Z>
gap> IntHoml := InternalHomOnObjects( DirectSum( Ml, Ul ), Nl );
<An object in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( IntHoml ) );
[ [  1,  2 ],
  [  0,  3 ] ]
gap> generator_l1 := StandardGeneratorMorphism( IntHoml, 1 );
<A morphism in Category of left presentations of Z>
gap> morphism_l1 := LambdaElimination( DirectSum( Ml, Ul ), Nl, generator_l1 );
<A morphism in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( morphism_l1 ) );
[ [  -3 ],
  [   2 ] ]
gap> generator_l2 := StandardGeneratorMorphism( IntHoml, 2 );
<A morphism in Category of left presentations of Z>
gap> morphism_l2 := LambdaElimination( DirectSum( Ml, Ul ), Nl, generator_l2 );
<A morphism in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( morphism_l2 ) );
[ [   0 ],
  [  -1 ] ]
gap> IsEqualForMorphisms( LambdaIntroduction( morphism_l1 ), generator_l1 );
false
gap> IsCongruentForMorphisms( LambdaIntroduction( morphism_l1 ), generator_l1 );
true
gap> IsEqualForMorphisms( LambdaIntroduction( morphism_l2 ), generator_l2 );
false
gap> IsCongruentForMorphisms( LambdaIntroduction( morphism_l2 ), generator_l2 );
true
gap> fpres := RightPresentations( ZZZ );;
gap> Mr := AsRightPresentation( fpres, HomalgMatrix( [ [ 2 ] ], 1, 1, ZZZ ) );
<An object in Category of right presentations of Z>
gap> Nr := AsRightPresentation( fpres, HomalgMatrix( [ [ 3 ] ], 1, 1, ZZZ ) );
<An object in Category of right presentations of Z>
gap> Tr := TensorProductOnObjects( Mr, Nr );
<An object in Category of right presentations of Z>
gap> Display( UnderlyingMatrix( Tr ) );
[ [  3,  2 ] ]
gap> IsZeroForObjects( Tr );
true
gap> Br := Braiding( DirectSum( Mr, Nr ), DirectSum( Mr, Mr ) );
<A morphism in Category of right presentations of Z>
gap> Display( UnderlyingMatrix( Br ) );
[ [  1,  0,  0,  0 ],
  [  0,  0,  1,  0 ],
  [  0,  1,  0,  0 ],
  [  0,  0,  0,  1 ] ]
gap> IsWellDefined( Br );
true
gap> Ur := TensorUnit( CapCategory( Mr ) );
<An object in Category of right presentations of Z>
gap> IntHomr := InternalHomOnObjects( DirectSum( Mr, Ur ), Nr );
<An object in Category of right presentations of Z>
gap> Display( UnderlyingMatrix( IntHomr ) );
[ [  1,  0 ],
  [  2,  3 ] ]
gap> generator_r1 := StandardGeneratorMorphism( IntHomr, 1 );
<A morphism in Category of right presentations of Z>
gap> morphism_r1 := LambdaElimination( DirectSum( Mr, Ur ), Nr, generator_r1 );
<A morphism in Category of right presentations of Z>
gap> Display( UnderlyingMatrix( morphism_r1 ) );
[ [  -3,   2 ] ]
gap> generator_r2 := StandardGeneratorMorphism( IntHoml, 2 );
<A morphism in Category of left presentations of Z>
gap> morphism_r2 := LambdaElimination( DirectSum( Ml, Ul ), Nl, generator_r2 );
<A morphism in Category of left presentations of Z>
gap> Display( UnderlyingMatrix( morphism_r2 ) );
[ [   0 ],
  [  -1 ] ]
gap> IsEqualForMorphisms( LambdaIntroduction( morphism_r1 ), generator_r1 );
false
gap> IsCongruentForMorphisms( LambdaIntroduction( morphism_r1 ), generator_r1 );
true
gap> IsEqualForMorphisms( LambdaIntroduction( morphism_r2 ), generator_r2 );
false
gap> IsCongruentForMorphisms( LambdaIntroduction( morphism_r2 ), generator_r2 );
true

gap> R := HomalgRingOfIntegers( );;
gap> fpres := LeftPresentations( R );;
gap> M := AsLeftPresentation( fpres, HomalgMatrix( [ [ 2 ] ], 1, 1, R ) );
<An object in Category of left presentations of Z>
gap> N := AsLeftPresentation( fpres, HomalgMatrix( [ [ 3 ] ], 1, 1, R ) );
<An object in Category of left presentations of Z>
gap> T := TensorProductOnObjects( M, N );
<An object in Category of left presentations of Z>
gap> Display( T );
[ [  3 ],
  [  2 ] ]

An object in Category of left presentations of Z
gap> IsZero( T );
true
gap> H := InternalHomOnObjects( DirectSum( M, M ), DirectSum( M, N ) );
<An object in Category of left presentations of Z>
gap> Display( H );
[ [   0,   0,   0,  -2 ],
  [   1,   2,   0,   0 ],
  [   0,   2,   2,   0 ],
  [   2,   3,   0,   2 ] ]

An object in Category of left presentations of Z
gap> alpha := StandardGeneratorMorphism( H, 3 );
<A morphism in Category of left presentations of Z>
gap> l := LambdaElimination( DirectSum( M, M ), DirectSum( M, N ), alpha );
<A morphism in Category of left presentations of Z>
gap> IsZero( l );
false
gap> Display( l );
[ [  -2,   6 ],
  [  -1,  -3 ] ]

A morphism in Category of left presentations of Z

gap> Q := HomalgFieldOfRationalsInSingular();;
gap> R := Q * "x";;
gap> F := FreeLeftPresentation( 2, Q );;
gap> HasIsProjective( F ) and IsProjective( F );
true
gap> G := FreeRightPresentation( 2, Q );;
gap> HasIsProjective( G ) and IsProjective( G );
true
gap> M := AsLeftPresentation( HomalgMatrix( "[ x, x ]", 1, 2, R ) );;
gap> IsProjective( M );
false
gap> N := AsLeftPresentation( HomalgMatrix( "[ 1, x ]", 1, 2, R ) );;
gap> IsProjective( N );
true