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

2 Futher CAP operations
 2.1 MorphismBetweenCoproducts and MorphismBetweenDirectProducts
 2.2 Projective covers and injective envelopes
 2.3 IsWeakTerminal and IsWeakInitial
 2.4 RelativeLift/RelativeColift
 2.5 Biased relative weak fiber product
 2.6 EmbeddingOfSumOfImagesOfAllMorphisms
 2.7 Systems of homogeneous linear equations in linear categories
 2.8 Limit
 2.9 Colimit
 2.10 Add-methods

  2.10-1 AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory

  2.10-2 AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory

  2.10-3 AddBiasedRelativeWeakFiberProduct

  2.10-4 AddColimit

  2.10-5 AddEmbeddingOfSumOfImagesOfAllMorphisms

  2.10-6 AddInjectionOfCofactorOfColimit

  2.10-7 AddInjectionOfCofactorOfColimitWithGivenColimit

  2.10-8 AddIsWeakInitial

  2.10-9 AddIsWeakTerminal

  2.10-10 AddLimit

  2.10-11 AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory

  2.10-12 AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory

  2.10-13 AddMorphismBetweenCoproducts

  2.10-14 AddMorphismBetweenCoproductsWithGivenCoproducts

  2.10-15 AddMorphismBetweenDirectProducts

  2.10-16 AddMorphismBetweenDirectProductsWithGivenDirectProducts

  2.10-17 AddMorphismOntoSumOfImagesOfAllMorphisms

  2.10-18 AddProjectionInFactorOfLimit

  2.10-19 AddProjectionInFactorOfLimitWithGivenLimit

  2.10-20 AddProjectionOfBiasedRelativeWeakFiberProduct

  2.10-21 AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct

  2.10-22 AddRelativeLift

  2.10-23 AddSetOfMorphismsOfFiniteCategory

  2.10-24 AddSetOfObjectsOfCategory

  2.10-25 AddSumOfImagesOfAllMorphisms

  2.10-26 AddUniversalMorphismFromColimit

  2.10-27 AddUniversalMorphismFromColimitWithGivenColimit

  2.10-28 AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct

  2.10-29 AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct

  2.10-30 AddUniversalMorphismIntoLimit

  2.10-31 AddUniversalMorphismIntoLimitWithGivenLimit

2 Futher CAP operations

2.1 MorphismBetweenCoproducts and MorphismBetweenDirectProducts

2.1-1 MorphismBetweenCoproducts
‣ MorphismBetweenCoproducts( diagram_S, F, diagram_T )( operation )

Returns: a morphism in \mathrm{Hom}(\sqcup_{i=0}^{m-1}A_i, \sqcup_{j=0}^{n-1} B_j)

The arguments are given as follows:

The output is the morphism \sqcup_{i=0}^{m-1} A_i \rightarrow \sqcup_{j=0}^{n-1} B_j defined by the pair F.

gap> LoadPackage( "ToolsForCategoricalTowers" );
true
gap> LoadPackage( "Toposes", ">= 2024.02-08", false );
true
gap> LoadPackage( "FinSetsForCAP", ">= 2024.02-09", false );
true
gap> sFinSets := SkeletalCategoryOfFiniteSets( );
SkeletalFinSets
gap> Display( sFinSets );
A CAP category with name SkeletalFinSets:

58 primitive operations were used to derive 350 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsElementaryTopos
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> a := FinSet( sFinSets, 2 );
|2|
gap> b := FinSet( sFinSets, 3 );
|3|
gap> beta := CocartesianBraiding( a, b );
|5| → |5|
gap> Display( beta );
{ 0,..., 4 } ⱶ[ 3, 4, 0, 1, 2 ]→ { 0,..., 4 }
gap> id_a := IdentityMorphism( a );
|2| → |2|
gap> id_b := IdentityMorphism( b );
|3| → |3|
gap> f := Pair( [ 1, 0 ], [ id_a, id_b ] );
[ [ 1, 0 ], [ |2| → |2|, |3| → |3| ] ]
gap> beta2 := MorphismBetweenCoproducts( [ a, b ], f, [ b, a ] );
|5| → |5|
gap> beta2 = beta;
true
gap> W := WrapperCategory( sFinSets,
>              rec( only_primitive_operations := false ) );
WrapperCategory( SkeletalFinSets )
gap> Display( W );
A CAP category with name WrapperCategory( SkeletalFinSets ):

