‣ TestCartesianBraidingForInvertibility( cat, obj_1, obj_2 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are three objects obj_1, obj_2 in a braided cartesian category cat. The output is true if the braiding is invertible, false otherwise.
‣ TestCartesianBraidingCompatibility( cat, obj_1, obj_2, obj_3 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are three objects obj_1, obj_2, obj_3 in a braided cartesian category cat. The output is true if the braiding compatabilities with the associator hold, false otherwise.
‣ TestCartesianBraidingCompatibilityForAllTriplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a braided cartesian category cat. The output is true if the braiding compatabilities with the associator hold for all triples of objects in L, otherwise false.
‣ BraidedCartesianCategoriesTest( cat, a, b ) | ( function ) |
The arguments are
a CAP category cat
objects a, b
This function checks for every operation declared in BraidedCartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ TestCocartesianBraidingForInvertibility( cat, obj_1, obj_2 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are three objects obj_1, obj_2 in a braided cocartesian category cat. The output is true if the braiding is invertible, false otherwise.
‣ TestCocartesianBraidingCompatibility( cat, obj_1, obj_2, obj_3 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are three objects obj_1, obj_2, obj_3 in a braided cocartesian category cat. The output is true if the braiding compatabilities with the associator hold, false otherwise.
‣ TestCocartesianBraidingCompatibilityForAllTriplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a braided cocartesian category cat. The output is true if the braiding compatabilities with the associator hold for all triples of objects in L, otherwise false.
‣ BraidedCocartesianCategoriesTest( cat, a, b ) | ( function ) |
The arguments are
a CAP category cat
objects a, b
This function checks for every operation declared in BraidedCocartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ TestCartesianUnitorsForInvertibility( cat, obj ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj in a cartesian category cat. The output is true if the left and right unitors are invertible for obj.
‣ TestCartesianAssociatorForInvertibility( cat, obj_1, obj_2, obj_3 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj_1, obj_2, obj_3 in a cartesian category cat. The output is true if the associator are invertible for these 3 objects, false otherwise.
‣ TestCartesianTriangleIdentity( cat, obj_1, obj_2 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj_1, obj_2 in a cartesian category cat. The output is true if the triangle identity holds for these 2 objects, false otherwise.
‣ TestCartesianTriangleIdentityForAllPairsInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a cartesian category cat. The output is true if the triangle identity holds for all pairs of objects in L, otherwise false.
‣ TestCartesianPentagonIdentity( cat, obj_1, obj_2, obj_3, obj_4 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are 4 objects obj_1, obj_2, obj_3, obj_4 in a cartesian category cat. The output is true if the pentagon identity holds for these 4 objects, false otherwise.
‣ TestCartesianPentagonIdentityUsingWithGivenOperations( cat, obj_1, obj_2, obj_3, obj_4 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are 4 objects obj_1, obj_2, obj_3, obj_4 in a cartesian category cat. The output is true if the pentagon identity holds for these 4 objects, false otherwise. This test uses the WithGiven-operations.
‣ TestCartesianPentagonIdentityForAllQuadruplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a cartesian category cat. The output is true if the pentagon identity holds for all quadruples of objects in L, otherwise false.
‣ CartesianCategoriesTest( cat, a, b, c, alpha, beta ) | ( function ) |
The arguments are
a CAP category cat
objects a, b, c
a morphism \alpha: a \rightarrow b
a morphism \beta: c \rightarrow d
This function checks for every operation declared in CartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ CartesianClosedCategoriesTest( cat, a, b, c, d, alpha, beta, gamma, delta, epsilon, zeta ) | ( function ) |
The arguments are
a CAP category cat
objects a, b, c, d
a morphism \alpha: a \rightarrow b
a morphism \beta: c \rightarrow d
a morphism \gamma: a \times b \rightarrow 1
a morphism \delta: c \times d \rightarrow 1
a morphism \epsilon: 1 \rightarrow \mathrm{Hom}(a,b)
a morphism \zeta: 1 \rightarrow \mathrm{Hom}(c,d)
This function checks for every operation declared in CartesianClosedCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ TestCocartesianUnitorsForInvertibility( cat, obj ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj in a cocartesian category cat. The output is true if the left and right unitors are invertible for obj.
‣ TestCocartesianAssociatorForInvertibility( cat, obj_1, obj_2, obj_3 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj_1, obj_2, obj_3 in a cocartesian category cat. The output is true if the associator are invertible for these 3 objects, false otherwise.
‣ TestCocartesianTriangleIdentity( cat, obj_1, obj_2 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects obj_1, obj_2 in a cocartesian category cat. The output is true if the triangle identity holds for these 2 objects, false otherwise.
‣ TestCocartesianTriangleIdentityForAllPairsInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a cocartesian category cat. The output is true if the triangle identity holds for all pairs of objects in L, otherwise false.
‣ TestCocartesianPentagonIdentity( cat, obj_1, obj_2, obj_3, obj_4 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are 4 objects obj_1, obj_2, obj_3, obj_4 in a cocartesian category cat. The output is true if the pentagon identity holds for these 4 objects, false otherwise.
‣ TestCocartesianPentagonIdentityUsingWithGivenOperations( cat, obj_1, obj_2, obj_3, obj_4 ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are 4 objects obj_1, obj_2, obj_3, obj_4 in a cocartesian category cat. The output is true if the pentagon identity holds for these 4 objects, false otherwise. This test uses the WithGiven-operations.
‣ TestCocartesianPentagonIdentityForAllQuadruplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list L of objects in a cocartesian category cat. The output is true if the pentagon identity holds for all quadruples of objects in L, otherwise false.
‣ CocartesianCategoriesTest( cat, a, b, c, alpha, beta ) | ( function ) |
The arguments are
a CAP category cat
objects a, b, c
a morphism \alpha: a \rightarrow b
a morphism \beta: c \rightarrow d
This function checks for every operation declared in CocartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ CocartesianCoclosedCategoriesTest( cat, a, b, c, d, alpha, beta, gamma, delta, epsilon, zeta ) | ( function ) |
The arguments are
a CAP category cat
objects a, b, c, d
a morphism \alpha: a \rightarrow b
a morphism \beta: c \rightarrow d
a morphism \gamma: 1 \rightarrow a \sqcup b
a morphism \delta: 1 \rightarrow c \sqcup d
a morphism \epsilon: \mathrm{coHom}(a,b) \rightarrow 1
a morphism \zeta: \mathrm{coHom}(c,d) \rightarrow 1
This function checks for every operation declared in CocartesianCoclosedCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ CodistributiveCocartesianCategoriesTest( cat, a, L ) | ( function ) |
The arguments are
a CAP category cat
an object a
a list L of objects
This function checks for every operation declared in CodistributiveCocartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
‣ DistributiveCartesianCategoriesTest( cat, a, L ) | ( function ) |
The arguments are
a CAP category cat
an object a
a list L of objects
This function checks for every operation declared in DistributiveCartesianCategories.gd if it is computable in the CAP category cat. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of cat. Pass the options
verbose := true to output more information.
only_primitive_operations := true, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in cat. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.
gap> LoadPackage( "CartesianCategories", false ); true gap> distributive := DummyCategory( rec( > list_of_operations_to_install := > ListOfDefiningOperations( "IsBicartesianClosedCategory" ), > properties := [ "IsBicartesianClosedCategory", "IsSkeletalCategory" ] ) );; gap> InfoOfInstalledOperationsOfCategory( distributive ); 21 primitive operations were used to derive 121 operations for this category \ which algorithmically * IsBicartesianClosedCategory and not yet algorithmically * IsDistributiveCategory and furthermore mathematically * IsSkeletalCategory
generated by GAPDoc2HTML