GAP (CAP) - Chapter 4: Objects

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

4 Objects
4.1 Attributes for the Type of Objects
4.1-1 CapCategory
4.2 Equality for Objects
4.2-1 IsEqualForObjects
4.2-2 AddIsEqualForObjects
4.3 Categorical Properties of Objects
4.3-1 AddIsProjective
4.3-2 AddIsInjective
4.3-3 AddIsTerminal
4.3-4 AddIsInitial
4.3-5 IsZeroForObjects
4.3-6 AddIsZeroForObjects
4.4 Tool functions for caches
4.4-1 IsEqualForCacheForObjects
4.4-2 AddIsEqualForCacheForObjects
4.5 Well-Definedness of Objects
4.5-1 IsWellDefinedForObjects
4.5-2 AddIsWellDefinedForObjects
4.6 Projectives
4.6-1 SomeProjectiveObject
4.6-2 EpimorphismFromSomeProjectiveObject
4.6-3 EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
4.6-4 ProjectiveLift
4.6-5 AddSomeProjectiveObject
4.6-6 AddEpimorphismFromSomeProjectiveObject
4.6-7 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject
4.6-8 AddProjectiveLift
4.7 Injectives
4.7-1 SomeInjectiveObject
4.7-2 MonomorphismIntoSomeInjectiveObject
4.7-3 MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject
4.7-4 InjectiveColift
4.7-5 AddSomeInjectiveObject
4.7-6 AddMonomorphismIntoSomeInjectiveObject
4.7-7 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject
4.7-8 AddInjectiveColift

### 4 Objects

Any GAP object which is IsCapCategoryObject can be added to a category and then becomes an object in this category. Any object can belong to one or no category. After a GAP object is added to the category, it knows which things can be computed in its category and to which category it belongs. It knows categorial properties and attributes, and the functions for existential quantifiers can be applied to the object.

#### 4.1 Attributes for the Type of Objects

##### 4.1-1 CapCategory

`‣ CapCategory`( a ) | ( attribute )

Returns: a category

The argument is an object \(a\). The output is the category \(\mathbf{C}\) to which \(a\) was added.

#### 4.2 Equality for Objects

##### 4.2-1 IsEqualForObjects

`‣ IsEqualForObjects`( a, b ) | ( operation )

Returns: a boolean

The arguments are two objects \(a\) and \(b\). The output is `true` if \(a = b\), otherwise the output is `false`.

##### 4.2-2 AddIsEqualForObjects

`‣ AddIsEqualForObjects`( C, F ) | ( operation )

Returns: nothing

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

#### 4.3 Categorical Properties of Objects

##### 4.3-1 AddIsProjective

`‣ AddIsProjective`( C, F ) | ( operation )

Returns: nothing

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

##### 4.3-2 AddIsInjective

`‣ AddIsInjective`( C, F ) | ( operation )

Returns: nothing

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

##### 4.3-3 AddIsTerminal

`‣ AddIsTerminal`( C, F ) | ( operation )

Returns: nothing

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

##### 4.3-4 AddIsInitial

`‣ AddIsInitial`( C, F ) | ( operation )

Returns: nothing

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

##### 4.3-5 IsZeroForObjects

`‣ IsZeroForObjects`( a ) | ( operation )

Returns: a boolean

The argument is an object \(a\) of a category \(\mathbf{C}\). The output is `true` if \(a\) is isomorphic to the zero object of \(\mathbf{C}\), otherwise the output is `false`.

##### 4.3-6 AddIsZeroForObjects

`‣ AddIsZeroForObjects`( C, F ) | ( operation )

Returns: nothing

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

#### 4.4 Tool functions for caches

##### 4.4-1 IsEqualForCacheForObjects

`‣ IsEqualForCacheForObjects`( phi, psi ) | ( operation )

Returns: true or false

Compares two objects in the cache

##### 4.4-2 AddIsEqualForCacheForObjects

`‣ AddIsEqualForCacheForObjects`( c, F ) | ( operation )

Returns: northing

By default, CAP uses caches to store the values of Categorical operations. To get a value out of the cache, one needs to compare the input of a basic operation with its previous input. To compare objects in the category, IsEqualForCacheForObject is used. By default this is an alias for IsEqualForObjects, where fail is substituted by false. If you add a function, this function used instead. A function \(F: a,b \mapsto bool\) is expected here. The output has to be true or false. Fail is not allowed in this context.

#### 4.5 Well-Definedness of Objects

##### 4.5-1 IsWellDefinedForObjects

`‣ IsWellDefinedForObjects`( a ) | ( operation )

Returns: a boolean

The argument is an object \(a\). The output is `true` if \(a\) is well-defined, otherwise the output is `false`.

##### 4.5-2 AddIsWellDefinedForObjects

`‣ AddIsWellDefinedForObjects`( C, F ) | ( operation )

Returns: nothing

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