326 primitive operations were used to derive 340 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsElementaryTopos
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> W_a := a / W;
<An object in WrapperCategory( SkeletalFinSets )>
gap> W_b := b / W;
<An object in WrapperCategory( SkeletalFinSets )>
gap> W_beta := CocartesianBraiding( W_a, W_b );
<A morphism in WrapperCategory( SkeletalFinSets )>
gap> MorphismDatum( W_beta ) = beta;
true
gap> W_id_a := IdentityMorphism( W_a );
<An identity morphism in WrapperCategory( SkeletalFinSets )>
gap> W_id_b := IdentityMorphism( W_b );
<An identity morphism in WrapperCategory( SkeletalFinSets )>
gap> W_f := Pair( [ 1, 0 ], [ W_id_a, W_id_b ] );;
gap> W_beta2 := MorphismBetweenCoproducts( [ W_a, W_b ], W_f, [ W_b, W_a ] );
<A morphism in WrapperCategory( SkeletalFinSets )>
gap> W_beta2 = W_beta;
true
gap> O := Opposite( sFinSets );
Opposite( SkeletalFinSets )
gap> Display( O );
A CAP category with name Opposite( SkeletalFinSets ):

259 primitive operations were used to derive 275 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsBicartesianCoclosedCategory
* IsFiniteBicompleteCategory
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> O_a := a / O;
<An object in Opposite( SkeletalFinSets )>
gap> O_b := b / O;
<An object in Opposite( SkeletalFinSets )>
gap> O_beta := CartesianBraiding( O_b, O_a );
<A morphism in Opposite( SkeletalFinSets )>
gap> MorphismDatum( O_beta ) = beta;
true
gap> O_id_a := IdentityMorphism( O_a );
<An identity morphism in Opposite( SkeletalFinSets )>
gap> O_id_b := IdentityMorphism( O_b );
<An identity morphism in Opposite( SkeletalFinSets )>
gap> O_f := Pair( [ 1, 0 ], [ O_id_a, O_id_b ] );;
gap> O_beta2 := MorphismBetweenDirectProducts( [ O_b, O_a ], O_f, [ O_a, O_b ] );
<A morphism in Opposite( SkeletalFinSets )>
gap> O_beta2 = O_beta;
true

2.1-2 MorphismBetweenCoproductsWithGivenCoproducts
‣ MorphismBetweenCoproductsWithGivenCoproducts( S, diagram_S, F, diagram_T, T )( operation )

Returns: a morphism in \mathrm{Hom}(\sqcup_{i=0}^{m-1}A_i, \sqcup_{j=0}^{n-1} B_j)

The arguments are given as follows:

The output is the morphism \sqcup_{i=0}^{m-1} A_i \rightarrow \sqcup_{j=0}^{n-1} B_j defined by the pair F.

2.1-3 MorphismBetweenDirectProducts
‣ MorphismBetweenDirectProducts( diagram_S, F, diagram_T )( operation )

Returns: a morphism in \mathrm{Hom}(\times_{i=0}^{m-1}A_i, \times_{j=0}^{n-1} B_j)

The arguments are given as follows:

The output is the morphism \times_{i=0}^{m-1} A_i \rightarrow \times_{j=0}^{n-1} B_j defined by the pair F.

gap> LoadPackage( "ToolsForCategoricalTowers" );
true
gap> LoadPackage( "Toposes", ">= 2024.02-08", false );
true
gap> LoadPackage( "FinSetsForCAP", ">= 2024.02-09", false );
true
gap> sFinSets := SkeletalCategoryOfFiniteSets( );
SkeletalFinSets
gap> Display( sFinSets );
A CAP category with name SkeletalFinSets:

58 primitive operations were used to derive 350 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsElementaryTopos
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> a := FinSet( sFinSets, 2 );
|2|
gap> b := FinSet( sFinSets, 3 );
|3|
gap> beta := CartesianBraiding( a, b );
|6| → |6|
gap> Display( beta );
{ 0,..., 5 } ⱶ[ 0, 3, 1, 4, 2, 5 ]→ { 0,..., 5 }
gap> id_a := IdentityMorphism( a );
|2| → |2|
gap> id_b := IdentityMorphism( b );
|3| → |3|
gap> f := Pair( [ 1, 0 ], [ id_b, id_a ] );
[ [ 1, 0 ], [ |3| → |3|, |2| → |2| ] ]
gap> beta2 := MorphismBetweenDirectProducts( [ a, b ], f, [ b, a ] );
|6| → |6|
gap> beta2 = beta;
true
gap> W := WrapperCategory( sFinSets,
>              rec( only_primitive_operations := false ) );
WrapperCategory( SkeletalFinSets )
gap> Display( W );
A CAP category with name WrapperCategory( SkeletalFinSets ):

