GAP (FreydCategoriesForCAP) - Chapter 12: Examples and Tests

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> T := TerminalCategoryWithMultipleObjects( );
TerminalCategoryWithMultipleObjects( )
gap> A := "A" / T;
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> B := "B" / T;
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> AT := AdditiveClosure( T );
AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )
gap> ABAA := [ A, B, A, A ] / AT;
<An object in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by 4 underlying objects>
gap> BAB := [ B, A, B ] / AT;
<An object in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by 3 underlying objects>
gap> AB := [ A, B ] / AT;
<An object in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by 2 underlying objects>
gap> mor_AB := MorphismConstructor( A, "A -> B", B );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> mor_BA := MorphismConstructor( B, "B -> A", A );
<A zero, isomorphism in TerminalCategoryWithMultipleObjects( )>
gap> id_A := IdentityMorphism( A );
<A zero, identity morphism in TerminalCategoryWithMultipleObjects( )>
gap> id_B := IdentityMorphism( B );
<A zero, identity morphism in TerminalCategoryWithMultipleObjects( )>
gap> alpha := MorphismConstructor( ABAA,
>   [ [ mor_AB, id_A, mor_AB ],
>     [ id_B, mor_BA, id_B ],
>     [ mor_AB, id_A, mor_AB ],
>     [ mor_AB, id_A, mor_AB ] ],
>     BAB );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 4 x 3 matrix of underlying morphisms>
gap> IsWellDefined( alpha );
true
gap> alpha2 := TensorProduct( alpha, alpha );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 16 x 9 matrix of underlying morphisms>
gap> IsWellDefined( alpha2 );
true
gap> IsIsomorphism( alpha2 );
true
gap> left := LeftUnitor( ABAA );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 4 x 4 matrix of underlying morphisms>
gap> IsWellDefined( left );
true
gap> left_inv := LeftUnitorInverse( ABAA );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 4 x 4 matrix of underlying morphisms>
gap> PreCompose( left, left_inv ) = IdentityMorphism( Source( left ) );
true
gap> PreCompose( left_inv, left ) = IdentityMorphism( Range( left ) );
true
gap> right := RightUnitor( BAB );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 3 x 3 matrix of underlying morphisms>
gap> IsWellDefined( right );
true
gap> right_inv := RightUnitorInverse( BAB );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 3 x 3 matrix of underlying morphisms>
gap> PreCompose( right, right_inv ) = IdentityMorphism( Source( right ) );
true
gap> PreCompose( right_inv, right ) = IdentityMorphism( Range( right ) );
true
gap> aslr := AssociatorLeftToRight( AB, BAB, AB );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 12 x 12 matrix of underlying morphisms>
gap> IsWellDefined( aslr );
true
gap> asrl := AssociatorRightToLeft( AB, BAB, AB );
<A morphism in AdditiveClosure( TerminalCategoryWithMultipleObjects( ) )\
 defined by a 12 x 12 matrix of underlying morphisms>
gap> PreCompose( aslr, asrl ) = IdentityMorphism( Source( aslr ) );
true
gap> PreCompose( asrl, aslr ) = IdentityMorphism( Range( aslr ) );
true

12.2 Adelman category basics for category of rows

gap> R := HomalgRingOfIntegers();;
gap> rows := CategoryOfRows( R );;
gap> adelman := AdelmanCategory( rows );;
gap> obj1 := CategoryOfRowsObject( 1, rows );;
gap> obj2 := CategoryOfRowsObject( 2, rows );;
gap> id := IdentityMorphism( obj2 );;
gap> alpha := CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );;
gap> beta := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );;
gap> gamma := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );;
gap> obj1_a := AsAdelmanCategoryObject( obj1 );;
gap> obj2_a := AsAdelmanCategoryObject( obj2 );;
gap> m := AsAdelmanCategoryMorphism( beta );;
gap> n := AsAdelmanCategoryMorphism( gamma );;
gap> IsWellDefined( m );
true
gap> # backwards compatibility
> IsIdenticalObj( MorphismDatum( m ), beta );
true
gap> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) );
false
gap> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) );
true
gap> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
>                          PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
>                         );
true
gap> d := [ obj1_a, obj2_a ];;
gap> pi1 := ProjectionInFactorOfDirectSum( d, 1 );;
gap> pi2 := ProjectionInFactorOfDirectSum( d, 2 );;
gap> id := IdentityMorphism( DirectSum( d ) );;
gap> iota1 := InjectionOfCofactorOfDirectSum( d, 1 );;
gap> iota2 := InjectionOfCofactorOfDirectSum( d, 2 );;
gap> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id );
true
gap> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id );
true
gap> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id );
true
gap> c := CokernelProjection( m );;
gap> c2 := CokernelProjection( c );;
gap> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) );
true
gap> IsWellDefined( CokernelProjection( m ) );
true
gap> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) );
true
gap> k := KernelEmbedding( c );;
gap> IsZeroForMorphisms( PreCompose( k, c ) );
true
gap> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) );
true

12.3 Adelman category basics for category of columns

gap> R := HomalgRingOfIntegers();;
gap> cols := CategoryOfColumns( R );;
gap> adelman := AdelmanCategory( cols );;
gap> obj1 := CategoryOfColumnsObject( 1, cols );;
gap> obj2 := CategoryOfColumnsObject( 2, cols );;
gap> id := IdentityMorphism( obj2 );;
gap> alpha := CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 2, 1, R ), obj2 );;
gap> beta := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 2, 4 ] ], 2, 2, R ), obj2 );;
gap> gamma := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );;
gap> obj1_a := AsAdelmanCategoryObject( obj1 );;
gap> obj2_a := AsAdelmanCategoryObject( obj2 );;
gap> m := AsAdelmanCategoryMorphism( beta );;
gap> n := AsAdelmanCategoryMorphism( gamma );;
gap> IsWellDefined( m );
true
gap> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) );
false
gap> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) );
true
gap> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
>                          PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
>                         );
true
gap> d := [ obj1_a, obj2_a ];;
gap> pi1 := ProjectionInFactorOfDirectSum( d, 1 );;
gap> pi2 := ProjectionInFactorOfDirectSum( d, 2 );;
gap> id := IdentityMorphism( DirectSum( d ) );;
gap> iota1 := InjectionOfCofactorOfDirectSum( d, 1 );;
gap> iota2 := InjectionOfCofactorOfDirectSum( d, 2 );;
gap> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id );
true
gap> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id );
true
gap> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id );
true
gap> c := CokernelProjection( m );;
gap> c2 := CokernelProjection( c );;
gap> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) );
true
gap> IsWellDefined( CokernelProjection( m ) );
true
gap> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) );
true
gap> k := KernelEmbedding( c );;
gap> IsZeroForMorphisms( PreCompose( k, c ) );
true
gap> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) );
true

