Goto Chapter: Top 1 2 Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

1 Lazy categories
 1.1 Examples

  1.1-1 Disassembling the snake in the Abelian category
  1.1-2 Disassembling the snake in the Abelian category (only lift primitve operations)
  1.1-3 Disassembling the snake in the free Abelian category
  1.1-4 Disassembling the snake in the free Abelian category (only lift primitve operations)
  1.1-5 Disassembling the snake in an underlying additive category
  1.1-6 Disassembling the snake in an underlying additive category (only lift primitve operations)
  1.1-7 Lazy terminal category with multiple objects

1 Lazy categories

1.1 Examples

1.1-1 Disassembling the snake in the Abelian category
gap> LoadPackage( "LinearAlgebraForCAP" );
true
gap> LoadPackage( "GeneralizedMorphismsForCAP" );
true
gap> SwitchGeneralizedMorphismStandard( "cospan" );
gap> Q := HomalgFieldOfRationals( );
Q
gap> id := HomalgIdentityMatrix( 8, Q );
<An unevaluated 8 x 8 identity matrix over an internal ring>
gap> a := CertainColumns( CertainRows( id, [ 1, 2, 3 ] ), [ 2, 3, 4, 5 ] );
<An unevaluated non-zero 3 x 4 matrix over an internal ring>
gap> b := CertainColumns( CertainRows( id, [ 1, 2, 3, 4 ] ), [ 2, 3, 4, 5, 6 ] );
<An unevaluated non-zero 4 x 5 matrix over an internal ring>
gap> c := CertainColumns(
>              CertainRows( id, [ 1, 2, 3, 4, 5 ] ), [ 3, 4, 5, 6, 7, 8 ] );
<An unevaluated non-zero 5 x 6 matrix over an internal ring>
gap> IsZero( a * b );
false
gap> IsZero( b * c );
false
gap> IsZero( a * b * c );
true
gap> Qmat := MatrixCategory( Q );
Category of matrices over Q
gap> Lazy := LazyCategory( Qmat : show_evaluation := true );
LazyCategory( Category of matrices over Q )
gap> a := a / Lazy; SetLabel( a, "a" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> b := b / Lazy; SetLabel( b, "b" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> c := c / Lazy; SetLabel( c, "c" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> d := CokernelProjection( a );
<An epimorphism in LazyCategory( Category of matrices over Q )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> f := KernelEmbedding( e );
<A monomorphism in LazyCategory( Category of matrices over Q )>
gap> g := KernelEmbedding( c );
<A monomorphism in LazyCategory( Category of matrices over Q )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> i := CokernelProjection( h );
<An epimorphism in LazyCategory( Category of matrices over Q )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> HK := HomologyObject( j, s );
<An object in LazyCategory( Category of matrices over Q )>
gap> HC := HomologyObject( s, k );
<An object in LazyCategory( Category of matrices over Q )>

1.1-2 Disassembling the snake in the Abelian category (only lift primitve operations)
gap> LoadPackage( "LinearAlgebraForCAP" );
true
gap> LoadPackage( "GeneralizedMorphismsForCAP" );
true
gap> SwitchGeneralizedMorphismStandard( "cospan" );
gap> Q := HomalgFieldOfRationals( );
Q
gap> id := HomalgIdentityMatrix( 8, Q );
<An unevaluated 8 x 8 identity matrix over an internal ring>
gap> a := CertainColumns( CertainRows( id, [ 1, 2, 3 ] ), [ 2, 3, 4, 5 ] );
<An unevaluated non-zero 3 x 4 matrix over an internal ring>
gap> b := CertainColumns( CertainRows( id, [ 1, 2, 3, 4 ] ), [ 2, 3, 4, 5, 6 ] );
<An unevaluated non-zero 4 x 5 matrix over an internal ring>
gap> c := CertainColumns(
>              CertainRows( id, [ 1, 2, 3, 4, 5 ] ), [ 3, 4, 5, 6, 7, 8 ] );
<An unevaluated non-zero 5 x 6 matrix over an internal ring>
gap> IsZero( a * b );
false
gap> IsZero( b * c );
false
gap> IsZero( a * b * c );
true
gap> Qmat := MatrixCategory( Q );
Category of matrices over Q
gap> Lazy := LazyCategory( Qmat :
>                 show_evaluation := true, primitive_operations := true );
LazyCategory( Category of matrices over Q )
gap> a := a / Lazy; SetLabel( a, "a" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> b := b / Lazy; SetLabel( b, "b" ); SetLabel( Target( b ), "C" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> c := c / Lazy; SetLabel( c, "c" );
<An evaluated morphism in LazyCategory( Category of matrices over Q )>
gap> d := CokernelProjection( a );
<An epimorphism in LazyCategory( Category of matrices over Q )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> f := KernelEmbedding( e );
<A monomorphism in LazyCategory( Category of matrices over Q )>
gap> g := KernelEmbedding( c );
<A monomorphism in LazyCategory( Category of matrices over Q )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> i := CokernelProjection( h );
<An epimorphism in LazyCategory( Category of matrices over Q )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of
 LazyCategory( Category of matrices over Q ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in LazyCategory( Category of matrices over Q )>
gap> HK := HomologyObject( j, s );
<An object in LazyCategory( Category of matrices over Q )>
gap> HC := HomologyObject( s, k );
<An object in LazyCategory( Category of matrices over Q )>

1.1-3 Disassembling the snake in the free Abelian category
gap> LoadPackage( "Algebroids", ">= 2022.05-06" );
true
gap> q := RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" );
q(4)[a:1->2,b:2->3,c:3->4]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) )
gap> zz := HomalgRingOfIntegers( );
Z
gap> Zq := zz[Fq];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
gap> A := Zq / [ Zq.abc ];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
/ relations
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> A_add := AdditiveClosure( A );
AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations )
gap> A_abel := AdelmanCategory( A_add );
Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) )
gap> LoadPackage( "LazyCategories" );
true
gap> Lazy := LazyCategory( A_abel : show_evaluation := true );
LazyCategory( Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) )
gap> a := A.a / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> b := A.b / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> c := A.c / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> SetLabel( a, "a" );
gap> SetLabel( b, "b" );
gap> SetLabel( c, "c" );
gap> SetLabel( Source( a ), "1" );
gap> SetLabel( Source( b ), "2" );
gap> SetLabel( Target( b ), "3" );
gap> SetLabel( Target( c ), "4" );
gap> d := CokernelProjection( a );
<An epimorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> f := KernelEmbedding( e );
<A monomorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> g := KernelEmbedding( c );
<A monomorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> i := CokernelProjection( h );
<An epimorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HK := HomologyObject( j, s );
<An object in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HC := HomologyObject( s, k );
<An object in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>