326 primitive operations were used to derive 340 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsElementaryTopos
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> W_a := a / W;
<An object in WrapperCategory( SkeletalFinSets )>
gap> W_b := b / W;
<An object in WrapperCategory( SkeletalFinSets )>
gap> W_beta := CartesianBraiding( W_a, W_b );
<A morphism in WrapperCategory( SkeletalFinSets )>
gap> MorphismDatum( W_beta ) = beta;
true
gap> W_id_a := IdentityMorphism( W_a );
<An identity morphism in WrapperCategory( SkeletalFinSets )>
gap> W_id_b := IdentityMorphism( W_b );
<An identity morphism in WrapperCategory( SkeletalFinSets )>
gap> W_f := Pair( [ 1, 0 ], [ W_id_b, W_id_a ] );;
gap> W_beta2 := MorphismBetweenDirectProducts( [ W_a, W_b ], W_f, [ W_b, W_a ] );
<A morphism in WrapperCategory( SkeletalFinSets )>
gap> W_beta2 = W_beta;
true
gap> O := Opposite( sFinSets );
Opposite( SkeletalFinSets )
gap> Display( O );
A CAP category with name Opposite( SkeletalFinSets ):

259 primitive operations were used to derive 275 operations for this category
which algorithmically
* IsCategoryWithDecidableColifts
* IsCategoryWithDecidableLifts
* IsEquippedWithHomomorphismStructure
* IsBicartesianCoclosedCategory
* IsFiniteBicompleteCategory
and furthermore mathematically
* IsSkeletalCategory
* IsStrictCartesianCategory
* IsStrictCocartesianCategory
gap> O_a := a / O;
<An object in Opposite( SkeletalFinSets )>
gap> O_b := b / O;
<An object in Opposite( SkeletalFinSets )>
gap> O_beta := CocartesianBraiding( O_b, O_a );
<A morphism in Opposite( SkeletalFinSets )>
gap> MorphismDatum( O_beta ) = beta;
true
gap> O_id_a := IdentityMorphism( O_a );
<An identity morphism in Opposite( SkeletalFinSets )>
gap> O_id_b := IdentityMorphism( O_b );
<An identity morphism in Opposite( SkeletalFinSets )>
gap> O_f := Pair( [ 1, 0 ], [ O_id_b, O_id_a ] );;
gap> O_beta2 := MorphismBetweenCoproducts( [ O_b, O_a ], O_f, [ O_a, O_b ] );
<A morphism in Opposite( SkeletalFinSets )>
gap> O_beta2 = O_beta;
true

2.1-4 MorphismBetweenDirectProductsWithGivenDirectProducts
‣ MorphismBetweenDirectProductsWithGivenDirectProducts( S, diagram_S, F, diagram_T, T )( operation )

Returns: a morphism in \mathrm{Hom}(\times_{i=0}^{m-1}A_i, \times_{j=0}^{n-1} B_j)

The arguments are given as follows:

The output is the morphism \times_{i=0}^{m-1} A_i \rightarrow \times_{j=0}^{n-1} B_j defined by the pair F.

2.2 Projective covers and injective envelopes

2.3 IsWeakTerminal and IsWeakInitial

2.3-1 IsWeakTerminal
‣ IsWeakTerminal( a )( property )

Returns: a boolean

The argument is an object a of a category \mathbf{C}. The output is true if a is weak terminal \mathbf{C}, otherwise the output is false.

2.3-2 IsWeakInitial
‣ IsWeakInitial( a )( property )

Returns: a boolean

The argument is an object a of a category \mathbf{C}. The output is true if a is weak initial in \mathbf{C}, otherwise the output is false.

2.4 RelativeLift/RelativeColift

2.4-1 RelativeLift
‣ RelativeLift( beta, alpha, nu )( operation )

Returns: a morphism in \mathrm{Hom}(b,a) + \{ \mathtt{fail} \}