12.4 Basics based on category of rows

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> LoadPackage( "RingsForHomalg", false );
true
gap> R := HomalgRingOfIntegers();;
gap> cat := CategoryOfRows( R );;
gap> obj1 := CategoryOfRowsObject( 1, cat );;
gap> obj2 := CategoryOfRowsObject( 2, cat );;
gap> IsIsomorphicForObjects( obj1, obj2 );
false
gap> IsIsomorphicForObjects( obj2, obj2 );
true
gap> IsIsomorphism( SomeIsomorphismBetweenObjects( obj2, obj2 ) );
true
gap> id := IdentityMorphism( obj2 );;
gap> alpha := CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );;
gap> beta := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );;
gap> comp := PreCompose( alpha, beta );;
gap> IsZeroForMorphisms( comp );;
gap> zero := ZeroMorphism( obj1, obj2 );;
gap> IsZeroForMorphisms( zero );;
gap> ZeroObject( cat );;
gap> UniversalMorphismIntoZeroObject( obj2 );;
gap> UniversalMorphismFromZeroObject( obj1 );;
gap> IsCongruentForMorphisms(
>     SumOfMorphisms( obj1, [ alpha, alpha, alpha ], obj2 ),
>     AdditionForMorphisms( alpha, AdditionForMorphisms( alpha, alpha ) )
> );
true
gap> IsCongruentForMorphisms(
>     SumOfMorphisms( obj1, [ ], obj2 ),
>     ZeroMorphism( obj1, obj2 )
> );
true
gap> DirectSum( obj1, obj2 );;
gap> DirectSumFunctorial( [ alpha, beta, id ] );;
gap> proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );;
gap> IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismFromCoproduct( proj, [ obj2, obj1, obj2 ], 3 ) );
true
gap> UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );;
gap> inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );;
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectProduct( inj, [ obj2, obj2, obj1 ], 3 ) );
true
gap> gamma := CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );;
gap> IsColiftable( beta, gamma );
true
gap> IsColiftable( gamma, beta );
false
gap> ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );;
gap> ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );;
gap> lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );;
gap> lift_arg_2 := gamma + gamma;;
gap> IsLiftable( lift_arg_1, lift_arg_2 );;
gap> Lift( lift_arg_1, lift_arg_2 );;
gap> pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );;
gap> pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );;
gap> IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );;
gap> inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );;
gap> inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );;
gap> IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );;
gap> WeakKernelLift( WeakCokernelProjection( gamma ), gamma );;
gap> pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );;
gap> pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );;
gap> UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );;
gap> ## Freyd categories
> freyd := FreydCategory( cat );;
gap> IsAbelianCategory( freyd );;
gap> obj_gamma := FreydCategoryObject( gamma );;
gap> u := RandomMorphismWithFixedSource( obj_gamma, [ [5], [5] ] );;
gap> IsWellDefined( u ) and IsEqualForObjects( Source(u), obj_gamma );
true
gap> u := RandomMorphismWithFixedSource( obj_gamma, 5 );;
gap> IsWellDefined( u ) and IsEqualForObjects( Source(u), obj_gamma );
true
gap> u := RandomMorphismWithFixedRange( obj_gamma, [ [5], [5] ] );;
gap> IsWellDefined( u ) and IsEqualForObjects( Range(u), obj_gamma );
true
gap> u := RandomMorphismWithFixedRange( obj_gamma, 5 );;
gap> IsWellDefined( u ) and IsEqualForObjects( Range(u), obj_gamma );
true
gap> obj_delta := RandomObject( freyd, [[10],[10],[10]] );;
gap> obj_delta := RandomObject( freyd, 10 );;
gap> u := RandomMorphismWithFixedSourceAndRange( obj_gamma, obj_delta, [ 5 ] );;
gap> IsWellDefined( u );
true
gap> IsEqualForObjects( Source(u), obj_gamma ) and IsEqualForObjects( Range(u), obj_delta );
true
gap> u := RandomMorphismWithFixedSourceAndRange( obj_gamma, obj_delta, 5 );;
gap> IsWellDefined( u );
true
gap> IsEqualForObjects( Source(u), obj_gamma ) and IsEqualForObjects( Range(u), obj_delta );
true
gap> IsWellDefined( RandomMorphism( freyd, 5 ) );
true
gap> IsWellDefined( RandomMorphism( freyd, [[[5],[5],[5]],[[5],[5],[5]],[1]] ) );
true
gap> f := FreydCategoryMorphism( obj_gamma, gamma, obj_gamma );;
gap> witness := MorphismWitness( f );;
gap> g := FreydCategoryMorphism( obj_gamma, ZeroMorphism( obj2, obj2 ), obj_gamma );;
gap> IsCongruentForMorphisms( f, g );;
gap> c := PreCompose( f, f );;
gap> s := g + g;;
gap> a := CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 2 ] ], 1, 1, R ), obj1 );;
gap> Z2 := FreydCategoryObject( a );;
gap> id := IdentityMorphism( Z2 );;
gap> z := id + id + id;;
gap> d := DirectSumFunctorial( [ z, z, z ] );;
gap> pr2 := ProjectionInFactorOfDirectSum( [ Z2, Z2, Z2 ], 2 );;
gap> pr3 := ProjectionInFactorOfDirectSum( [ Z2, Z2, Z2 ], 3 );;
gap> UniversalMorphismIntoDirectSum( [ pr3, pr2 ] );;
gap> inj1 := InjectionOfCofactorOfDirectSum( [ Z2, Z2, Z2 ], 1 );;
gap> inj2 := InjectionOfCofactorOfDirectSum( [ Z2, Z2, Z2 ], 2 );;
gap> UniversalMorphismFromDirectSum( [ inj2, inj1 ] );;
gap> ZFree := obj1/freyd;;
gap> id := IdentityMorphism( ZFree );;
gap> z := id + id;;
gap> CokernelProjection( z );;
gap> CokernelColift( z, CokernelProjection( z ) );;
gap> UniversalMorphismFromZeroObjectWithGivenZeroObject( obj_gamma, ZeroObject( freyd ) );;
gap> MultiplyWithElementOfCommutativeRingForMorphisms( 2 / R, f );;
gap> S := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> Rows_S := CategoryOfRows( S );;
gap> S3 := CategoryOfRowsObject( 3, Rows_S );;
gap> S1 := CategoryOfRowsObject( 1, Rows_S );;
gap> mor := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,y,z]", 3, 1, S ), S1 );;
gap> biased_w := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );;
gap> biased_h := CategoryOfRowsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );;
gap> BiasedWeakFiberProduct( biased_h, biased_w );;
gap> ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );;
gap> IsCongruentForMorphisms(
>    PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ),
>    biased_h
> );
true
gap> IsCongruentForMorphisms(
>   PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )),
>   biased_h
> );
true
gap> k := FreydCategoryObject( mor );;
gap> w := EpimorphismFromSomeProjectiveObjectForKernelObject( UniversalMorphismIntoZeroObject( k ) );;
gap> k := KernelEmbedding( w );;
gap> ColiftAlongEpimorphism( CokernelProjection( k ), CokernelProjection( k ) );;
gap> ## Homomorphism structures
> a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );;
gap> IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );;
gap> a := ZeroObjectFunctorial( cat );;
gap> IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );;
gap> Z4 := FreydCategoryObject( AsCategoryOfRowsMorphism( HomalgMatrix( "[4]", 1, 1, R ), cat ) );;
gap> Z3 := FreydCategoryObject( AsCategoryOfRowsMorphism( HomalgMatrix( "[3]", 1, 1, R ), cat ) );;
gap> HomomorphismStructureOnObjects( Z4, Z2 );;
gap> HomomorphismStructureOnObjects( Z4, Z4 );;
gap> HomomorphismStructureOnObjects( Z2, Z4 );;
gap> HomomorphismStructureOnObjects( Z3, Z4 );;
gap> HomomorphismStructureOnMorphisms( IdentityMorphism( DirectSum( Z4, Z2, Z3 ) ), -IdentityMorphism( DirectSum( Z4, Z3 ) ) );;
gap> ## Lifts
> S2 := CategoryOfRowsObject( 2, Rows_S );;
gap> S4 := CategoryOfRowsObject( 4, Rows_S );;
gap> S1_freyd := AsFreydCategoryObject( S1 );;
gap> S2_freyd := AsFreydCategoryObject( S2 );;
gap> S3_freyd := AsFreydCategoryObject( S3 );;
gap> S4_freyd := AsFreydCategoryObject( S4 );;
gap> lift := FreydCategoryMorphism( S1_freyd, CategoryOfRowsMorphism( S1, HomalgMatrix( "[x]", 1, 1, S ), S1 ), S1_freyd );;
gap> gamma := FreydCategoryMorphism( S1_freyd, CategoryOfRowsMorphism( S1, HomalgMatrix( "[y]", 1,1, S ), S1 ), S1_freyd );;
gap> alpha := PreCompose( lift, gamma );;
gap> IsLiftable( alpha, gamma );
true
gap> Lift( alpha, gamma );;
gap> IsColiftable( lift, alpha );
true
gap> IsCongruentForMorphisms( PreCompose( lift, Colift( lift, alpha ) ), alpha );
true
gap> lift := FreydCategoryMorphism( S2_freyd, CategoryOfRowsMorphism( S2, HomalgMatrix( "[x,y,z,x^2,1,z+1]", 2, 3, S ), S3 ), S3_freyd );;
gap> gamma := FreydCategoryMorphism( S3_freyd, CategoryOfRowsMorphism( S3, HomalgMatrix( "[x,y,z,z+1, x^2,y^2,z^2,z^2+1, x^3,y^3,z^3,z^3+1]", 3,4, S ), S4 ), S4_freyd );;
gap> alpha := PreCompose( lift, gamma );;
gap> Lift( alpha, gamma );;
gap> Colift( lift, alpha );;
gap> IsCongruentForMorphisms( PreCompose( lift, Colift( lift, alpha ) ), alpha );;
gap> interpretation := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );;
gap> IsCongruentForMorphisms( gamma,
> InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( gamma ), Range( gamma ), interpretation ) );;
gap> ## Opposite
> HomomorphismStructureOnObjects( Opposite( Z4 ), Opposite( Z2 ) );;
gap> HomomorphismStructureOnObjects( Z2, Z4 );;
gap> interpretation := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( Opposite( gamma ) );;
gap> IsCongruentForMorphisms( Opposite( gamma ),
> InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( Opposite( gamma ) ), Range( Opposite( gamma ) ), interpretation ) );
true

