GAP (SubcategoriesForCAP) - Chapter 4: Slice categories (eager data structure)

The GAP category of objects in an eager slice category over the tensor unit.

4.1-8 IsMorphismInAnEagerSliceCategoryOverTensorUnit

The GAP category of morphisms in an eager slice category over the tensor unit.

4.2 Constructors

4.2-1 SliceCategory

4.2-2 SliceCategoryOverTensorUnit

4.2-3 AsSliceCategoryCell

4.3 Examples

4.3-1 SliceCategory

#@if ValueOption( "no_precompiled_code" ) <> true
gap> LoadPackage( "SubcategoriesForCAP" );
true
gap> LoadPackage( "Toposes", ">= 2024.02-04" );
true
gap> LoadPackage( "FinSetsForCAP", ">= 2024.02-02" );
true
gap> B := SubobjectClassifier( SkeletalFinSets );
|2|
gap> S := SliceCategory( B );
A slice category of SkeletalFinSets
gap> Display( S );
A CAP category with name A slice category of SkeletalFinSets:

50 primitive operations were used to derive 280 operations for this category which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsDistributiveCategory
* IsFiniteBicompleteCategory
and not yet algorithmically
* IsElementaryTopos
gap> o0 := MapOfFinSets( B, [ 1, 1 ], B ) / S;
An object in the slice category given by: |2| → |2|
gap> o1 := MapOfFinSets( FinSet( 3 ), [ 0, 1, 0 ], B ) / S;
An object in the slice category given by: |3| → |2|
gap> o2 := MapOfFinSets( FinSet( 4 ), [ 1, 0, 1, 0 ], B ) / S;
An object in the slice category given by: |4| → |2|
gap> IsWellDefined( o0 );
true
gap> IsWellDefined( o1 );
true
gap> IsWellDefined( o2 );
true
gap> IsHomSetInhabited( o1, o0 );
false
gap> IsHomSetInhabited( o0, o1 );
true
gap> IsHomSetInhabited( o1, o2 );
true
gap> IsHomSetInhabited( o2, o1 );
true
gap> iota := UniversalMorphismFromInitialObject( o1 );
A morphism in the slice category given by: |0| → |3|
gap> Display( iota );
∅ ⱶ[  ]→ { 0, 1, 2 }

A morphism in the slice category given by the above data
gap> IsInitial( Source( iota ) );
true
gap> tau := UniversalMorphismIntoTerminalObject( o2 );
A morphism in the slice category given by: |4| → |2|
gap> Display( tau );
{ 0,..., 3 } ⱶ[ 1, 0, 1, 0 ]→ { 0, 1 }

A morphism in the slice category given by the above data
gap> IsTerminal( Target( tau ) );
true
gap> n := MapOfFinSets( FinSet( 3 ), [ 2, 0, 3 ], FinSet( 4 ) );
|3| → |4|
gap> IsWellDefined( n );
true
gap> n := AsSliceCategoryCell( o1, n, o2 );
A morphism in the slice category given by: |3| → |4|
gap> IsWellDefined( n );
false
gap> m1 := MapOfFinSets( FinSet( 3 ), [ 1, 0, 3 ], FinSet( 4 ) );
|3| → |4|
gap> m1 := AsSliceCategoryCell( o1, m1, o2 );
A morphism in the slice category given by: |3| → |4|
gap> IsWellDefined( m1 );
true
gap> IsSplitEpimorphism( m1 );
false
gap> m2 := MapOfFinSets( FinSet( 4 ), [ 1, 2, 1, 0 ], FinSet( 3 ) );
|4| → |3|
gap> m2 := AsSliceCategoryCell( o2, m2, o1 );
A morphism in the slice category given by: |4| → |3|
gap> IsWellDefined( m2 );
true
gap> IsSplitEpimorphism( m2 );
true
gap> m3 := PreCompose( m1, m2 );
A morphism in the slice category given by: |3| → |3|
gap> IsWellDefined( m3 );
true
gap> IsOne( m3 );
false
gap> m4 := Inverse( m3 );
A morphism in the slice category given by: |3| → |3|
gap> IsWellDefined( m4 );
true
gap> m5 := PreCompose( m2, m1 );
A morphism in the slice category given by: |4| → |4|
gap> IsWellDefined( m5 );
true
gap> IsOne( m5 );
false
gap> t := DistinguishedObjectOfHomomorphismStructure( S );
|1|
gap> H := MorphismsOfExternalHom( o1, o2 );;
gap> Length( H );
8
gap> h := HomStructure( o1, o2 );
|8|
gap> HomStructure( m1, m2 );
|16| → |4|
gap> th := MorphismsOfExternalHom( t, h );
[ |1| → |8|, |1| → |8|, |1| → |8|, |1| → |8|,
  |1| → |8|, |1| → |8|, |1| → |8|, |1| → |8| ]