The arguments are two morphisms \beta: b \rightarrow c, \alpha: a \rightarrow c, and \nu: d \rightarrow c . The output is a relative lift \beta / \alpha: b \rightarrow a of \beta along \alpha modulo \nu. if such a relative lift exists or \mathtt{fail} if it doesn't. Recall that a relative lift \beta / \alpha: b \rightarrow a of \beta along \alpha modulo \nu is a morphism such that \alpha \circ (\beta / \alpha) \sim_{b,c} \beta + \chi \nu, for some morphism \chi: b \rightarrow d.

2.5 Biased relative weak fiber product

For a given pair of morphisms (\alpha: A \rightarrow B, \beta \colon C \rightarrow B), a biased relative weak fiber product of (\alpha, \beta) consists of three parts:

The triple ( P, \pi, u ) is called a biased relative weak fiber product of (\alpha,\beta). We denote the object P of such a triple by \mathrm{BiasedRelativeWeakFiberProduct}(\alpha,\beta). We say that the morphism u(\tau) is induced by the universal property of the biased relative weak fiber product.

2.5-1 BiasedRelativeWeakFiberProduct
‣ BiasedRelativeWeakFiberProduct( alpha, beta, sigma )( operation )

Returns: an object

The arguments are two morphisms \alpha: A \rightarrow B, \beta: C \rightarrow B. The output is the biased relative weak fiber product P of \alpha and \beta.

2.5-2 ProjectionOfBiasedRelativeWeakFiberProduct
‣ ProjectionOfBiasedRelativeWeakFiberProduct( alpha, beta, sigma )( operation )

Returns: a morphism in \mathrm{Hom}( P, A )

The arguments are three morphisms \alpha: A \rightarrow B, \beta: C \rightarrow B, \sigma: D \rightarrow A. The output is the biased relative weak fiber product projection \pi: P \rightarrow A.

2.5-3 ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct
‣ ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( alpha, beta, sigma, P )( operation )

Returns: a morphism in \mathrm{Hom}( P, A )

The arguments are two morphisms \alpha: A \rightarrow B, \beta: C \rightarrow B, \sigma: D \rightarrow A, and an object P = \mathrm{BiasedRelativeWeakFiberProduct}( \alpha, \beta ). The output is the biased relative weak fiber product projection \pi: P \rightarrow A.

2.5-4 UniversalMorphismIntoBiasedRelativeWeakFiberProduct
‣ UniversalMorphismIntoBiasedRelativeWeakFiberProduct( alpha, beta, sigma, tau )( operation )

Returns: a morphism in \mathrm{Hom}( T, P )

The arguments are three morphisms \alpha: A \rightarrow B, \beta: C \rightarrow B, \sigma: D \rightarrow A, \tau: T \rightarrow A. The output is the morphism u( \tau ) induced by the universal property of the biased relative weak fiber product P of \alpha and \beta.

2.5-5 UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct
‣ UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( alpha, beta, sigma, tau, P )( operation )

Returns: a morphism in \mathrm{Hom}( T, P )

The arguments are three morphisms \alpha: A \rightarrow B, \beta: C \rightarrow B, \tau: T \rightarrow A and an object P = \mathrm{BiasedRelativeWeakFiberProduct}( \alpha, \beta ). The output is the morphism u( \tau ) induced by the universal property of the biased relative weak fiber product P of \alpha and \beta.

2.6 EmbeddingOfSumOfImagesOfAllMorphisms

2.6-1 MorphismOntoSumOfImagesOfAllMorphisms
‣ MorphismOntoSumOfImagesOfAllMorphisms( a, b )( operation )

Returns: a morphism

Return a morphism onto the sum of images of all morphisms between a and b.

2.6-2 EmbeddingOfSumOfImagesOfAllMorphisms
‣ EmbeddingOfSumOfImagesOfAllMorphisms( a, b )( operation )

Returns: a morphism

Return the embedding of the sum of images of all morphisms between a and b.

2.6-3 SumOfImagesOfAllMorphisms
‣ SumOfImagesOfAllMorphisms( a, b )( operation )

Returns: a morphism

Return the sum of images of all morphisms between a and b.

2.7 Systems of homogeneous linear equations in linear categories

2.7-1 MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory
‣ MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory( left_coeffs, right_coeffs, right_side )( operation )

Returns: a boolean

Like SolveLinearSystemInAbCategory, but the output is simply true if a unique solution exists, and false otherwise.

2.7-2 MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory
‣ MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( left_coeffs, right_coeffs )( operation )

Returns: a boolean