12.5 Basics based on category of columns

gap> R := HomalgRingOfIntegers();;
gap> cat := CategoryOfColumns( R );;
gap> obj1 := CategoryOfColumnsObject( 1, cat );;
gap> obj2 := CategoryOfColumnsObject( 2, cat );;
gap> id := IdentityMorphism( obj2 );;
gap> alpha := CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 1, 2, R ), obj2 );;
gap> beta := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );;
gap> comp := PreCompose( alpha, beta );;
gap> IsZeroForMorphisms( comp );;
gap> zero := ZeroMorphism( obj1, obj2 );;
gap> IsZeroForMorphisms( zero );;
gap> ZeroObject( cat );;
gap> UniversalMorphismIntoZeroObject( obj2 );;
gap> UniversalMorphismFromZeroObject( obj1 );;
gap> DirectSum( obj1, obj2 );;
gap> DirectSumFunctorial( [ alpha, beta, id ] );;
gap> proj := ProjectionInFactorOfDirectSum( [ obj2, obj1, obj2 ], 2 );;
gap> IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismFromDirectSum( proj, [ obj2, obj1, obj2 ], 3 ) );
true
gap> UniversalMorphismIntoDirectSum( [ alpha, alpha, alpha ] );;
gap> inj := InjectionOfCofactorOfDirectSum( [ obj2, obj2, obj1 ], 2 );;
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 1 ) );
true
gap> IsOne( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 2 ) );
true
gap> IsZeroForMorphisms( ComponentOfMorphismIntoDirectSum( inj, [ obj2, obj2, obj1 ], 3 ) );
true
gap> gamma := CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 1 ], [ 1, 1 ] ], 2, 2, R ), obj2 );;
gap> IsColiftable( beta, gamma );
false
gap> IsColiftable( gamma, beta );
false
gap> ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma );;
gap> ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, ZeroMorphism( Range( gamma ), Range( gamma ) ) );;
gap> lift_arg_1 := PreCompose( ProjectionInFirstFactorOfWeakBiFiberProduct( gamma, gamma + gamma ), gamma );;
gap> lift_arg_2 := gamma + gamma;;
gap> IsLiftable( lift_arg_1, lift_arg_2 );;
gap> Lift( lift_arg_1, lift_arg_2 );;
gap> pi1 := ProjectionInFirstFactorOfWeakBiFiberProduct( alpha, beta );;
gap> pi2 := ProjectionInSecondFactorOfWeakBiFiberProduct( alpha, beta );;
gap> IsEqualForMorphisms( PreCompose( pi1, alpha ), PreCompose( pi2, beta ) );;
gap> inj1 := InjectionOfFirstCofactorOfWeakBiPushout( gamma + gamma, gamma );;
gap> inj2 := InjectionOfSecondCofactorOfWeakBiPushout( gamma + gamma, gamma );;
gap> IsEqualForMorphisms( PreCompose( gamma + gamma, inj1 ), PreCompose( gamma, inj2 ) );;
gap> WeakKernelLift( WeakCokernelProjection( gamma ), gamma );;
gap> pi1 := InjectionOfFirstCofactorOfWeakBiPushout( alpha, alpha );;
gap> pi2 := InjectionOfSecondCofactorOfWeakBiPushout( alpha, alpha );;
gap> UniversalMorphismFromWeakBiPushout( alpha, alpha, pi1, pi2 );;
gap> ## Freyd categories
> freyd := FreydCategory( cat );;
gap> IsAbelianCategory( freyd );;
gap> obj_gamma := FreydCategoryObject( gamma );;
gap> f := FreydCategoryMorphism( obj_gamma, gamma, obj_gamma );;
gap> witness := MorphismWitness( f );;
gap> g := FreydCategoryMorphism( obj_gamma, ZeroMorphism( obj2, obj2 ), obj_gamma );;
gap> IsCongruentForMorphisms( f, g );;
gap> c := PreCompose( f, f );;
gap> s := g + g;;
gap> a := CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 2 ] ], 1, 1, R ), obj1 );;
gap> Z2 := FreydCategoryObject( a );;
gap> id := IdentityMorphism( Z2 );;
gap> z := id + id + id;;
gap> d := DirectSumFunctorial( [ z, z, z ] );;
gap> pr2 := ProjectionInFactorOfDirectSum( [ Z2, Z2, Z2 ], 2 );;
gap> pr3 := ProjectionInFactorOfDirectSum( [ Z2, Z2, Z2 ], 3 );;
gap> UniversalMorphismIntoDirectSum( [ pr3, pr2 ] );;
gap> inj1 := InjectionOfCofactorOfDirectSum( [ Z2, Z2, Z2 ], 1 );;
gap> inj2 := InjectionOfCofactorOfDirectSum( [ Z2, Z2, Z2 ], 2 );;
gap> UniversalMorphismFromDirectSum( [ inj2, inj1 ] );;
gap> ZFree := AsFreydCategoryObject( obj1 );;
gap> id := IdentityMorphism( ZFree );;
gap> z := id + id;;
gap> CokernelProjection( z );;
gap> CokernelColift( z, CokernelProjection( z ) );;
gap> S := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> Cols_S := CategoryOfColumns( S );;
gap> S3 := CategoryOfColumnsObject( 3, Cols_S );;
gap> S1 := CategoryOfColumnsObject( 1, Cols_S );;
gap> mor := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,y,z]", 1, 3, S ), S1 );;
gap> biased_w := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,0,0,0,x,0,0,0,x]", 3, 3, S ), S3 );;
gap> biased_h := CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x*y, x*z, y^2]", 3, 3, S ), S3 );;
gap> BiasedWeakFiberProduct( biased_h, biased_w );;
gap> ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w );;
gap> IsCongruentForMorphisms(
>    PreCompose( UniversalMorphismIntoBiasedWeakFiberProduct( biased_h, biased_w, biased_h ), ProjectionOfBiasedWeakFiberProduct( biased_h, biased_w ) ),
>    biased_h
> );
true
gap> IsCongruentForMorphisms(
>   PreCompose( InjectionOfBiasedWeakPushout( biased_h, biased_w ), UniversalMorphismFromBiasedWeakPushout( biased_h, biased_w, biased_h )),
>   biased_h
> );
true
gap> k := FreydCategoryObject( mor );;
gap> w := EpimorphismFromSomeProjectiveObjectForKernelObject( UniversalMorphismIntoZeroObject( k ) );;
gap> k := KernelEmbedding( w );;
gap> ColiftAlongEpimorphism( CokernelProjection( k ), CokernelProjection( k ) );;
gap> ## Homomorphism structures
> a := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );;
gap> IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );;
gap> a := ZeroObjectFunctorial( cat );;
gap> IsCongruentForMorphisms( InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( a ), Range( a ), InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( a ) ), a );;
gap> Z4 := FreydCategoryObject( AsCategoryOfColumnsMorphism( HomalgMatrix( "[4]", 1, 1, R ), cat ) );;
gap> Z3 := FreydCategoryObject( AsCategoryOfColumnsMorphism( HomalgMatrix( "[3]", 1, 1, R ), cat ) );;
gap> HomomorphismStructureOnObjects( Z4, Z2 );;
gap> HomomorphismStructureOnObjects( Z4, Z4 );;
gap> HomomorphismStructureOnObjects( Z2, Z4 );;
gap> HomomorphismStructureOnObjects( Z3, Z4 );;
gap> HomomorphismStructureOnMorphisms( IdentityMorphism( DirectSum( Z4, Z2, Z3 ) ), -IdentityMorphism( DirectSum( Z4, Z3 ) ) );;
gap> ## Lifts
> S2 := CategoryOfColumnsObject( 2, Cols_S );;
gap> S4 := CategoryOfColumnsObject( 4, Cols_S );;
gap> S1_freyd := AsFreydCategoryObject( S1 );;
gap> S2_freyd := AsFreydCategoryObject( S2 );;
gap> S3_freyd := AsFreydCategoryObject( S3 );;
gap> S4_freyd := AsFreydCategoryObject( S4 );;
gap> lift := FreydCategoryMorphism( S1_freyd, CategoryOfColumnsMorphism( S1, HomalgMatrix( "[x]", 1, 1, S ), S1 ), S1_freyd );;
gap> gamma := FreydCategoryMorphism( S1_freyd, CategoryOfColumnsMorphism( S1, HomalgMatrix( "[y]", 1,1, S ), S1 ), S1_freyd );;
gap> alpha := PreCompose( lift, gamma );;
gap> Lift( alpha, gamma );;
gap> Colift( lift, alpha );;
gap> IsCongruentForMorphisms( PreCompose( lift, Colift( lift, alpha ) ), alpha );;
gap> lift := FreydCategoryMorphism( S2_freyd, CategoryOfColumnsMorphism( S2, HomalgMatrix( "[x,y,z,x^2,1,z+1]", 3, 2, S ), S3 ), S3_freyd );;
gap> gamma := FreydCategoryMorphism( S3_freyd, CategoryOfColumnsMorphism( S3, HomalgMatrix( "[x,y,z,z+1, x^2,y^2,z^2,z^2+1, x^3,y^3,z^3,z^3+1]", 4,3, S ), S4 ), S4_freyd );;
gap> alpha := PreCompose( lift, gamma );;
gap> Lift( alpha, gamma );;
gap> Colift( lift, alpha );;
gap> IsCongruentForMorphisms( PreCompose( lift, Colift( lift, alpha ) ), alpha );;
gap> interpretation := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( gamma );;
gap> IsCongruentForMorphisms( gamma,
> InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( gamma ), Range( gamma ), interpretation ) );;
gap> ## Opposite
> HomomorphismStructureOnObjects( Opposite( Z4 ), Opposite( Z2 ) );;
gap> HomomorphismStructureOnObjects( Z2, Z4 );;
gap> interpretation := InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( Opposite( gamma ) );;
gap> IsCongruentForMorphisms( Opposite( gamma ),
> InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( Source( Opposite( gamma ) ), Range( Opposite( gamma ) ), interpretation ) );
true

