‣ 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.
‣ 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.
‣ MonoidalCategoriesTensorProductAndUnitTest( cat, a, b ) | ( function ) |
The arguments are
a CAP category cat
objects a, b
This function checks for every operation declared in MonoidalCategoriesTensorProductAndUnit.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.
‣ 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.
‣ 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.
gap> LoadPackage( "MonoidalCategories", false ); true gap> LoadPackage( "LinearAlgebraForCAP", false ); true gap> Q := HomalgFieldOfRationals(); Q gap> a := VectorSpaceObject( 1, Q ); <A vector space object over Q of dimension 1> gap> b := VectorSpaceObject( 2, Q ); <A vector space object over Q of dimension 2> gap> c := VectorSpaceObject( 3, Q ); <A vector space object over Q of dimension 3> gap> z := ZeroObject( CapCategory( a ) ); <A vector space object over Q of dimension 0> gap> alpha := VectorSpaceMorphism( a, [ [ 1, 0 ] ], b ); <A morphism in Category of matrices over Q> gap> beta := VectorSpaceMorphism( b, > [ [ 1, 0, 0 ], [ 0, 1, 0 ] ], c ); <A morphism in Category of matrices over Q> gap> gamma := VectorSpaceMorphism( c, > [ [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 0 ] ], c ); <A morphism in Category of matrices over Q> gap> IsCongruentForMorphisms( > TensorProductOnMorphisms( alpha, beta ), > TensorProductOnMorphisms( beta, alpha ) ); false gap> IsOne( AssociatorRightToLeft( a, b, c ) ); true gap> IsCongruentForMorphisms( > gamma, LambdaElimination( c, c, LambdaIntroduction( gamma ) ) ); true gap> IsZero( TraceMap( gamma ) ); true gap> IsCongruentForMorphisms( > RankMorphism( DirectSum( a, b ) ), RankMorphism( c ) ); true gap> IsOne( Braiding( b, c ) ); false gap> IsOne( PreCompose( Braiding( b, c ), Braiding( c, b ) ) ); true
generated by GAPDoc2HTML