Like BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory, but the output is true if the homogeneous system has only the trivial solution, and false otherwise.

2.7-3 BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory
‣ BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( alpha, beta )( operation )

Returns: a list of lists of morphisms [X^1, \dots, X^t]

The arguments are two lists of lists \alpha and \beta of morphisms in a linear category over a commutative ring k. The first list \alpha (the left coefficients) is a list of list of morphisms \alpha_{ij}: A_i \rightarrow B_j, where i = 1, \dots, m and j = 1, \dots, n for integers m,n \geq 1. The second list \beta (the right coefficients) is a list of list of morphisms \beta_{ij}: C_j \rightarrow D_i, where i = 1, \dots, m and j = 1, \dots, n. The output is a generating set [X^1,\dots,X^t] for the solutions of the homogeneous linear system: \sum_{j = 1}^n \alpha_{ij}\cdot X_{j} \cdot \beta_{ij} = 0, ~i = 1, \dots, m. Particularly, each X^k is a list (of length n) of morphisms X^k_j:B_j \to C_j, j=1,\dots,n.

2.7-4 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory
‣ BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( alpha, beta, gamma, delta )( operation )

Returns: a list of lists of morphisms [X^1, \dots, X^t]

The arguments are four lists of lists \alpha, \beta, \gamma, \delta of morphisms in some linear category over commutative ring. Each of \alpha and \gamma is a list of list of morphisms \alpha_{ij}, \gamma_{ij}: A_i \rightarrow B_j, where i = 1, \dots, m and j = 1, \dots, n for integers m,n \geq 1. Each of \beta and \delta is also a list of list of morphisms \beta_{ij}, \delta_{ij}: C_j \rightarrow D_i, where i = 1, \dots, m and j = 1, \dots, n. The output is a generating set [X^1,\dots,X^t] for the solutions of the homogeneous linear system defined by \alpha, \beta, \gamma and \delta, i.e., \sum_{j = 1}^n \alpha_{ij}\cdot X^{k}_{j} \cdot \beta_{ij} = \sum_{j = 1}^n \gamma_{ij}\cdot X^{k}_{j} \cdot \delta_{ij} for all i = 1, \dots, m and all k = 1, \dots, t.

2.7-5 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory
‣ BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( alpha, delta )( operation )

Returns: a list of lists of morphisms [X^1, \dots, X^t]

The arguments are two lists of lists \alpha, \delta morphisms in some linear category over commutative ring. \alpha is a list of list of morphisms \alpha_{ij}:A_i \rightarrow B_j and \delta is a list of list of morphisms \delta_{ij}:C_j \rightarrow D_i, where i = 1, \dots, m and j = 1, \dots, n for integers m,n \geq 1. The method delegates to BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory applied on \alpha, \beta, \gamma, \delta where

for all i = 1, \dots, m and j = 1, \dots, n.

gap> LoadPackage( "ToolsForCategoricalTowers" );
true
gap> LoadPackage( "FreydCategoriesForCAP" );
true
gap> QQ := HomalgFieldOfRationals();
Q
gap> QQ_rows := CategoryOfRows( QQ );
Rows( Q )
gap> t := TensorUnit( QQ_rows );
<A row module over Q of rank 1>
gap> id_t := IdentityMorphism( t );
<An identity morphism in Rows( Q )>
gap> 1*(11)*7 + 2*(12)*8 + 3*(13)*9;
620
gap> 4*(11)*3 + 5*(12)*4 + 6*(13)*1;
450
gap> alpha_s :=  [ [ 1 , 2 , 3  ], [ 4 , 5 , 6  ] ] * id_t;;
gap> beta_s := [ [ 7 , 8 , 9  ], [ 3 , 4 , 1  ] ] * id_t;;
gap> gamma_s := [ 620 , 450  ] * id_t;;
gap> MereExistenceOfSolutionOfLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s, gamma_s );
true
gap> MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s, gamma_s );
false
gap> x := SolveLinearSystemInAbCategory( QQ_rows, alpha_s, beta_s, gamma_s );;
gap> 1*x[1]*7 + 2*x[2]*8 + 3*x[3]*9 = gamma_s[1];
true
gap> 4*x[1]*3 + 5*x[2]*4 + 6*x[3]*1 = gamma_s[2];
true
gap> MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s );
false
gap> basis := BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory
>                                   ( QQ_rows, alpha_s, beta_s );;
gap> Length( basis );
1
gap> Display( basis[1][1] );
Source:
A row module over Q of rank 1