12.6 CoFreyd category

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> ZZZ := HomalgRingOfIntegers( );;
gap> rows := CategoryOfRows( ZZZ );;
gap> co_freyd := CoFreydCategory( rows );
CoFreyd( Rows( Z ) )
gap> rows_obj := CategoryOfRowsObject( rows, 1 );; # ZZZ^1
gap> co_freyd_obj := AsCoFreydCategoryObject( rows_obj );; # ZZZ^1 -> 0
gap> rows_mor := CategoryOfRowsMorphism( rows, rows_obj, HomalgMatrix( [ 2 ], 1, 1, ZZZ ), rows_obj );; # ZZZ^1 --2-> ZZZ^1
gap> co_freyd_mor := CoFreydCategoryMorphism( co_freyd_obj, rows_mor, co_freyd_obj );;
gap> IsWellDefined( co_freyd_mor );
true
gap> Display( KernelObject( co_freyd_mor ) );

--------------------------------
CoRelation morphism:
--------------------------------

Source: 
A row module over Z of rank 1

Matrix: 
[ [  2 ] ]

Range: 
A row module over Z of rank 1

A morphism in Rows( Z )


--------------------------------
General description:
--------------------------------

An object in CoFreyd( Rows( Z ) )

gap> Display( UnderlyingMorphism( KernelEmbedding( co_freyd_mor ) ) );
Source: 
A row module over Z of rank 1

Matrix: 
[ [  1 ] ]

Range: 
A row module over Z of rank 1

An identity morphism in Rows( Z )
gap> Display( CokernelObject( co_freyd_mor ) );

--------------------------------
CoRelation morphism:
--------------------------------

Source: 
A row module over Z of rank 0

Matrix: 
(an empty 0 x 0 matrix)

Range: 
A row module over Z of rank 0

A morphism in Rows( Z )


--------------------------------
General description:
--------------------------------

An object in CoFreyd( Rows( Z ) )

gap> Display( UnderlyingMorphism( CokernelProjection( co_freyd_mor ) ) );
Source: 
A row module over Z of rank 1

Matrix: 
(an empty 1 x 0 matrix)

Range: 
A row module over Z of rank 0

A morphism in Rows( Z )

12.7 Cokernel image closure in category of rows

gap> R := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> RowsR := CategoryOfRows( R );;
gap> m := AsCategoryOfRowsMorphism( 
>     HomalgMatrix( "[[x],[y],[z]]", 3, 1, R ), RowsR
> );;
gap> mu := AsCokernelImageClosureMorphism( m );;
gap> C := CokernelObject( mu );;
gap> C2 := AsFinitelyPresentedCokernelImageClosureObject( m );;
gap> IsEqualForObjects( C, C2 );
true
gap> n := AsCategoryOfRowsMorphism( 
>     HomalgMatrix( "[[x,y],[y^2,z]]", 2, 2, R ), RowsR
> );;
gap> nu := AsCokernelImageClosureMorphism( n );;
gap> nu2 := PreCompose( nu, nu );;
gap> IsWellDefined( nu2 );
true
gap> IsCongruentForMorphisms( nu, nu2 );
false
gap> nu + nu;;
gap> nu2 - nu;;
gap> cat := CapCategory( nu );;
gap> ZeroObject( cat );;
gap> ZeroMorphism( Source( nu ), Source( mu ) );;
gap> UniversalMorphismIntoZeroObject( Source( nu ) );;
gap> UniversalMorphismFromZeroObject( Source( nu ) );;
gap> S := Source( mu );;
gap> DirectSum( [S, S, S ] );;
gap> DirectSumFunctorial( [ nu2, nu ] );;
gap> UniversalMorphismIntoDirectSum( [ nu, nu ] );;
gap> UniversalMorphismFromDirectSum( [ nu, nu ] );;
gap> ProjectionInFactorOfDirectSum( [ S, S, S ], 2 );;
gap> InjectionOfCofactorOfDirectSum( [ S, S, S, S ], 4 );;
gap> CokernelColift( nu, CokernelProjection( nu ) );;
gap> IsCongruentForMorphisms( nu, PreCompose( CoastrictionToImage( nu ), ImageEmbedding( nu ) ) );
true
gap> u := UniversalMorphismFromImage( nu, [ nu, IdentityMorphism( Range( nu ) ) ] );;
gap> IsWellDefined( u );
true
gap> IsCongruentForMorphisms( nu, PreCompose( CoastrictionToImage( nu ), u ) );
true
gap> IsCongruentForMorphisms( u, ImageEmbedding( nu ) );
true
gap> kernel := KernelObject( mu );;
gap> emb := KernelEmbedding( mu );;
gap> p := PreCompose( EpimorphismFromSomeProjectiveObject( kernel ), KernelEmbedding( mu ) );;
gap> KernelLift( mu, p );;
gap> LiftAlongMonomorphism( emb, p );;
gap> I_to_A := FunctorCokernelImageClosureToFreydCategory( RowsR );;
gap> A_to_I := FunctorFreydCategoryToCokernelImageClosure( RowsR );;
gap> ApplyFunctor( I_to_A, kernel );;
gap> ApplyFunctor( A_to_I, ApplyFunctor( I_to_A, kernel ) );;
gap> nu := NaturalIsomorphismFromIdentityToFinitePresentationOfCokernelImageClosureObject( RowsR );;
gap> mu := NaturalIsomorphismFromFinitePresentationOfCokernelImageClosureObjectToIdentity( RowsR );;
gap> IsCongruentForMorphisms(
>     IdentityMorphism( kernel ),
>     PreCompose( ApplyNaturalTransformation( nu, kernel ), ApplyNaturalTransformation( mu, kernel ) )
> );
true

12.8 Cokernel image closure in category of columns