#### 4.6 Projectives

For a given object \(A\) in an abelian category having enough projectives, the following commands allow us to compute some projective object \(P\) together with an epimorphism \(\pi: P \rightarrow A\).

##### 4.6-1 SomeProjectiveObject

`‣ SomeProjectiveObject`( A ) | ( attribute )

Returns: an object

The argument is an object \(A\). The output is some projective object \(P\) for which there exists an epimorphism \(\pi: P \rightarrow A\).

##### 4.6-2 EpimorphismFromSomeProjectiveObject

`‣ EpimorphismFromSomeProjectiveObject`( A ) | ( attribute )

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

The argument is an object \(A\). The output is an epimorphism \(\pi: P \rightarrow A\) with \(P\) a projective object that equals the output of \(\mathrm{SomeProjectiveObject}(A)\).

##### 4.6-3 EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject

`‣ EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject`( A, P ) | ( operation )

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

The arguments are an object \(A\) and a projective object \(P\) that equals the output of \(\mathrm{SomeProjectiveObject}(A)\). The output is an epimorphism \(\pi: P \rightarrow A\).

##### 4.6-4 ProjectiveLift

`‣ ProjectiveLift`( pi, epsilon ) | ( operation )

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

The arguments are a morphism \(\pi: P \rightarrow A\) with \(P\) a projective, and an epimorphism \(\epsilon: B \rightarrow A\). The output is a morphism \(\lambda: P \rightarrow B\) such that \(\epsilon \circ \lambda = \pi\).

##### 4.6-5 AddSomeProjectiveObject

`‣ AddSomeProjectiveObject`( 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 `SomeProjectiveObject`. \(F: A \mapsto P\).

##### 4.6-6 AddEpimorphismFromSomeProjectiveObject

`‣ AddEpimorphismFromSomeProjectiveObject`( 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 `EpimorphismFromSomeProjectiveObject`. \(F: A \mapsto \pi\).

##### 4.6-7 AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject

`‣ AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject`( 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 `AddEpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject`. \(F: (A,P) \mapsto \pi\).

##### 4.6-8 AddProjectiveLift

`‣ AddProjectiveLift`( C, F ) | ( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operations adds the given function \(F\) to the category for the basic operation `ProjectiveLift`. The function \(F\) maps a pair \((\pi, \epsilon)\) to a projective lift \(\lambda\).

#### 4.7 Injectives

For a given object \(A\) in an abelian category having enough injectives, the following commands allow us to compute some injective object \(I\) together with a monomorphism \(\iota: A \rightarrow I\).

##### 4.7-1 SomeInjectiveObject

`‣ SomeInjectiveObject`( A ) | ( attribute )

Returns: an object

The argument is an object \(A\). The output is some injective object \(I\) for which there exists a monomorphism \(\iota: A \rightarrow I\).

##### 4.7-2 MonomorphismIntoSomeInjectiveObject

`‣ MonomorphismIntoSomeInjectiveObject`( A ) | ( attribute )

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

The argument is an object \(A\). The output is a monomorphism \(\iota: A \rightarrow I\) with \(I\) an injective object that equals the output of \(\mathrm{SomeInjectiveObject}(A)\).

##### 4.7-3 MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject

`‣ MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject`( A, I ) | ( operation )

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

The arguments are an object \(A\) and an injective object \(I\) that equals the output of \(\mathrm{SomeInjectiveObject}(A)\). The output is a monomorphism \(\iota: A \rightarrow I\).

##### 4.7-4 InjectiveColift

`‣ InjectiveColift`( \iota, \beta ) | ( operation )

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

The arguments are a morphism \(\iota: B \rightarrow A\) and \(\beta: B \rightarrow I\) where \(I\) is an injective object. The output is a morphism \(\lambda: A \rightarrow I\) such that \(\lambda \circ \iota = \beta\).

##### 4.7-5 AddSomeInjectiveObject

`‣ AddSomeInjectiveObject`( 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 `SomeInjectiveObject`. \(F: A \mapsto I\).

##### 4.7-6 AddMonomorphismIntoSomeInjectiveObject

`‣ AddMonomorphismIntoSomeInjectiveObject`( 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 `MonomorphismIntoSomeInjectiveObject`. \(F: A \mapsto \pi\).

##### 4.7-7 AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject

`‣ AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject`( 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 `AddMonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject`. \(F: (A,I) \mapsto \pi\).

##### 4.7-8 AddInjectiveColift

`‣ AddInjectiveColift`( C, F ) | ( operation )

Returns: nothing

The arguments are a category \(C\) and a function \(F\). This operations adds the given function \(F\) to the category for the basic operation `InjectiveColift`. The function \(F\) maps a pair \((\iota, \beta)\) to an injective colift \(\lambda\) if it exists, and to `fail` otherwise.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Ind

generated by GAPDoc2HTML