1.1-4 Disassembling the snake in the free Abelian category (only lift primitve operations)
gap> LoadPackage( "Algebroid", ">= 2022.05-02" );
true
gap> q := RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" );
q(4)[a:1->2,b:2->3,c:3->4]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) )
gap> zz := HomalgRingOfIntegers( );
Z
gap> Zq := zz[Fq];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
gap> A := Zq / [ Zq.abc ];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
/ relations
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> A_add := AdditiveClosure( A );
AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations )
gap> A_abel := AdelmanCategory( A_add );
Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) )
gap> LoadPackage( "LazyCategories" );
true
gap> Lazy := LazyCategory( A_abel :
>                 show_evaluation := true, primitive_operations := true );
LazyCategory( Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) )
gap> a := A.a / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> b := A.b / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> c := A.c / A_add / A_abel / Lazy;
<An evaluated morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> SetLabel( a, "a" );
gap> SetLabel( b, "b" );
gap> SetLabel( c, "c" );
gap> SetLabel( Source( a ), "1" );
gap> SetLabel( Source( b ), "2" );
gap> SetLabel( Target( b ), "3" );
gap> SetLabel( Target( c ), "4" );
gap> d := CokernelProjection( a );
<An epimorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> f := KernelEmbedding( e );
<A monomorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> g := KernelEmbedding( c );
<A monomorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> i := CokernelProjection( h );
<An epimorphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of LazyCategory(
 Adelman category( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HK := HomologyObject( j, s );
<An object in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HC := HomologyObject( s, k );
<An object in LazyCategory( Adelman category( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>

1.1-5 Disassembling the snake in an underlying additive category
gap> LoadPackage( "Algebroids", ">= 2022.05-06" );
true
gap> q := RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" );
q(4)[a:1->2,b:2->3,c:3->4]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) )
gap> zz := HomalgRingOfIntegers( );
Z
gap> Zq := zz[Fq];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
gap> A := Zq / [ Zq.abc ];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
/ relations
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> A_add := AdditiveClosure( A );
AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations )
gap> Lazy := LazyCategory( A_add : show_evaluation := true,
>                 lazify_range_of_hom_structure := true );
LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) )
gap> a := A.a / A_add / Lazy; SetLabel( a, "a" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> b := A.b / A_add / Lazy; SetLabel( b, "b" ); SetLabel( Target( b ), "3" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> c := A.c / A_add / Lazy; SetLabel( c, "c" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> Adelman := AdelmanCategory( Lazy );
Adelman category( LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) )
gap> a := a / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> b := b / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> c := c / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> d := CokernelProjection( a );
<An epimorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> f := KernelEmbedding( e );
<A monomorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> g := KernelEmbedding( c );
<A monomorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> i := CokernelProjection( h );
<An epimorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HK := HomologyObject( j, s );
<An object in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HC := HomologyObject( s, k );
<An object in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>

1.1-6 Disassembling the snake in an underlying additive category (only lift primitve operations)
gap> LoadPackage( "Algebroids", ">= 2022.05-06" );
true
gap> q := RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" );
q(4)[a:1->2,b:2->3,c:3->4]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) )
gap> zz := HomalgRingOfIntegers( );
Z
gap> Zq := zz[Fq];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
gap> A := Zq / [ Zq.abc ];
Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
/ relations
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> A_add := AdditiveClosure( A );
AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations )
gap> Lazy := LazyCategory( A_add : show_evaluation := true,
>                 lazify_range_of_hom_structure := true,
>                 primitive_operations := true );
LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) )
gap> a := A.a / A_add / Lazy; SetLabel( a, "a" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> b := A.b / A_add / Lazy; SetLabel( b, "b" ); SetLabel( Target( b ), "3" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> c := A.c / A_add / Lazy; SetLabel( c, "c" );
<An evaluated morphism in LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) )>
gap> Adelman := AdelmanCategory( Lazy );
Adelman category( LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) )
gap> a := a / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> b := b / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> c := c / Adelman;
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> d := CokernelProjection( a );
<An epimorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> e := CokernelColift( a, PreCompose( b, c ) );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> f := KernelEmbedding( e );
<A monomorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> g := KernelEmbedding( c );
<A monomorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> h := KernelLift( c, PreCompose( a, b ) );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> i := CokernelProjection( h );
<An epimorphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> ff := AsGeneralizedMorphism( f );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> dd := AsGeneralizedMorphism( d );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> bb := AsGeneralizedMorphism( b );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> gg := AsGeneralizedMorphism( g );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ii := AsGeneralizedMorphism( i );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> ss := PreCompose( [ ff, PseudoInverse( dd ), bb, PseudoInverse( gg ), ii ] );
<A morphism in Generalized morphism category of Adelman category(
 LazyCategory( AdditiveClosure( Algebroid( Z, FreeCategory(
 RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) ) / relations ) ) ) by cospan>