Matrix:
[ [  111/13 ] ]

Range:
A row module over Q of rank 1

A morphism in Rows( Q )
gap> Display( basis[1][2] );
Source:
A row module over Q of rank 1

Matrix:
[ [  -141/26 ] ]

Range:
A row module over Q of rank 1

A morphism in Rows( Q )
gap> Display( basis[1][3] );
Source:
A row module over Q of rank 1

Matrix:
[ [  1 ] ]

Range:
A row module over Q of rank 1

A morphism in Rows( Q )
gap> 2*(11)*5 + 3*(12)*7 + 9*(13)*2;
596
gap> Add( alpha_s,  [ 2 , 3 , 9  ] * id_t );
gap> Add( beta_s, [ 5 , 7 , 2  ] * id_t );
gap> Add( gamma_s, 596 * id_t );
gap> MereExistenceOfSolutionOfLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s, gamma_s );
true
gap> MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s, gamma_s );
true
gap> x := SolveLinearSystemInAbCategory( QQ_rows, alpha_s, beta_s, gamma_s );;
gap> 1*x[1]*7 + 2*x[2]*8 + 3*x[3]*9 = gamma_s[1];
true
gap> 4*x[1]*3 + 5*x[2]*4 + 6*x[3]*1 = gamma_s[2];
true
gap> 2*x[1]*5 + 3*x[2]*7 + 9*x[3]*2 = gamma_s[3];
true
gap> MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory
>                                   ( QQ_rows, alpha_s, beta_s );
true
gap> basis := BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory
>                                   ( QQ_rows, alpha_s, beta_s );
[ ]

2.8 Limit

2.8-1 LimitPair
‣ LimitPair( cat, objs, decorated_mors )( operation )

Returns: a pair of morphisms

The input is

The output is a pair consisting of an object in cat and two parallel morphisms having this object as source, such that the binary equalizer of the two morphisms is the limit of the diagram.

2.8-2 Limit
‣ Limit( objs, decorated_mors )( operation )

Returns: an object

The input is a finite diagram (or subquiver) D (in a category cat) consisting of

The output is the limit object \mathrm{Limit}(D) of the diagram D.

2.8-3 ProjectionInFactorOfLimit
‣ ProjectionInFactorOfLimit( objects, decorated_morphisms, k )( operation )

Returns: a morphism in \mathrm{Hom}( P, P_k )

The input is

The output is the projection of the limit object P := \mathrm{Limit}(D) of the diagram D into the k-th objects P_k =objs[k].

2.8-4 ProjectionInFactorOfLimitWithGivenLimit
‣ ProjectionInFactorOfLimitWithGivenLimit( objects, decorated_morphisms, k, P )( operation )

Returns: a morphism in \mathrm{Hom}( P, P_k )

The input is

The output is the projection of the limit object P :=\mathrm{Limit}(D) into P_k =objs[k].

2.8-5 UniversalMorphismIntoLimit
‣ UniversalMorphismIntoLimit( objects, decorated_morphisms, T, tau )( operation )

Returns: a morphism in \mathrm{Hom}( T, \mathrm{Limit}(D) )

The input is

The output is the morphism u( \tau ): T \rightarrow \mathrm{Limit}(D) given by the universal property of the limit.

2.8-6 UniversalMorphismIntoLimitWithGivenLimit
‣ UniversalMorphismIntoLimitWithGivenLimit( objects, decorated_morphisms, T, tau, P )( operation )

Returns: a morphism in \mathrm{Hom}( T, P )

The input is

The output is the morphism u( \tau ): T \rightarrow P = \mathrm{Limit}(D) given by the universal property of the limit.

2.9 Colimit

2.9-1 ColimitPair
‣ ColimitPair( cat, objs, decorated_mors )( operation )

Returns: a pair of morphisms

The input is

The output is a pair consisting of an object in cat and two parallel morphisms having this object as range, such that the binary coequalizer of the two morphisms is the colimit of the diagram.

2.9-2 Colimit
‣ Colimit( objs, decorated_mors )( operation )

Returns: an object

The input is a finite diagram (or subquiver) D (in a category cat) consisting of

The output is the colimit object \mathrm{Colimit}(D) of the diagram D.

2.9-3 InjectionOfCofactorOfColimit
‣ InjectionOfCofactorOfColimit( objects, decorated_morphisms, k )( operation )