gap> th = List( H, InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure );
true
gap> H = List( th, m ->
>         InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism( o1, o2, m ) );
true
gap> Display( o1 );
{ 0, 1, 2 } ⱶ[ 0, 1, 0 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> Po1 := PowerObject( o1 );
An object in the slice category given by: |6| → |2|
gap> Display( Po1 );
{ 0,..., 5 } ⱶ[ 0, 0, 0, 0, 1, 1 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> e_o1 := PowerObjectLeftEvaluationMorphism( o1 );
A morphism in the slice category given by: |10| → |4|
gap> IsWellDefined( e_o1 );
true
gap> Display( e_o1 );
{ 0,..., 9 } ⱶ[ 0, 1, 0, 1, 2, 3, 0, 0, 1, 1 ]→ { 0,..., 3 }

A morphism in the slice category given by the above data
gap> sing_o1 :=  SingletonMorphism( o1 );
A morphism in the slice category given by: |3| → |6|
gap> Display( sing_o1 );
{ 0, 1, 2 } ⱶ[ 1, 5, 2 ]→ { 0,..., 5 }

A morphism in the slice category given by the above data
gap> IsWellDefined( sing_o1 );
true
gap> Display( o2 );
{ 0,..., 3 } ⱶ[ 1, 0, 1, 0 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> Po2 := PowerObject( o2 );
An object in the slice category given by: |8| → |2|
gap> Display( Po2 );
{ 0,..., 7 } ⱶ[ 0, 0, 0, 0, 1, 1, 1, 1 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> e_o2 := PowerObjectLeftEvaluationMorphism( o2 );
A morphism in the slice category given by: |16| → |4|
gap> IsWellDefined( e_o2 );
true
gap> Display( e_o2 );
{ 0,..., 15 } ⱶ[ 2, 3, 2, 3, 0, 1, 0, 1, 2, 2, 3, 3, 0, 0, 1, 1 ]→ { 0,..., 3 }

A morphism in the slice category given by the above data
gap> sing_o2 :=  SingletonMorphism( o2 );
A morphism in the slice category given by: |4| → |8|
gap> Display( sing_o2 );
{ 0,..., 3 } ⱶ[ 5, 1, 6, 2 ]→ { 0,..., 7 }

A morphism in the slice category given by the above data
gap> IsWellDefined( sing_o2 );
true
gap> Display( m1 );
{ 0, 1, 2 } ⱶ[ 1, 0, 3 ]→ { 0,..., 3 }

A morphism in the slice category given by the above data
gap> Pm1 := PowerObjectFunctorial( m1 );
A morphism in the slice category given by: |8| → |6|
gap> Display( Pm1 );
{ 0,..., 7 } ⱶ[ 0, 1, 2, 3, 4, 5, 4, 5 ]→ { 0,..., 5 }

A morphism in the slice category given by the above data
gap> IsWellDefined( Pm1 );
true
gap> Display( m2 );
{ 0,..., 3 } ⱶ[ 1, 2, 1, 0 ]→ { 0, 1, 2 }

A morphism in the slice category given by the above data
gap> Pm2 := PowerObjectFunctorial( m2 );
A morphism in the slice category given by: |6| → |8|
gap> Display( Pm2 );
{ 0,..., 5 } ⱶ[ 0, 2, 1, 3, 4, 7 ]→ { 0,..., 7 }

A morphism in the slice category given by the above data
gap> IsWellDefined( Pm2 );
true
gap> omega := SubobjectClassifier( S );
An object in the slice category given by: |4| → |2|
gap> Display( omega );
{ 0,..., 3 } ⱶ[ 0, 0, 1, 1 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> o12 := DirectProduct( o1, o2 );
An object in the slice category given by: |6| → |2|
gap> Display( o12 );
{ 0,..., 5 } ⱶ[ 1, 0, 0, 1, 0, 0 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> ff := MapOfFinSets( SourceOfUnderlyingMorphism( o12 ),
>              [ 3, 1, 1, 2, 1, 0 ],
>              SourceOfUnderlyingMorphism( omega ) );;
gap> f := MorphismConstructor( o12, ff, omega );
A morphism in the slice category given by: |6| → |4|
gap> IsWellDefined( f );
true
gap> g := PLeftTransposeMorphism( o1, o2, f );
A morphism in the slice category given by: |3| → |8|
gap> expo1o1 := Exponential( o1, o1 );
An object in the slice category given by: |5| → |2|
gap> Display( expo1o1 );
{ 0,..., 4 } ⱶ[ 0, 0, 0, 0, 1 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> evo1o1 := CartesianLeftEvaluationMorphism( o1, o1 );
A morphism in the slice category given by: |9| → |3|
gap> Display( evo1o1 );
{ 0,..., 8 } ⱶ[ 0, 2, 0, 2, 1, 0, 0, 2, 2 ]→ { 0, 1, 2 }

A morphism in the slice category given by the above data
#@fi

4.3-2 SliceCategoryOverTensorUnit

gap> LoadPackage( "SubcategoriesForCAP", false );
true
gap> LoadPackage( "LazyCategories", false );
true
gap> T := TerminalCategoryWithMultipleObjects();
TerminalCategoryWithMultipleObjects( )
gap> L := LazyCategory( T : primitive_operations := true, optimize := 0 );
LazyCategory( TerminalCategoryWithMultipleObjects( ) )
gap> a := "a" / T;
<A zero object in TerminalCategoryWithMultipleObjects( )>
gap> I := MorphismConstructor( T, a, "I", TensorUnit( T ) ) / L;
<An evaluated morphism in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>
gap> DualOverTensorUnit( L, I );
<A morphism in LazyCategory( TerminalCategoryWithMultipleObjects( ) )>

gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> Q := HomalgFieldOfRationalsInSingular( );
Q
gap> R := Q["x,y"];
Q[x,y]
gap> P := CategoryOfRows( R );
Rows( Q[x,y] )
gap> S := SliceCategoryOverTensorUnit( P );
SliceCategoryOverTensorUnit( Rows( Q[x,y] ) )
gap> I := HomalgMatrix( "[ x^2, x*y ]", 2, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> J := HomalgMatrix( "[ x ]", 1, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> phi := HomalgMatrix( "[ x, y ]", 2, 1, R ) / P;
<A morphism in Rows( Q[x,y] )>
gap> phi := MorphismConstructor( S, I, phi, J );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> IsWellDefined( phi );
true
gap> Ip := HomalgMatrix( "[ x*y, x*y^2 ]", 2, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> Jp := HomalgMatrix( "[ x ]", 1, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> psi := HomalgMatrix( "[ y, y^2 ]", 2, 1, R ) / P;
<A morphism in Rows( Q[x,y] )>
gap> psi := MorphismConstructor( S, Ip, psi, Jp );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> IsWellDefined( psi );
true
gap> TensorProductOnObjects( I, J );
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> TensorProductOnMorphisms( phi, psi );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> LeftUnitor( I );
A morphism in the slice category given by: <An identity morphism in Rows( Q[x,y] )>
gap> RightUnitor( I );
A morphism in the slice category given by: <An identity morphism in Rows( Q[x,y] )>
gap> AssociatorLeftToRight( I, J, Ip );
A morphism in the slice category given by: <An identity morphism in Rows( Q[x,y] )>
gap> AssociatorRightToLeft( I, J, Ip );
A morphism in the slice category given by: <An identity morphism in Rows( Q[x,y] )>
gap> Braiding( I, J );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>

4.3-3 IteratedInternalHom

Iteratively applying \(\underline{Hom}(J,-)\) to the universal morphism \(\iota: I \to T\), where \(T\) is the terminal object of the slice category, might never become an isomorphism. However, in this example it does.

gap> LoadPackage( "Locales" );
true
gap> Q := HomalgFieldOfRationalsInSingular( );
Q
gap> R := Q["x,y"];
Q[x,y]
gap> P := CategoryOfRows( R );
Rows( Q[x,y] )
gap> S := SliceCategoryOverTensorUnit( P );
SliceCategoryOverTensorUnit( Rows( Q[x,y] ) )
gap> I := HomalgMatrix( "[ x^2, x*y ]", 2, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> J := HomalgMatrix( "[ x ]", 1, 1, R ) / P / S;
An object in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> iota := InternalHom( UniversalMorphismIntoTerminalObject( J ), I );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> Display( iota );
Source:
A row module over Q[x,y] of rank 2

Matrix:
x,0,
0,x

Range:
A row module over Q[x,y] of rank 2

A morphism in Rows( Q[x,y] )

A morphism in the slice category given by the above data
gap> iota := InternalHom( J, iota );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> Display( iota );
Source:
A row module over Q[x,y] of rank 2

Matrix:
y,
x

Range:
A row module over Q[x,y] of rank 1

A morphism in Rows( Q[x,y] )

A morphism in the slice category given by the above data
gap> iota := InternalHom( J, iota );
A morphism in the slice category given by: <A morphism in Rows( Q[x,y] )>
gap> Display( iota );
Source:
A row module over Q[x,y] of rank 1

Matrix:
1

Range:
A row module over Q[x,y] of rank 1

A morphism in Rows( Q[x,y] )

A morphism in the slice category given by the above data
gap> iota = InternalHom( J, iota );
true
gap> IsIsomorphism( iota );
true
gap> Display( Source( iota ) );
Source:
A row module over Q[x,y] of rank 1

Matrix:
1

Range:
A row module over Q[x,y] of rank 1

A morphism in Rows( Q[x,y] )

An object in the slice category given by the above data
gap> Source( iota ) = Target( iota );
true

4.3-4 Double pushout rewriting

Double pushout in the slice category of SkeletalFinSets over its subobject classifier.

gap> LoadPackage( "SubcategoriesForCAP" );
true
gap> omega := SubobjectClassifier( SkeletalFinSets );
|2|
gap> S := SliceCategory( omega );
A slice category of SkeletalFinSets
gap> k := omega;
|2|
gap> K := MapOfFinSets( k, [ 1, 0 ], omega ) / S;
An object in the slice category given by: |2| → |2|
gap> l := FinSet( 6 );
|6|
gap> L := MapOfFinSets( l, [ 1, 0, 1, 0, 0, 1 ], omega ) / S;
An object in the slice category given by: |6| → |2|
gap> r := FinSet( 7 );
|7|
gap> R := MapOfFinSets( r, [ 1, 0, 0, 1, 1, 0, 0 ], omega ) / S;
An object in the slice category given by: |7| → |2|
gap> lambda := AsSliceCategoryCell( K, MapOfFinSets( k, [ 0, 1 ], l ), L );
A morphism in the slice category given by: |2| → |6|
gap> rho := AsSliceCategoryCell( K, MapOfFinSets( k, [ 0, 1 ], r ), R );
A morphism in the slice category given by: |2| → |7|
gap> g := FinSet( 8 );
|8|
gap> G := MapOfFinSets( g, [ 1, 0, 1, 0, 0, 1, 1, 1 ], omega ) / S;
An object in the slice category given by: |8| → |2|
gap> mu := AsSliceCategoryCell( L, MapOfFinSets( l, [ 0, 1, 2, 3, 4, 5 ], g ), G );
A morphism in the slice category given by: |6| → |8|
gap> poc := PushoutComplement( lambda, mu );
A morphism in the slice category given by: |4| → |8|
gap> Display( poc );
{ 0,..., 3 } ⱶ[ 0, 1, 6, 7 ]→ { 0,..., 7 }

A morphism in the slice category given by the above data
gap> Display( Source( poc ) );
{ 0,..., 3 } ⱶ[ 1, 0, 1, 1 ]→ { 0, 1 }

An object in the slice category given by the above data
gap> dpo := DPO( mu, lambda, rho );
[ A morphism in the slice category given by: |4| → |9|,
  A morphism in the slice category given by: |7| → |9| ]
gap> Display( dpo[1] );
{ 0,..., 3 } ⱶ[ 0, 1, 2, 3 ]→ { 0,..., 8 }

A morphism in the slice category given by the above data
gap> Display( dpo[2] );
{ 0,..., 6 } ⱶ[ 0, 1, 4, 5, 6, 7, 8 ]→ { 0,..., 8 }

A morphism in the slice category given by the above data
gap> Display( Target( dpo[1] ) );
{ 0,..., 8 } ⱶ[ 1, 0, 1, 1, 0, 1, 1, 0, 0 ]→ { 0, 1 }

An object in the slice category given by the above data

4.3-5 Precompilation

gap> LoadPackage( "SubcategoriesForCAP" );
true
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> ZZZ := HomalgRingOfIntegers( );;
gap> # HomalgIdentityMatrix( size, ring ) * matrix -> matrix
> CapJitAddLogicTemplate(
>     rec(
>         variable_names := [ "size", "ring", "matrix" ],
>         src_template := "HomalgIdentityMatrix( size, ring ) * matrix",
>         dst_template := "matrix",
>         needed_packages := [ [ "MatricesForHomalg", ">= 2020.05.19" ] ],
>     )
> );
gap> CapJitAddLogicTemplate(
>     rec(
>         variable_names := [ "matrix", "dimension", "ring" ],
>         src_template := "matrix * HomalgIdentityMatrix( dimension, ring )",
>         dst_template := "matrix",
>     )
> );
gap> # we do not use SliceCategoryOverTensorUnit because that installs more operations
> # which we are not interested in for this simple test
> category_constructor := ring ->
>     SliceCategory(
>         TensorUnit(
>             CategoryOfRows( ring : FinalizeCategory := true )
>         )
>     );;
gap> given_arguments := [ ZZZ ];;
gap> compiled_category_name := "SliceCategoryOfCategoryOfRowsOfRingOfIntegersOverTensorUnitPrecompiled";;
gap> package_name := "SubcategoriesForCAP";;
gap> CapJitPrecompileCategoryAndCompareResult(
>     category_constructor,
>     given_arguments,
>     package_name,
>     compiled_category_name
>     : operations := "primitive",
>     number_of_objectified_objects_in_data_structure_of_object := 3,
>     number_of_objectified_morphisms_in_data_structure_of_object := 1,
>     number_of_objectified_objects_in_data_structure_of_morphism := 6,
>     number_of_objectified_morphisms_in_data_structure_of_morphism := 4
> );

4 Slice categories (eager data structure)

4.1 GAP categories

4.1-1 IsEagerSliceCategory

4.1-2 IsCellInAnEagerSliceCategory

4.1-3 IsObjectInAnEagerSliceCategory

4.1-4 IsMorphismInAnEagerSliceCategory

4.1-5 IsEagerSliceCategoryOverTensorUnit

4.1-6 IsCellInAnEagerSliceCategoryOverTensorUnit

4.1-7 IsObjectInAnEagerSliceCategoryOverTensorUnit