gap> R := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> ColsR := CategoryOfColumns( R );;
gap> m := AsCategoryOfColumnsMorphism( 
>      HomalgMatrix( "[[x],[y],[z]]", 1, 3, R ), ColsR
> );;
gap> mu := AsCokernelImageClosureMorphism( m );;
gap> C := CokernelObject( mu );;
gap> C2 := AsFinitelyPresentedCokernelImageClosureObject( m );;
gap> IsEqualForObjects( C, C2 );
true
gap> n := AsCategoryOfColumnsMorphism( 
>     HomalgMatrix( "[[x,y],[y^2,z]]", 2, 2, R ), ColsR
> );;
gap> nu := AsCokernelImageClosureMorphism( n );;
gap> nu2 := PreCompose( nu, nu );;
gap> IsWellDefined( nu2 );
true
gap> IsCongruentForMorphisms( nu, nu2 );
false
gap> nu + nu;;
gap> nu2 - nu;;
gap> cat := CapCategory( nu );;
gap> ZeroObject( cat );;
gap> ZeroMorphism( Source( nu ), Source( mu ) );;
gap> UniversalMorphismIntoZeroObject( Source( nu ) );;
gap> UniversalMorphismFromZeroObject( Source( nu ) );;
gap> S := Source( mu );;
gap> DirectSum( [S, S, S ] );;
gap> DirectSumFunctorial( [ nu2, nu ] );;
gap> UniversalMorphismIntoDirectSum( [ nu, nu ] );;
gap> UniversalMorphismFromDirectSum( [ nu, nu ] );;
gap> ProjectionInFactorOfDirectSum( [ S, S, S ], 2 );;
gap> InjectionOfCofactorOfDirectSum( [ S, S, S, S ], 4 );;
gap> CokernelColift( nu, CokernelProjection( nu ) );;
gap> IsCongruentForMorphisms( nu, PreCompose( CoastrictionToImage( nu ), ImageEmbedding( nu ) ) );
true
gap> u := UniversalMorphismFromImage( nu, [ nu, IdentityMorphism( Range( nu ) ) ] );;
gap> IsWellDefined( u );
true
gap> IsCongruentForMorphisms( nu, PreCompose( CoastrictionToImage( nu ), u ) );
true
gap> IsCongruentForMorphisms( u, ImageEmbedding( nu ) );
true
gap> kernel := KernelObject( mu );;
gap> emb := KernelEmbedding( mu );;
gap> p := PreCompose( EpimorphismFromSomeProjectiveObject( kernel ), KernelEmbedding( mu ) );;
gap> KernelLift( mu, p );;
gap> LiftAlongMonomorphism( emb, p );;
gap> I_to_A := FunctorCokernelImageClosureToFreydCategory( ColsR );;
gap> A_to_I := FunctorFreydCategoryToCokernelImageClosure( ColsR );;
gap> ApplyFunctor( I_to_A, kernel );;
gap> ApplyFunctor( A_to_I, ApplyFunctor( I_to_A, kernel ) );;
gap> nu := NaturalIsomorphismFromIdentityToFinitePresentationOfCokernelImageClosureObject( ColsR );;
gap> mu := NaturalIsomorphismFromFinitePresentationOfCokernelImageClosureObjectToIdentity( ColsR );;
gap> IsCongruentForMorphisms(
>     IdentityMorphism( kernel ),
>     PreCompose( ApplyNaturalTransformation( nu, kernel ), ApplyNaturalTransformation( mu, kernel ) )
> );
true

12.9 Adelman category basics

gap> R := HomalgRingOfIntegers();;
gap> RowsR := CategoryOfRows( R );;
gap> one := AsCategoryOfRowsMorphism( HomalgMatrix( [ [ 1 ] ], 1, 1, R ), RowsR );;
gap> two := AsCategoryOfRowsMorphism( HomalgMatrix( [ [ 2 ] ], 1, 1, R ), RowsR );;
gap> four := AsCategoryOfRowsMorphism( HomalgMatrix( [ [ 4 ] ], 1, 1, R ), RowsR );;
gap> source := AdelmanCategoryObject( two, two );;
gap> range := AdelmanCategoryObject( two, four );;
gap> mor := AdelmanCategoryMorphism( source, one, range );;
gap> IsZeroForMorphisms( mor );
false
gap> emb := EmbeddingFunctorIntoFreydCategory( RowsR );;
gap> ind := AdelmanCategoryFunctorInducedByUniversalProperty( emb );;
gap> IsZeroForMorphisms( ApplyFunctor( ind, mor ) );
true
gap> M := FreydCategoryObject( AsCategoryOfRowsMorphism( HomalgMatrix( [ [  2, 2, 2 ], [ 4, 4, 6 ] ], 2, 3, R ), RowsR ) );;
gap> as_tensor := EmbeddingFunctorOfFreydCategoryIntoAdelmanCategory( RowsR );;
gap> Mt := ApplyFunctor( as_tensor, M );;
gap> lsat := LeftSatelliteAsEndofunctorOfAdelmanCategory( RowsR );;
gap> rsat := RightSatelliteAsEndofunctorOfAdelmanCategory( RowsR );;
gap> torsion := ApplyFunctor( ind, ( ApplyFunctor( rsat, ApplyFunctor( lsat, Mt ) ) ) );;
gap> unit := UnitOfSatelliteAdjunctionOfAdelmanCategory( RowsR );;
gap> IsZeroForMorphisms( ApplyNaturalTransformation( unit, Mt ) );
true
gap> counit := CounitOfSatelliteAdjunctionOfAdelmanCategory( RowsR );;
gap> t := ApplyNaturalTransformation( counit, Mt );;

12.10 Grade filtration

The sequence of modules computed via satellites behaves in a way that is not understood in the case when the ring is not Auslander regular.

gap> R := HomalgFieldOfRationalsInSingular() * "x,y";;
gap> R := R/"x*y"/"x^2";;
gap> RowsR := CategoryOfRows( R );;
gap> Freyd := FreydCategory( RowsR );;
gap> mat := HomalgMatrix( "[x,y]", 1, 2, R );;
gap> M := mat/Freyd;;
gap> mu1 := GradeFiltrationNthMonomorphism( M, 1 );;
gap> IsMonomorphism( mu1 );
true
gap> IsZero( mu1 );
false
gap> IsEpimorphism( mu1 );
false
gap> mu2 := GradeFiltrationNthMonomorphism( M, 2 );;
gap> IsIsomorphism( mu2 );
true
gap> IsZero( mu2 );
false
gap> mu3 := GradeFiltrationNthMonomorphism( M, 3 );;
gap> IsIsomorphism( mu3 );
true
gap> IsZero( mu3 );
false
gap> mu4 := GradeFiltrationNthMonomorphism( M, 4 );;
gap> IsMonomorphism( mu4 );
false
gap> IsEpimorphism( mu4 );
true
gap> IsZero( mu4 );
false

gap> Qxyz := HomalgFieldOfRationalsInDefaultCAS( ) * "x,y,z";;
gap> wmat := HomalgMatrix( "[ \
> x*y,  y*z,    z,        0,         0,    \
> x^3*z,x^2*z^2,0,        x*z^2,     -z^2, \
> x^4,  x^3*z,  0,        x^2*z,     -x*z, \
> 0,    0,      x*y,      -y^2,      x^2-1,\
> 0,    0,      x^2*z,    -x*y*z,    y*z,  \
> 0,    0,      x^2*y-x^2,-x*y^2+x*y,y^2-y \
> ]", 6, 5, Qxyz );;
gap> RowsR := CategoryOfRows( Qxyz );;
gap> Freyd := FreydCategory( RowsR );;
gap> Adel := AdelmanCategory( RowsR );;
gap> M := wmat/Freyd;;