Returns: a morphism in \mathrm{Hom}( P_k, P )

The input is

The output is the injection of the k-th objects P_k =objs[k] into the colimit object P := \mathrm{Colimit}(D) of the diagram D.

2.9-4 InjectionOfCofactorOfColimitWithGivenColimit
‣ InjectionOfCofactorOfColimitWithGivenColimit( objects, decorated_morphisms, k, P )( operation )

Returns: a morphism in \mathrm{Hom}( P_k, P )

The input is

The output is the projection of P_k =objs[k] into the colimit object P :=\mathrm{Colimit}(D).

2.9-5 UniversalMorphismFromColimit
‣ UniversalMorphismFromColimit( objects, decorated_morphisms, T, tau )( operation )

Returns: a morphism in \mathrm{Hom}( \mathrm{Colimit}(D), T )

The input is

The output is the morphism u( \tau ): \mathrm{Colimit}(D) \rightarrow T given by the universal property of the colimit.

2.9-6 UniversalMorphismFromColimitWithGivenColimit
‣ UniversalMorphismFromColimitWithGivenColimit( objects, decorated_morphisms, T, tau, P )( operation )

Returns: a morphism in \mathrm{Hom}( P, T )

The input is

The output is the morphism u( \tau ): P = \mathrm{Colimit}(D) \rightarrow T given by the universal property of the colimit.

2.9-7 PositionsOfSublist
‣ PositionsOfSublist( superlist, sublist[, from] )( function )

Returns: a list of integers

returns all indices 1 \leq i \leq Length(superlist) at which a sublist (of superlist) equal to sublist starts. If sublist does not occur the output is the empty-list. The version with given from starts searching after the position from.

2.9-8 AllCoproducts
‣ AllCoproducts( cat, objects )( operation )

Returns: a list of objects

The input is a category cat and a list of objects therein, such that the list L of all possible finite coproducts is finite. The output is the list L.

2.10 Add-methods

2.10-1 AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory
‣ AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory. F: ( arg2, arg3, arg4, arg5 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2, arg3, arg4, arg5).

2.10-2 AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory
‣ AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory. F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2, arg3).

