‣ 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:
diagram_S is a list of objects (A_i)_{i = 0 \dots m - 1},
diagram_T is a list of objects (B_j)_{j = 0 \dots n - 1},
F is a pair consisting of a list f = (f_i)_{i = 0 \dots m - 1} of length m of integers between 0, \ldots, n - 1 and a list of morphisms ( A_i \rightarrow B_{f_i} )_{i = 0 \dots m - 1}.
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 348 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 ): 324 primitive operations were used to derive 338 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 ): 257 primitive operations were used to derive 273 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
‣ 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:
diagram_S is a list of objects (A_i)_{i = 0 \dots m - 1},
diagram_T is a list of objects (B_j)_{j = 0 \dots n - 1},
S is the coproduct \sqcup_{i=0}^{m-1} A_i,
T is the coproduct \sqcup_{j=0}^{n-1} B_j,
F is a pair consisting of a list f = (f_i)_{i = 0 \dots m - 1} of length m of integers between 0, \ldots, n - 1 and a list of morphisms ( A_i \rightarrow B_{f_i} )_{i = 0 \dots m - 1}.
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.
‣ 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:
diagram_S is a list of objects (A_i)_{i = 0 \dots m - 1},
diagram_T is a list of objects (B_j)_{j = 0 \dots n - 1},
F is a pair consisting of a list f = (f_j)_{j = 0 \dots n - 1} of length n of integers between 0, \ldots, m - 1 and a list of morphisms ( A_{f_j} \rightarrow B_j )_{j = 0 \dots n - 1}.
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 348 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 ): 324 primitive operations were used to derive 338 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 ): 257 primitive operations were used to derive 273 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
‣ 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:
diagram_S is a list of objects (A_i)_{i = 0 \dots m - 1},
diagram_T is a list of objects (B_j)_{j = 0 \dots n - 1},
S is the product \times_{i=0}^{m-1} A_i,
T is the product \times_{j=0}^{n-1} B_j,
F is a pair consisting of a list f = (f_j)_{j = 0 \dots n - 1} of length n of integers between 0, \ldots, m - 1 and a list of morphisms ( A_{f_j} \rightarrow B_j )_{j = 0 \dots n - 1}.
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.
‣ 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.
‣ 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.
‣ 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 such that a relative lift \beta / \alpha: b \rightarrow a of \beta along \alpha modulo \nu exists. Such a relative lift is returned. 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.
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:
an object P,
a morphism \pi: P \rightarrow A such that there exists a morphism \delta: P \rightarrow C such that \beta \circ \delta \sim_{P,B} \alpha \circ \pi,
a dependent function u mapping each \tau: T \rightarrow A, which admits a morphism \mu \colon T \rightarrow C with \beta \circ \mu \sim_{T,B} \alpha \circ \tau, to a morphism u(\tau):T \rightarrow P such that \pi \circ u(\tau) \sim_{T,A} \tau.
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.
‣ 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.
‣ 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.
‣ 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.
‣ 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.
‣ 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.
‣ MorphismOntoSumOfImagesOfAllMorphisms( a, b ) | ( operation ) |
Returns: a morphism
Return a morphism onto the sum of images of all morphisms between a and b.
‣ EmbeddingOfSumOfImagesOfAllMorphisms( a, b ) | ( operation ) |
Returns: a morphism
Return the embedding of the sum of images of all morphisms between a and b.
‣ SumOfImagesOfAllMorphisms( a, b ) | ( operation ) |
Returns: a morphism
Return the sum of images of all morphisms between a and b.
‣ 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.
‣ 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.
‣ 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.
‣ 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.
‣ 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
\beta_{ij} equals IdentityMorphism(Source(\delta_{ij})) if \delta_{ij} is an endomorphism, and ZeroMorphism(Source(\delta_{ij}), Range(\delta_{ij})) otherwise,
\gamma_{ij} equals IdentityMorphism(Source(\alpha_{ij})) if \alpha_{ij} is an endomorphism, and ZeroMorphism(Source(\alpha_{ij}), Range(\alpha_{ij})) otherwise;
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 ); [ ]
‣ LimitPair( cat, objs, decorated_mors ) | ( operation ) |
Returns: a pair of morphisms
The input is
a category cat and
a finite diagram (or subquiver) in cat given by
a list objs of objects in cat, and
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat.
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.
‣ Limit( objs, decorated_mors ) | ( operation ) |
Returns: an object
The input is a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs of objects in cat and
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat.
The output is the limit object \mathrm{Limit}(D) of the diagram D.
‣ ProjectionInFactorOfLimit( objects, decorated_morphisms, k ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( P, P_k )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat, and
a positive integer k.
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].
‣ ProjectionInFactorOfLimitWithGivenLimit( objects, decorated_morphisms, k, P ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( P, P_k )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a positive integer k, and
an object P= \mathrm{Limit}(D).
The output is the projection of the limit object P :=\mathrm{Limit}(D) into P_k =objs[k].
‣ UniversalMorphismIntoLimit( objects, decorated_morphisms, T, tau ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( T, \mathrm{Limit}(D) )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a test object T, and
a list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) in cat defining a cone over D.
The output is the morphism u( \tau ): T \rightarrow \mathrm{Limit}(D) given by the universal property of the limit.
‣ UniversalMorphismIntoLimitWithGivenLimit( objects, decorated_morphisms, T, tau, P ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( T, P )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a test object T,
a list of morphisms \tau = ( \tau_i: T \rightarrow P_i ) in cat defining a cone over D, and
an object P= \mathrm{Limit}(D).
The output is the morphism u( \tau ): T \rightarrow P = \mathrm{Limit}(D) given by the universal property of the limit.
‣ ColimitPair( cat, objs, decorated_mors ) | ( operation ) |
Returns: a pair of morphisms
The input is
a category cat and
a finite diagram (or subquiver) in cat given by
a list objs of objects in cat, and
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat.
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.
‣ Colimit( objs, decorated_mors ) | ( operation ) |
Returns: an object
The input is a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs of objects in cat and
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat.
The output is the colimit object \mathrm{Colimit}(D) of the diagram D.
‣ InjectionOfCofactorOfColimit( objects, decorated_morphisms, k ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( P_k, P )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat, and
a positive integer k.
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.
‣ InjectionOfCofactorOfColimitWithGivenColimit( objects, decorated_morphisms, k, P ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( P_k, P )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a positive integer k, and
an object P= \mathrm{Colimit}(D).
The output is the projection of P_k =objs[k] into the colimit object P :=\mathrm{Colimit}(D).
‣ UniversalMorphismFromColimit( objects, decorated_morphisms, T, tau ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( \mathrm{Colimit}(D), T )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a test object T, and
a list of morphisms \tau = ( \tau_i: P_i \rightarrow T ) in cat defining a cocone over D.
The output is the morphism u( \tau ): \mathrm{Colimit}(D) \rightarrow T given by the universal property of the colimit.
‣ UniversalMorphismFromColimitWithGivenColimit( objects, decorated_morphisms, T, tau, P ) | ( operation ) |
Returns: a morphism in \mathrm{Hom}( P, T )
The input is
a finite diagram (or subquiver) D (in a category cat) consisting of
a list objs = (P_i)_{i = 1 \dots n} of objects in cat,
a list decorated_mors of triples [ i, mor, j ], where mor:objs[i] \to objs[j] is a morphism in cat,
a test object T,
a list of morphisms \tau = ( \tau_i: P_i \rightarrow T ) in cat defining a cocone over D, and
an object P= \mathrm{Colimit}(D).
The output is the morphism u( \tau ): P = \mathrm{Colimit}(D) \rightarrow T given by the universal property of the colimit.
‣ 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.
‣ 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.
‣ AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( C, F ) | ( operation ) |
‣ AddBasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4, arg5 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory}(arg2, arg3, arg4, arg5).
‣ AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( C, F ) | ( operation ) |
‣ AddBasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory}(arg2, arg3).
‣ AddBiasedRelativeWeakFiberProduct( C, F ) | ( operation ) |
‣ AddBiasedRelativeWeakFiberProduct( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4 ) \mapsto \mathtt{BiasedRelativeWeakFiberProduct}(arg2, arg3, arg4).
‣ AddColimit( C, F ) | ( operation ) |
‣ AddColimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms ) \mapsto \mathtt{Colimit}(objects, decorated_morphisms).
‣ AddEmbeddingOfSumOfImagesOfAllMorphisms( C, F ) | ( operation ) |
‣ AddEmbeddingOfSumOfImagesOfAllMorphisms( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b ) \mapsto \mathtt{EmbeddingOfSumOfImagesOfAllMorphisms}(a, b).
‣ AddInjectionOfCofactorOfColimit( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfColimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, k ) \mapsto \mathtt{InjectionOfCofactorOfColimit}(objects, decorated_morphisms, k).
‣ AddInjectionOfCofactorOfColimitWithGivenColimit( C, F ) | ( operation ) |
‣ AddInjectionOfCofactorOfColimitWithGivenColimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{InjectionOfCofactorOfColimitWithGivenColimit}(objects, decorated_morphisms, k, P).
‣ AddIsWeakInitial( C, F ) | ( operation ) |
‣ AddIsWeakInitial( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsWeakInitial}(arg2).
‣ AddIsWeakTerminal( C, F ) | ( operation ) |
‣ AddIsWeakTerminal( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2 ) \mapsto \mathtt{IsWeakTerminal}(arg2).
‣ AddLimit( C, F ) | ( operation ) |
‣ AddLimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms ) \mapsto \mathtt{Limit}(objects, decorated_morphisms).
‣ AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( C, F ) | ( operation ) |
‣ AddMereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory}(arg2, arg3).
‣ AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory( C, F ) | ( operation ) |
‣ AddMereExistenceOfUniqueSolutionOfLinearSystemInAbCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3, arg4 ) \mapsto \mathtt{MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory}(arg2, arg3, arg4).
‣ AddMorphismBetweenCoproducts( C, F ) | ( operation ) |
‣ AddMorphismBetweenCoproducts( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenCoproducts}(source_diagram, pair, range_diagram).
‣ AddMorphismBetweenCoproductsWithGivenCoproducts( C, F ) | ( operation ) |
‣ AddMorphismBetweenCoproductsWithGivenCoproducts( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( S, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenCoproductsWithGivenCoproducts}(S, source_diagram, pair, range_diagram, T).
‣ AddMorphismBetweenDirectProducts( C, F ) | ( operation ) |
‣ AddMorphismBetweenDirectProducts( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( source_diagram, pair, range_diagram ) \mapsto \mathtt{MorphismBetweenDirectProducts}(source_diagram, pair, range_diagram).
‣ AddMorphismBetweenDirectProductsWithGivenDirectProducts( C, F ) | ( operation ) |
‣ AddMorphismBetweenDirectProductsWithGivenDirectProducts( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( S, source_diagram, pair, range_diagram, T ) \mapsto \mathtt{MorphismBetweenDirectProductsWithGivenDirectProducts}(S, source_diagram, pair, range_diagram, T).
‣ AddMorphismOntoSumOfImagesOfAllMorphisms( C, F ) | ( operation ) |
‣ AddMorphismOntoSumOfImagesOfAllMorphisms( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b ) \mapsto \mathtt{MorphismOntoSumOfImagesOfAllMorphisms}(a, b).
‣ AddProjectionInFactorOfLimit( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfLimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, k ) \mapsto \mathtt{ProjectionInFactorOfLimit}(objects, decorated_morphisms, k).
‣ AddProjectionInFactorOfLimitWithGivenLimit( C, F ) | ( operation ) |
‣ AddProjectionInFactorOfLimitWithGivenLimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, k, P ) \mapsto \mathtt{ProjectionInFactorOfLimitWithGivenLimit}(objects, decorated_morphisms, k, P).
‣ AddProjectionOfBiasedRelativeWeakFiberProduct( C, F ) | ( operation ) |
‣ AddProjectionOfBiasedRelativeWeakFiberProduct( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b, c ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProduct}(a, b, c).
‣ AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F ) | ( operation ) |
‣ AddProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b, c, P ) \mapsto \mathtt{ProjectionOfBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, P).
‣ AddRelativeLift( C, F ) | ( operation ) |
‣ AddRelativeLift( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( beta, alpha, nu ) \mapsto \mathtt{RelativeLift}(beta, alpha, nu).
‣ AddSetOfMorphismsOfFiniteCategory( C, F ) | ( operation ) |
‣ AddSetOfMorphismsOfFiniteCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{SetOfMorphismsOfFiniteCategory}().
‣ AddSetOfObjectsOfCategory( C, F ) | ( operation ) |
‣ AddSetOfObjectsOfCategory( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( ) \mapsto \mathtt{SetOfObjectsOfCategory}().
‣ AddSumOfImagesOfAllMorphisms( C, F ) | ( operation ) |
‣ AddSumOfImagesOfAllMorphisms( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( arg2, arg3 ) \mapsto \mathtt{SumOfImagesOfAllMorphisms}(arg2, arg3).
‣ AddUniversalMorphismFromColimit( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromColimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismFromColimit}(objects, decorated_morphisms, T, tau).
‣ AddUniversalMorphismFromColimitWithGivenColimit( C, F ) | ( operation ) |
‣ AddUniversalMorphismFromColimitWithGivenColimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismFromColimitWithGivenColimit}(objects, decorated_morphisms, T, tau, P).
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProduct( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b, c, t ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProduct}(a, b, c, t).
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( a, b, c, t, P ) \mapsto \mathtt{UniversalMorphismIntoBiasedRelativeWeakFiberProductWithGivenBiasedRelativeWeakFiberProduct}(a, b, c, t, P).
‣ AddUniversalMorphismIntoLimit( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoLimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, T, tau ) \mapsto \mathtt{UniversalMorphismIntoLimit}(objects, decorated_morphisms, T, tau).
‣ AddUniversalMorphismIntoLimitWithGivenLimit( C, F ) | ( operation ) |
‣ AddUniversalMorphismIntoLimitWithGivenLimit( C, F, weight ) | ( 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. Optionally, a weight (default: 100) can be specified which should roughly correspond to the computational complexity of the function (lower weight = less complex = faster execution). F: ( objects, decorated_morphisms, T, tau, P ) \mapsto \mathtt{UniversalMorphismIntoLimitWithGivenLimit}(objects, decorated_morphisms, T, tau, P).
generated by GAPDoc2HTML