We compute the grade sequence of functors (it turns out that on the level of functors, we don't get monos)

gap> M_tor := M/Adel;;
gap> Mu1 := GradeFiltrationNthNaturalTransformationComponent( M_tor, 1 );;
gap> IsZero( Mu1 );
false
gap> IsMonomorphism( Mu1 );
true
gap> Mu2 := GradeFiltrationNthNaturalTransformationComponent( M_tor, 2 );;
gap> IsZero( Mu2 );
false
gap> IsMonomorphism( Mu2 );
false
gap> Mu3 := GradeFiltrationNthNaturalTransformationComponent( M_tor, 3 );;
gap> IsZero( Mu3 );
false
gap> IsMonomorphism( Mu3 );
false
gap> Mu4 := GradeFiltrationNthNaturalTransformationComponent( M_tor, 4 );;
gap> IsZero( Mu4 );
true

We compute the grade sequence of modules (here, we really get monos and thus a filtration)

gap> mu1 := GradeFiltrationNthMonomorphism( M, 1 );;
gap> IsZero( mu1 );
false
gap> IsMonomorphism( mu1 );
true
gap> mu2 := GradeFiltrationNthMonomorphism( M, 2 );;
gap> IsZero( mu2 );
false
gap> IsMonomorphism( mu2 );
true
gap> mu3 := GradeFiltrationNthMonomorphism( M, 3 );;
gap> IsZero( mu3 );
false
gap> IsMonomorphism( mu3 );
true
gap> mu4 := GradeFiltrationNthMonomorphism( M, 4 );;
gap> IsZero( mu4 );
true

12.11 Groups as categories

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> G := SymmetricGroup( 3 );;
gap> CG := GroupAsCategory( G );;
gap> u := GroupAsCategoryUniqueObject( CG );;
gap> alpha := GroupAsCategoryMorphism( (1,2,3), CG );;
gap> alpha * Inverse( alpha ) = IdentityMorphism( u );
true
gap> beta := GroupAsCategoryMorphism( (1,2,3,5), CG );;
gap> IsWellDefined( beta );
false
gap> gamma := GroupAsCategoryMorphism( (1,3), CG );;
gap> IsWellDefined( gamma );
true
gap> Lift( alpha, gamma ) * gamma = alpha;
true
gap> alpha * Colift( alpha, gamma ) = gamma;
true
gap> Length( HomomorphismStructureOnObjects( u, u ) ) = Size( G );
true
gap> InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism(
>     u,u,
>     PreCompose(
>         InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure( alpha ), HomomorphismStructureOnMorphisms( gamma, Inverse( gamma ) )
>     )
> )
> =
> gamma * alpha * Inverse( gamma );
true
gap> x := (2,3)/CG;;
gap> id := ()/CG;;
gap> IsIdenticalObj( x * x, id );
true
#@fi

12.12 Homomorphisms between f.p. functors based on category of rows

gap> R := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> Rows_R := CategoryOfRows( R );;
gap> R1 := CategoryOfRowsObject( 1, Rows_R );;
gap> R3 := CategoryOfRowsObject( 3, Rows_R );;
gap> alpha := CategoryOfRowsMorphism( R3, HomalgMatrix( "[x,y,z]", 3, 1, R ), R1 );;
gap> M := FreydCategoryObject( alpha );;
gap> c0 := CovariantExtAsFreydCategoryObject( M, 0 );;
gap> c1 := CovariantExtAsFreydCategoryObject( M, 1 );;
gap> c2 := CovariantExtAsFreydCategoryObject( M, 2 );;
gap> IsZeroForObjects( HomomorphismStructureOnObjects( c0, c2 ) ); # = Ext^2( M, M )
false

12.13 Homomorphisms between f.p. functors based on category of columns

gap> R := HomalgFieldOfRationalsInSingular() * "x,y,z";;
gap> Cols_R := CategoryOfColumns( R );;
gap> R1 := CategoryOfColumnsObject( 1, Cols_R );;
gap> R3 := CategoryOfColumnsObject( 3, Cols_R );;
gap> alpha := CategoryOfColumnsMorphism( R3, HomalgMatrix( "[x,y,z]", 1, 3, R ), R1 );;
gap> M := FreydCategoryObject( alpha );;
gap> c0 := CovariantExtAsFreydCategoryObject( M, 0 );;
gap> c1 := CovariantExtAsFreydCategoryObject( M, 1 );;
gap> c2 := CovariantExtAsFreydCategoryObject( M, 2 );;
gap> IsZeroForObjects( HomomorphismStructureOnObjects( c0, c2 ) ); # = Ext^2( M, M )
false

12.14 Homomorphism structure

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> LoadPackage( "RingsForHomalg", false );
true
gap> EEE := KoszulDualRing( HomalgFieldOfRationalsInSingular( ) * "x,y" );;
gap> Eoid := RingAsCategory( EEE );;
gap> a := RingAsCategoryMorphism( Eoid, 1/2 );;
gap> b := RingAsCategoryMorphism( Eoid, -2/3 );;
gap> u := RingAsCategoryUniqueObject( Eoid );;
gap> IsCongruentForMorphisms( a,
>     InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism(
>         u,u,
>         InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure(
>             a
>         )
>     )
> );
true
gap> a = HomStructure( u, u, HomStructure( a ) );
true
gap> IsEqualForObjects( HomStructure( Eoid ), DistinguishedObjectOfHomomorphismStructure( Eoid ) );
true
gap> c := RingAsCategoryMorphism( Eoid, 3 );;
gap> d := RingAsCategoryMorphism( Eoid, 0 );;
gap> left_coeffs := [ [ a, b ], [ c, d ] ];;
gap> right_coeffs := [ [ PreCompose( a, b ), PreCompose( b, c ) ], [ c, PreCompose( a, a ) ] ];;
gap> right_side := [ a, b ];;
gap> MereExistenceOfSolutionOfLinearSystemInAbCategory( left_coeffs, right_coeffs, right_side );
true
gap> solution := 
>     SolveLinearSystemInAbCategory(
>     left_coeffs,
>     right_coeffs,
>     right_side
> );;
gap> ForAll( [ 1, 2 ], i ->
>     IsCongruentForMorphisms(
>         Sum( List( [ 1, 2 ], j -> PreCompose( [ left_coeffs[i][j], solution[j], right_coeffs[i][j] ] ) ) ),
>         right_side[i]
>     )
> );
true
gap> IsLiftable( c, d );
false
gap> LiftOrFail( c, d );
fail
gap> IsLiftable( d, c );
true
gap> LiftOrFail( d, c );
<0>
gap> Lift( d, c );
<0>
gap> IsColiftable( c, d );
true
gap> ColiftOrFail( c, d );
<0>
gap> Colift( c, d );
<0>
gap> IsColiftable( d, c );
false
gap> ColiftOrFail( d, c );
fail

12.15 Linear closure of categories

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> G := SymmetricGroup( 3 );;
gap> CG := GroupAsCategory( G );;
gap> compare_func := function( g, h ) return UnderlyingGroupElement( g ) < UnderlyingGroupElement( h ); end;;
gap> ZZZ := HomalgRingOfIntegers();;
gap> ZCG := LinearClosure( ZZZ, CG, compare_func );;
gap> u := GroupAsCategoryUniqueObject( CG );;
gap> g := GroupAsCategoryMorphism( (1,2,3), CG );;
gap> h := GroupAsCategoryMorphism( (1,2), CG );;
gap> v := LinearClosureObject( ZCG, u );;
gap> elem1 := LinearClosureMorphism( v, [ 1, 2, 3, 4, 5, 6 ], [ g, h, g, h, g, h ], v );;
gap> elem2 := LinearClosureMorphism( v, [ 1, 2, 3, 4, 5, 6 ], [ h, g, h, g, h, g ], v );;
gap> # for i in [ 1 .. 10^6 ] do LinearClosureMorphism( v, [ 1, 2, 3, 4, 5, 6 ], [ g, h, g, h, g, h ], v ); od;
gap> elem := LinearClosureMorphism( v, [ 0, 0, 0, 0, 0, 0 ], [ g, h, g, h, g, h ], v );;
gap> a := (1,2)/CG/ZCG;;
gap> b := (2,3)/CG/ZCG;;
gap> IsIsomorphism( a + b );
false
gap> Lift( a + b, a ) * a = a + b;
true
gap> IsLiftable( a + b, -2*a ); ## over Q this is liftable
false
#@fi

12.16 Matrices over ZP K

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> #Incidence matrix of our proset
> K := [ [1, 1, 1], [0, 1, 1], [0, 1, 1] ];;
gap> #Construction of a tower of categories
> CP_K := ProSetAsCategory( K );;
gap> ZZZ := HomalgRingOfIntegers( );;
gap> ZP_K := LinearClosure( ZZZ, CP_K, ReturnTrue );;
gap> RowsP_K := AdditiveClosure( ZP_K );;
gap> a := ProSetAsCategoryObject( 1, CP_K );;
gap> b := ProSetAsCategoryObject( 2, CP_K );;
gap> c := ProSetAsCategoryObject( 3, CP_K );;
gap> #Three random objects in the additive closure
> #Such that there exists morphisms from A->B and B->C:
> rand_coef := List( [ 1 .. 5 ], i -> Random( [ 2 .. 20 ] ) );;
gap> A1 := List( [ 1 .. rand_coef[ 1 ] ], i -> a );;
gap> A2 := List( [ 1 .. rand_coef[ 2 ] ], i -> b );;
gap> A := Concatenation( A1, A2 );;
gap> B1 := List( [ 1 .. rand_coef[ 3 ] ], i -> b );;
gap> B2 := List( [ 1 .. rand_coef[ 4 ] ], i -> c );;
gap> B :=  Concatenation( B1, B2 );;
gap> C := List([ 1 .. rand_coef[ 5 ] ], i -> c);;
gap> #A random lifting problem over ZP_K
> MA_B :=  List( [ 1 .. rand_coef[ 1 ] + rand_coef[ 2 ] ], i ->
>             List( [ 1 .. rand_coef[ 3 ] + rand_coef[ 4 ] ], j ->
>                 LinearClosureMorphism( LinearClosureObject( A[i], ZP_K ), [Random( [ -20 .. 20 ] )], [ProSetAsCategoryMorphism( A[i], B[j] )], LinearClosureObject( B[j], ZP_K ) )
>                 )
>               );;
gap> alpha := MA_B/RowsP_K;;
gap> MB_C :=  List( [ 1 .. rand_coef[ 3 ] + rand_coef[ 4 ] ], i ->
>             List( [ 1 .. rand_coef[ 5 ] ], j ->
>                 LinearClosureMorphism( LinearClosureObject( B[i], ZP_K ), [Random( [ -20 .. 20 ] )], [ProSetAsCategoryMorphism( B[i], C[j] )], LinearClosureObject( C[j], ZP_K ) )
>                 )
>              );;
gap> beta := MB_C/RowsP_K;;
gap> gamma := PreCompose( alpha, beta );;
gap> lift := Lift( gamma, beta );;
gap> PreCompose(lift, beta) = gamma;
true
#@fi

12.17 Matrices over ZG

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> G := SymmetricGroup( 3 );;
gap> CG := GroupAsCategory( G );;
gap> ZZZ := HomalgRingOfIntegers( );;
gap> ZCG := LinearClosure( ZZZ, CG );;
gap> RowsG := AdditiveClosure( ZCG );;
#@fi

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> a := (1,2)/CG/ZCG;;
gap> b := (2,3)/CG/ZCG;;
gap> e := ()/CG/ZCG;;
gap> omega := [ [ a - e ], [ b - e ] ]/RowsG;;
gap> u := GroupAsCategoryUniqueObject( CG );;
gap> v := LinearClosureObject( ZCG, u );;
gap> u := AsAdditiveClosureObject( v );;
gap> HomStructure( u, omega );;
#@fi

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> elem := Elements( G );;
gap> elem := List( elem, x -> x/CG/ZCG );;
gap> rand_elem := function() local coeffs; coeffs := List( [ 1 .. 6 ], i -> Random( [ -20 .. 20 ] ) ); if ForAll( coeffs, IsZero ) then return ZeroMorphism( v, v ); fi; return Sum( List( [ 1 .. 6 ], i -> Random( [ -20 .. 20 ] ) * One( ZZZ ) * elem[i] ) ); end;;
gap> mat10_11 := List( [ 1 .. 10 ], i ->
>         List( [ 1 .. 11 ], j ->
>             rand_elem()
>         )
>     );;
gap> mat11_12 := List( [ 1 .. 11 ], i ->
>         List( [ 1 .. 12 ], j ->
>             rand_elem()
>         )
>     );;
gap> alpha := mat10_11/RowsG;;
gap> beta := mat11_12/RowsG;;
gap> gamma := PreCompose( alpha, beta );;
gap> lift := Lift( gamma, beta );;
gap> PreCompose( lift, beta ) = gamma;
true
#@fi

12.18 Opposite( CategoryOfRow ) as CategoryOfColumns

Assume that we have the constructors CategoryOfRows and CategoryOfColumns but no constructor Opposite. Then we can still model Opposite( CategoryOfRows ) as CategoryOfColumns using ReinterpretationOfCategory. This can be achieved up to minor modifications by swapping object_constructor and modeling_tower_object_constructor and so on in CategoryOfColums_as_Opposite_CategoryOfRows. With this, objects and morphisms indeed have the attribute Opposite as desired. Getting ObjectDatum and MorphismDatum to return this attribute would also be possible, but would require more effort than simply swapping object_constructor and modeling_tower_object_constructor and so.

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> QQ := HomalgFieldOfRationals( );;
gap> cols := CategoryOfColumns( QQ );;
gap> rows := CategoryOfRows( QQ );;
gap> object_constructor :=
>     { cat, rank } -> CreateCapCategoryObjectWithAttributes( cat,
>                                                             Opposite, CategoryOfRowsObject( Opposite( cat ), rank )
>     );;
gap> modeling_tower_object_constructor :=
>     { cat, rank } -> CreateCapCategoryObjectWithAttributes( ModelingCategory( cat ),
>                                                             RankOfObject, rank
>     );;
gap> object_datum := { cat, obj } -> RankOfObject( Opposite( obj ) );;
gap> modeling_tower_object_datum := { cat, obj } -> RankOfObject( obj );;
gap> morphism_constructor :=
>     { cat, source, underlying_matrix, range } ->
>         CreateCapCategoryMorphismWithAttributes(
>             cat,
>             source, range,
>             Opposite, CategoryOfRowsMorphism(
>                 Opposite( cat ),
>                 Opposite( range ),
>                 underlying_matrix,
>                 Opposite( source )
>             )
>         );;
gap> modeling_tower_morphism_constructor :=
>     { cat, source, underlying_matrix, range } ->
>         CreateCapCategoryMorphismWithAttributes(
>             ModelingCategory( cat ),
>             source, range,
>             UnderlyingMatrix, underlying_matrix
>         );;
gap> morphism_datum := { cat, mor } -> UnderlyingMatrix( Opposite( mor ) );;
gap> modeling_tower_morphism_datum := { cat, mor } -> UnderlyingMatrix( mor );;
gap> op := ReinterpretationOfCategory( cols, rec(
>     name := Concatenation( "Opposite( ", Name( rows )," )" ),
>     category_filter := WasCreatedAsOppositeCategory,
>     category_object_filter := IsCapCategoryOppositeObject,
>     category_morphism_filter := IsCapCategoryOppositeMorphism,
>     object_constructor := object_constructor,
>     object_datum := object_datum,
>     morphism_constructor := morphism_constructor,
>     morphism_datum := morphism_datum,
>     modeling_tower_object_constructor := modeling_tower_object_constructor,
>     modeling_tower_object_datum := modeling_tower_object_datum,
>     modeling_tower_morphism_constructor := modeling_tower_morphism_constructor,
>     modeling_tower_morphism_datum := modeling_tower_morphism_datum,
>     only_primitive_operations := true,
> ) );
Opposite( Rows( Q ) )
gap> SetOpposite( op, rows );
gap> source := ObjectConstructor( op, 1 );
<An object in Opposite( Rows( Q ) )>
gap> range := ObjectConstructor( op, 2 );
<An object in Opposite( Rows( Q ) )>
gap> zero := ZeroMorphism( source, range );
<A zero morphism in Opposite( Rows( Q ) )>
gap> sum := AdditionForMorphisms( zero, zero );
<A morphism in Opposite( Rows( Q ) )>
gap> # notice that source and range are indeed swapped compared to the above
> Display( Source( Opposite( sum ) ) );
A row module over Q of rank 2
gap> Display( Range( Opposite( sum ) ) );
A row module over Q of rank 1

12.19 Testing if an object is projective, injective, bijective, and computing projective/injective dimensions

gap> R := HomalgRingOfIntegers();;
gap> rows := CategoryOfRows( R );;
gap> adelman := AdelmanCategory( rows );;
gap> rowobj := CategoryOfRowsObject( 1, rows );;
gap> alpha := ProjectionInFactorOfDirectSum( [ rowobj, rowobj ], 1 );;
gap> alpha := AsAdelmanCategoryMorphism( alpha );;
gap> obj := CokernelObject( alpha );;
gap> IsBijectiveObject( obj );
true
gap> beta := 2 * IdentityMorphism( rowobj );;
gap> beta := AsAdelmanCategoryMorphism( beta );;
gap> obj1 := CokernelObject( beta );;
gap> obj2 := KernelObject( beta );;
gap> obj3 := ImageObject( beta );;
gap> obj4 := HomologyObject( beta, beta );;
gap> IsBijectiveObject( obj1 );
false
gap> IsInjective( obj1 );
true
gap> ProjectiveDimension( obj1 );
2
gap> IsBijectiveObject( obj2 );
false
gap> IsProjective( obj2 );
true
gap> InjectiveDimension( obj2 );
2
gap> ProjectiveDimension( obj3 );
1
gap> InjectiveDimension( obj3 );
1
gap> ProjectiveDimension( obj4 );
2
gap> InjectiveDimension( obj4 );
2

12.20 Prosets

#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> K := [ [1, 1, 1], [0, 1, 1], [0, 1, 1] ];;
gap> L := [ [1, 1, 0], [0, 1, 1], [0, 0, 1] ];;
gap> P_K := ProSetAsCategory(K);;
gap> #ProSetAsCategory(L);
gap> a := 1/P_K;;
gap> b := ProSetAsCategoryObject(2, P_K);;
gap> c := ProSetAsCategoryObject(3, P_K);;
gap> d := ProSetAsCategoryObject(4, P_K);;
gap> delta := ProSetAsCategoryMorphism(b, a);;
gap> IsWellDefined(a);
true
gap> IsWellDefined(d);
false
gap> IsWellDefined(delta);
false
gap> alpha := ProSetAsCategoryMorphism(a, b);;
gap> beta := ProSetAsCategoryMorphism(b, c);;
gap> gamma := ProSetAsCategoryMorphism(a, c);;
gap> gamma = PreCompose(alpha, beta);
true
gap> id_a := IdentityMorphism(a);;
gap> IsWellDefined(Inverse(alpha));
false
gap> beta*Inverse(beta) = IdentityMorphism(b);
true
gap> alpha = Lift(gamma, beta);
true
gap> IsLiftable(beta, gamma);
false
gap> Colift(alpha, gamma) = beta;
true
gap> alpha = HomStructure(a, b, HomStructure(alpha));
true
#@fi

12.21 Tests

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> R := HomalgRingOfIntegers( ) ;;
gap> cat := CategoryOfColumns( R );;
gap> A := RandomObjectByInteger( cat, 2 );;
gap> B := RandomObjectByInteger( cat, 2 );;
gap> mor1 := RandomMorphismByInteger( cat, 2 );;
gap> mor2 := RandomMorphismWithFixedSourceByInteger( cat, CategoryOfColumnsObject( cat, 3 ), 2 );;
gap> mor3 := RandomMorphismWithFixedRangeByInteger( cat, CategoryOfColumnsObject( cat, 3 ), 2 );;
gap> mor4 := RandomMorphismWithFixedSourceAndRangeByInteger( cat, CategoryOfColumnsObject( cat, 3 ), CategoryOfColumnsObject( cat, 4 ), 2 );;
gap> RankOfObject( Source( mor2 ) ) = 3;
true
gap> RankOfObject( Range( mor3 ) ) = 3;
true
gap> RankOfObject( Source( mor4 ) ) = 3;
true
gap> RankOfObject( Range( mor4 ) ) = 4;
true

gap> LoadPackage( "FreydCategoriesForCAP", false );
true
gap> QQ := HomalgFieldOfRationalsInSingular( );;
gap> QQxy := QQ * "x,y";;
gap> EQQxy := KoszulDualRing( QQxy );;
gap> R := KoszulDualRing( HomalgRingOfIntegersInSingular( ) * "x,y" );;
gap> CAP_INTERNAL_GENERATE_DOCUMENTATION_FOR_CATEGORY_INSTANCES(
>     [
>         [ CategoryOfRows( R ), "CategoryOfRows of an arbitrary ring" ],
>         [ CategoryOfRows( EQQxy ), "CategoryOfRows of an exterior algebra over a field" ],
>         [ CategoryOfRows( QQxy ), "CategoryOfRows of a commutative ring" ],
>         [ CategoryOfRows( QQ ), "CategoryOfRows of a field" ],
>     ],
>     "FreydCategoriesForCAP",
>     "CategoryOfRows.autogen.gd",
>     "Category of rows",
>     "Supported CAP operations"
> );

12.22 Category of relations

gap> F := HomalgRingOfIntegers( 3 );;
gap> vec := CategoryOfRows( F );;
gap> rel := RelCategory( vec );;
gap> A := 1/vec/rel;;
gap> id := IdentityMorphism( A );;
gap> IsWellDefined( id );
true
gap> alpha := HomalgMatrix( "[ 1, 2 ]", 2, 1, F )/vec;;
gap> alpha_rel := alpha/rel;;
gap> alpha_rel_inv := rel/alpha;;
gap> beta := PreCompose( alpha_rel_inv, alpha_rel );;
gap> IsCongruentForMorphisms( beta, id );
true
gap> IsEqualForMorphisms( beta, id );
false
gap> R := HomalgFieldOfRationalsInSingular() * "t";;
gap> t := IndeterminatesOfPolynomialRing( R )[1];;
gap> cocycle := function( a, b, c ) local e; e := CoastrictionToImage( UniversalMorphismIntoDirectSum( [ ReversedArrow( c ), Arrow( c ) ] ) ); return t^RankOfObject( KernelObject( e ) ); end;;
#@if IsPackageMarkedForLoading( "FinSetsForCAP", ">= 2023.07-03" )
gap> T := TwistedLinearClosure( R, rel, cocycle );;
gap> gamma := beta/T;;
gap> delta := ZeroMorphism( 1/vec, 1/vec )/rel/T;;
gap> IsZeroForMorphisms( 3*gamma - 3*gamma );
true
gap> IsCongruentForMorphisms( delta, gamma );
false
gap> beta := PreCompose( alpha_rel_inv/T, alpha_rel/T );;
gap> IsZeroForMorphisms( beta - t * IdentityMorphism( Range( alpha_rel/T ) ) );
true
gap> IsZeroForMorphisms( ( gamma * delta ) * gamma - gamma * ( delta * gamma ) );
true
#@fi

12.23 Rings as Ab-categories

gap> CR := RingAsCategory( Integers );;
gap> u := RingAsCategoryUniqueObject( CR );;
gap> alpha := 2 / CR;
<2>
gap> IsOne( alpha );
false
gap> MorphismDatum( alpha );
2
gap> IsZeroForMorphisms( alpha );
false
gap> alpha * alpha;
<4>
gap> -alpha;
<-2>
gap> IsZeroForMorphisms( alpha + AdditiveInverse( alpha ) );
true
gap> beta := RingAsCategoryMorphism( 1/2, CR );;
gap> IsWellDefined( beta );
false
gap> gamma := IdentityMorphism( u );
<1>
gap> IsOne( gamma );
true
gap> delta := ZeroMorphism( u, u );
<0>
gap> IsZeroForMorphisms( delta );
true
gap> 2 * alpha;
<4>
gap> Lift( alpha * alpha, alpha );
<2>
gap> Colift( alpha, alpha * alpha );
<2>
gap> BasisOfExternalHom( u, u );
[ <1> ]
gap> CoefficientsOfMorphism( alpha );
[ 2 ]
gap> IsCongruentForMorphisms( alpha, LinearCombinationOfMorphisms( u, CoefficientsOfMorphism( alpha ), BasisOfExternalHom( u, u ), u ) );
true
gap> TensorUnit( CR );
*
gap> TensorUnit( CR ) = u;
true
gap> TensorProductOnObjects( u, u );
*
gap> TensorProductOnObjects( u, u ) = u;
true
gap> TensorProductOnMorphisms( alpha, beta );
<1>
gap> Braiding( u, u );
<1>
gap> DualOnObjects( u ) = u;
true
gap> DualOnMorphisms( alpha ) = alpha;
true
gap> EvaluationForDual( u );
<1>
gap> CoevaluationForDual( u );
<1>
gap> CoDualOnObjects( u ) = u;
true
gap> CoDualOnMorphisms( beta ) = beta;
true
gap> CoclosedEvaluationForCoDual( u );
<1>
gap> CoclosedCoevaluationForCoDual( u );
<1>
gap> EEE := KoszulDualRing( HomalgFieldOfRationalsInSingular( ) * "x,y" );;
gap> CE := RingAsCategory( EEE );;
gap> u := RingAsCategoryUniqueObject( CE );;
gap> alpha := ("2 + 3 * e0 + 4 * e1 + 5 * e0*e1" / EEE) / CE;
<5*e0*e1+3*e0+4*e1+2>
gap> IsOne( alpha );
false
gap> IsZeroForMorphisms( alpha );
false
gap> alpha * alpha;
<20*e0*e1+12*e0+16*e1+4>
gap> -alpha;
<-5*e0*e1-3*e0-4*e1-2>
gap> IsZeroForMorphisms( alpha + AdditiveInverse( alpha ) );
true
gap> gamma := IdentityMorphism( u );
<1>
gap> IsOne( gamma );
true
gap> delta := ZeroMorphism( u, u );
<0>
gap> IsZeroForMorphisms( delta );
true
gap> 2 * alpha;
<10*e0*e1+6*e0+8*e1+4>
gap> Lift( alpha * alpha, alpha );
<5*e0*e1+3*e0+4*e1+2>
gap> Colift( alpha, alpha * alpha );
<5*e0*e1+3*e0+4*e1+2>
gap> basis := BasisOfExternalHom( u, u );
[ <1>, <e0>, <e1>, <e0*e1> ]
gap> coeffs := CoefficientsOfMorphism( alpha );
[ 2, 3, 4, 5 ]
gap> IsCongruentForMorphisms( alpha, LinearCombinationOfMorphisms( u, coeffs, basis, u ) );
true
gap> u_op := Opposite( u );
<An object in Opposite( RingAsCategory( Q{e0,e1} ) )>
gap> alpha_op := Opposite( alpha );
<A morphism in Opposite( RingAsCategory( Q{e0,e1} ) )>
gap> basis := BasisOfExternalHom( u_op, u_op );;
gap> coeffs := CoefficientsOfMorphism( alpha_op );
[ 2, 3, 4, 5 ]
gap> IsCongruentForMorphisms( alpha_op, LinearCombinationOfMorphisms( u_op, coeffs, basis, u_op ) );
true

12 Examples and Tests

12.1 Monoidal structure of AdditiveClosure