2.10-3 AddBiasedRelativeWeakFiberProduct
‣ AddBiasedRelativeWeakFiberProduct( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation BiasedRelativeWeakFiberProduct. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{BiasedRelativeWeakFiberProduct}(arg2, arg3, arg4).

2.10-4 AddColimit
‣ AddColimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Colimit. F: ( objects, decorated_morphisms ) \mapsto \mathtt{Colimit}(objects, decorated_morphisms).

2.10-5 AddEmbeddingOfSumOfImagesOfAllMorphisms
‣ AddEmbeddingOfSumOfImagesOfAllMorphisms( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation EmbeddingOfSumOfImagesOfAllMorphisms. F: ( a, b ) \mapsto \mathtt{EmbeddingOfSumOfImagesOfAllMorphisms}(a, b).

2.10-6 AddInjectionOfCofactorOfColimit
‣ AddInjectionOfCofactorOfColimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfColimit. F: ( objects, decorated_morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfColimit}(objects, decorated_morphisms, k).

2.10-7 AddInjectionOfCofactorOfColimitWithGivenColimit
‣ AddInjectionOfCofactorOfColimitWithGivenColimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation InjectionOfCofactorOfColimitWithGivenColimit. F: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfColimitWithGivenColimit}(objects, decorated_morphisms, k, P).

2.10-8 AddIsWeakInitial
‣ AddIsWeakInitial( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWeakInitial. F: ( arg2 ) \mapsto \mathtt{IsWeakInitial}(arg2).

2.10-9 AddIsWeakTerminal
‣ AddIsWeakTerminal( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation IsWeakTerminal. F: ( arg2 ) \mapsto \mathtt{IsWeakTerminal}(arg2).

2.10-10 AddLimit
‣ AddLimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation Limit. F: ( objects, decorated_morphisms ) \mapsto \mathtt{Limit}(objects, decorated_morphisms).

2.10-11 AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory
‣ AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory. F: ( arg2, arg3 ) \mapsto \mathtt{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2, arg3).

2.10-12 AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory
‣ AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory. F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4).

2.10-13 AddMorphismBetweenCoproducts
‣ AddMorphismBetweenCoproducts( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenCoproducts. F: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenCoproducts}(source_diagram, pair, range_diagram).

2.10-14 AddMorphismBetweenCoproductsWithGivenCoproducts
‣ AddMorphismBetweenCoproductsWithGivenCoproducts( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenCoproductsWithGivenCoproducts. F: ( S, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenCoproductsWithGivenCoproducts}(S, source_diagram, pair, range_diagram, T).

2.10-15 AddMorphismBetweenDirectProducts
‣ AddMorphismBetweenDirectProducts( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectProducts. F: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectProducts}(source_diagram, pair, range_diagram).

2.10-16 AddMorphismBetweenDirectProductsWithGivenDirectProducts
‣ AddMorphismBetweenDirectProductsWithGivenDirectProducts( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismBetweenDirectProductsWithGivenDirectProducts. F: ( S, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectProductsWithGivenDirectProducts}(S, source_diagram, pair, range_diagram, T).

2.10-17 AddMorphismOntoSumOfImagesOfAllMorphisms
‣ AddMorphismOntoSumOfImagesOfAllMorphisms( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation MorphismOntoSumOfImagesOfAllMorphisms. F: ( a, b ) \mapsto \mathtt{MorphismOntoSumOfImagesOfAllMorphisms}(a, b).

2.10-18 AddProjectionInFactorOfLimit
‣ AddProjectionInFactorOfLimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfLimit. F: ( objects, decorated_morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfLimit}(objects, decorated_morphisms, k).

2.10-19 AddProjectionInFactorOfLimitWithGivenLimit
‣ AddProjectionInFactorOfLimitWithGivenLimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionInFactorOfLimitWithGivenLimit. F: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfLimitWithGivenLimit}(objects, decorated_morphisms, k, P).

2.10-20 AddProjectionOfBiasedRelativeWeakFiberProduct
‣ AddProjectionOfBiasedRelativeWeakFiberProduct( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOfBiasedRelativeWeakFiberProduct. F: ( a, b, c ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProduct}(a, b, c).

2.10-21 AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct
‣ AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct. F: ( a, b, c, P ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, P).

2.10-22 AddRelativeLift
‣ AddRelativeLift( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation RelativeLift. F: ( beta, alpha, nu ) \mapsto \mathtt{RelativeLift}(beta, alpha, nu).

2.10-23 AddSetOfMorphismsOfFiniteCategory
‣ AddSetOfMorphismsOfFiniteCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SetOfMorphismsOfFiniteCategory. F: ( ) \mapsto \mathtt{SetOfMorphismsOfFiniteCategory}().

2.10-24 AddSetOfObjectsOfCategory
‣ AddSetOfObjectsOfCategory( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SetOfObjectsOfCategory. F: ( ) \mapsto \mathtt{SetOfObjectsOfCategory}().

2.10-25 AddSumOfImagesOfAllMorphisms
‣ AddSumOfImagesOfAllMorphisms( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation SumOfImagesOfAllMorphisms. F: ( arg2, arg3 ) \mapsto \mathtt{SumOfImagesOfAllMorphisms}(arg2, arg3).

2.10-26 AddUniversalMorphismFromColimit
‣ AddUniversalMorphismFromColimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromColimit. F: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromColimit}(objects, decorated_morphisms, T, tau).

2.10-27 AddUniversalMorphismFromColimitWithGivenColimit
‣ AddUniversalMorphismFromColimitWithGivenColimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismFromColimitWithGivenColimit. F: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromColimitWithGivenColimit}(objects, decorated_morphisms, T, tau, P).

2.10-28 AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoBiasedRelativeWeakFiberProduct. F: ( a, b, c, t ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProduct}(a, b, c, t).

2.10-29 AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct. F: ( a, b, c, t, P ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, t, P).

2.10-30 AddUniversalMorphismIntoLimit
‣ AddUniversalMorphismIntoLimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoLimit. F: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoLimit}(objects, decorated_morphisms, T, tau).

2.10-31 AddUniversalMorphismIntoLimitWithGivenLimit
‣ AddUniversalMorphismIntoLimitWithGivenLimit( C, F )( operation )

Returns: nothing

The arguments are a category C and a function F. This operation adds the given function F to the category for the basic operation UniversalMorphismIntoLimitWithGivenLimit. F: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoLimitWithGivenLimit}(objects, decorated_morphisms, T, tau, P).

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

generated by GAPDoc2HTML