gap> s := HonestRepresentative( ss );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> j := KernelObjectFunctorial( b, d, e );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> k := CokernelObjectFunctorial( h, g, b );
<A morphism in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HK := HomologyObject( j, s );
<An object in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>
gap> HC := HomologyObject( s, k );
<An object in Adelman category( LazyCategory( AdditiveClosure(
 Algebroid( Z, FreeCategory( RightQuiver( "q(4)[a:1->2,b:2->3,c:3->4]" ) ) )
 / relations ) ) )>

1.1-7 Lazy terminal category with multiple objects
gap> T := TerminalCategoryWithMultipleObjects( );
TerminalCategoryWithMultipleObjects( )
gap> L := LazyCategory( T : primitive_operations := true, optimize := 0 );
LazyCategory( TerminalCategoryWithMultipleObjects( ) )
gap> a := "a" / T / L;
<An evaluated object in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( a );
a

An evaluated object given by the above data
gap> IsWellDefined( a );
true
gap> IsWellDefined( DirectSum( a, a ) );
true
gap> IsWellDefined( IdentityMorphism( DirectSum( a, a ) ) );
true
gap> aa := ObjectConstructor( T, "a" ) / L;
<An evaluated object in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( aa );
a

An evaluated object given by the above data
gap> a = aa;
true
gap> b := "b" / T / L;
<An evaluated object in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( b );
b

An evaluated object given by the above data
gap> a = b;
false
gap> t := TensorProduct( a, b );
<An object in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( t );
TensorProductOnObjects(
<An evaluated object in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )>,
<An evaluated object in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )> )
gap> a = t;
false
gap> TensorProduct( a, a ) = t;
false
gap> m := MorphismConstructor( EvaluatedCell( a ), "m", EvaluatedCell( b ) ) / L;
<An evaluated morphism in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( m );
a
|
| m
v
b

An evaluated morphism given by the above data
gap> IsWellDefined( m );
true
gap> n := MorphismConstructor( EvaluatedCell( a ), "n", EvaluatedCell( b ) ) / L;
<An evaluated morphism in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( n );
a
|
| n
v
b

An evaluated morphism given by the above data
gap> IsEqualForMorphisms( m, n );
false
gap> IsCongruentForMorphisms( m, n );
true
gap> m = n;
true
gap> id := IdentityMorphism( a );
<An identity morphism in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( id );
IdentityMorphism( <An evaluated object in
LazyCategory( TerminalCategoryWithMultipleObjects( ) )> )
gap> m = id;
false
gap> id = MorphismConstructor( EvaluatedCell( a ), "xy", EvaluatedCell( a ) ) / L;
true
gap> z := ZeroMorphism( a, a );
<A zero morphism in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> Display( z );
ZeroMorphism(
<An evaluated object in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )>,
<An evaluated object in
 LazyCategory( TerminalCategoryWithMultipleObjects( ) )> )
gap> id = z;
true
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 Ind

generated by GAPDoc2HTML