‣ AdditiveMonoidalCategoriesTest( 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 AdditiveMonoidalCategories.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.
‣ TestBraidingForInvertibility( 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 monoidal category \(cat\). The output is true if the braiding is invertible, false otherwise.
‣ TestBraidingCompatibility( 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 monoidal category \(cat\). The output is true if the braiding compatabilities with the associator hold, false otherwise.
‣ TestBraidingCompatibilityForAllTriplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list \(L\) of objects in a braided monoidal category \(cat\). The output is true if the braiding compatabilities with the associator hold for all triples of objects in \(L\), otherwise false.
‣ BraidedMonoidalCategoriesTest( cat, a, b ) | ( function ) |
The arguments are
a CAP category \(cat\)
objects \(a, b\)
This function checks for every operation declared in BraidedMonoidalCategories.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.
‣ ClosedMonoidalCategoriesTest( 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 \otimes b \rightarrow 1\)
a morphism \(\delta: c \otimes 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 ClosedMonoidalCategories.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.
‣ ClosedMonoidalCategoriesTestWithGiven( cat, a, b, c, d, alpha, beta ) | ( 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\)
This function checks for some *WithGiven operations declared in ClosedMonoidalCategories.gd if they are 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.
‣ CoclosedMonoidalCategoriesTest( 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 \otimes b\)
a morphism \(\delta: 1 \rightarrow c \otimes 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 CoclosedMonoidalCategories.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.
‣ CoclosedMonoidalCategoriesTestWithGiven( 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\)
This function checks for some *WithGiven operations declared in CoclosedMonoidalCategories.gd if they are 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.
‣ LeftClosedMonoidalCategoriesTest( 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 \otimes b \rightarrow 1\)
a morphism \(\delta: c \otimes 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 LeftClosedMonoidalCategories.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.
‣ LeftClosedMonoidalCategoriesTestWithGiven( 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\)
This function checks for some *WithGiven operationS declared in LeftClosedMonoidalCategories.gd if they are 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.
‣ LeftCoclosedMonoidalCategoriesTest( 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 \otimes b\)
a morphism \(\delta: 1 \rightarrow c \otimes 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 LeftCoclosedMonoidalCategories.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.
‣ LeftCoclosedMonoidalCategoriesTestWithGiven( 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\)
This function checks for some *WithGiven operations declared in LeftCoclosedMonoidalCategories.gd if they are 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.
‣ MonoidalCategoriesTensorProductOnObjectsAndTensorUnitTest( cat, a, b ) | ( function ) |
The arguments are
a CAP category \(cat\)
objects \(a, b\)
This function checks for every operation declared in MonoidalCategoriesTensorProductOnObjectsAndTensorUnit.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.
‣ TestMonoidalUnitorsForInvertibility( cat, obj ) | ( operation ) |
Returns: a boolean
This is a debug operation. The arguments are two objects \(obj\) in a monoidal category \(cat\). The output is true if the left and right unitors are invertible for \(obj\).
‣ TestAssociatorForInvertibility( 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 monoidal category \(cat\). The output is true if the associator are invertible for these 3 objects, false otherwise.
‣ TestMonoidalTriangleIdentity( 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 monoidal category \(cat\). The output is true if the triangle identity holds for these 2 objects, false otherwise.
‣ TestMonoidalTriangleIdentityForAllPairsInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list \(L\) of objects in a monoidal category \(cat\). The output is true if the triangle identity holds for all pairs of objects in \(L\), otherwise false.
‣ TestMonoidalPentagonIdentity( 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 monoidal category \(cat\). The output is true if the pentagon identity holds for these 4 objects, false otherwise.
‣ TestMonoidalPentagonIdentityUsingWithGivenOperations( 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 monoidal category \(cat\). The output is true if the pentagon identity holds for these 4 objects, false otherwise. This test uses the WithGiven-operations.
‣ TestMonoidalPentagonIdentityForAllQuadruplesInList( cat, L ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is a list \(L\) of objects in a monoidal category \(cat\). The output is true if the pentagon identity holds for all quadruples of objects in \(L\), otherwise false.
‣ MonoidalCategoriesTest( 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 MonoidalCategories.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.
‣ TestZigZagIdentitiesForDual( cat, obj ) | ( operation ) |
Returns: a boolean
This is a debug operation. The argument is an object \(obj\) in a rigid symmetric monoidal category \(cat\). The output is true if the zig zag identity for duals hold, false otherwise.
‣ RigidSymmetricClosedMonoidalCategoriesTest( cat, a, b, c, d, alpha ) | ( function ) |
The arguments are
a CAP category \(cat\)
objects \(a, b, c, d\)
an endomorphism \(\alpha: a \rightarrow a\)
This function checks for every object and morphism declared in RigidSymmetricClosedMonoidalCategories.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.
‣ RigidSymmetricCoclosedMonoidalCategoriesTest( cat, a, b, c, d, alpha ) | ( function ) |
The arguments are
a CAP category \(cat\)
objects \(a, b, c, d\)
an endomorphism \(\alpha: a \rightarrow a\)
This function checks for every object and morphism declared in RigidSymmetricCoclosedMonoidalCategories.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.
generated by GAPDoc2HTML