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

2 Objects
 2.1 Attributes for the Type of Objects
 2.2 Equality for Objects
 2.3 Categorical Properties of Objects
 2.4 Random Objects
 2.5 Tool functions for caches
 2.6 Adding Objects to a Category
 2.7 Well-Definedness of Objects
 2.8 Projectives
 2.9 Injectives
 2.10 Simplified Objects

2 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.

2.1 Attributes for the Type of Objects

2.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.

2.2 Equality for Objects

2.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.

2.2-2 AddIsEqualForObjects
‣ AddIsEqualForObjects( 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 IsEqualForObjects. \(F: (a,b) \mapsto \mathtt{IsEqualForObjects}(a,b)\).

2.3 Categorical Properties of Objects

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

Returns: a boolean

The argument is an object \(a\). The output is true if \(a\) is a projective object, otherwise the output is false.

2.3-2 AddIsProjective
‣ AddIsProjective( 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 IsProjective. \(F: a \mapsto \mathtt{IsProjective}(a)\).

2.3-3 IsInjective
‣ IsInjective( a )( property )

Returns: a boolean

The argument is an object \(a\). The output is true if \(a\) is an injective object, otherwise the output is false.

2.3-4 AddIsInjective
‣ AddIsInjective( 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 IsInjective. \(F: a \mapsto \mathtt{IsInjective}(a)\).

2.3-5 IsTerminal
‣ IsTerminal( a )( property )

Returns: a boolean

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

2.3-6 AddIsTerminal
‣ AddIsTerminal( 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 IsTerminal. \(F: a \mapsto \mathtt{IsTerminal}(a)\).

2.3-7 IsInitial
‣ IsInitial( a )( property )

Returns: a boolean

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

2.3-8 AddIsInitial
‣ AddIsInitial( 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 IsInitial. \(F: a \mapsto \mathtt{IsInitial}(a)\).

2.3-9 IsZeroForObjects
‣ IsZeroForObjects( a )( property )

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.

2.3-10 IsZero
‣ IsZero( a )( property )

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.

2.3-11 AddIsZeroForObjects
‣ AddIsZeroForObjects( 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 IsZeroForObjects. \(F: a \mapsto \mathtt{IsZeroForObjects}(a)\).

2.4 Random Objects

CAP provides two principal methods to generate random objects:

2.4-1 RandomObjectByInteger
‣ RandomObjectByInteger( C, n )( operation )

Returns: an object or fail

The arguments are a category \(C\) and an integer \(n\). The output is a random object in \(C\) or fail.

2.4-2 AddRandomObjectByInteger
‣ AddRandomObjectByInteger( 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 RandomObjectByInteger. The function \(F\) maps \((C,n)\) to fail or to a random object in \(C\).

2.4-3 RandomObjectByList
‣ RandomObjectByList( C, L )( operation )

Returns: an object or fail

The arguments are a category \(C\) and a list \(L\). The output is a random object in \(C\) or fail.

2.4-4 AddRandomObjectByList
‣ AddRandomObjectByList( 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 RandomObjectByList. The function \(F\) maps \((C,L)\) to fail or to a random object in \(C\).

2.4-5 RandomObject
‣ RandomObject( C, n )( operation )
‣ RandomObject( C, L )( operation )

These are convenient methods and they, depending on the input, delegate to one of the above methods.

2.5 Tool functions for caches

2.5-1 IsEqualForCacheForObjects
‣ IsEqualForCacheForObjects( phi, psi )( operation )

Returns: true or false

Compares two objects in the cache

2.5-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, IsEqualForCacheForObjects is used. By default, IsEqualForCacheForObjects falls back to IsEqualForCache (see ToolsForHomalg), which in turn defaults to recursive comparison for lists and IsIdenticalObj in all other cases. 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.

2.6 Adding Objects to a Category

2.6-1 Add
‣ Add( category, object )( operation )

Adds object as an object to category.

2.6-2 AddObject
‣ AddObject( category, object )( operation )

Adds object as an object to category. If object already lies in the filter IsCapCategoryObject, the operation Add (2.6-1) can be used instead.

2.6-3 AddObjectRepresentation
‣ AddObjectRepresentation( category, filter )( operation )

The argument filter is used to create an object type for the category category, which is then used in ObjectifyObjectForCAPWithAttributes to objectify objects for this category.

2.6-4 ObjectifyObjectForCAPWithAttributes
‣ ObjectifyObjectForCAPWithAttributes( object, category[, attribute1, value1, ...] )( function )

Returns: an object

Objectifies the object object with the type created for objects in the category category. The type is created by passing a representation to AddObjectRepresentation. Objects which are objectified using this method do not have to be passed to the AddObject function. The optional arguments behave like the corresponding arguments in ObjectifyWithAttributes. Also returns the objectified object.

2.7 Well-Definedness of Objects

2.7-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.

2.7-2 AddIsWellDefinedForObjects
‣ AddIsWellDefinedForObjects( 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 IsWellDefinedForObjects. \(F: a \mapsto \mathtt{IsWellDefinedForObjects}( a )\).

2.8 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\).

2.8-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\).

2.8-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)\).

2.8-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\).

2.8-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\).

2.8-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\).

2.8-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\).

2.8-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\).

2.8-8 AddProjectiveLift
‣ AddProjectiveLift( 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 ProjectiveLift. The function \(F\) maps a pair \((\pi, \epsilon)\) to a projective lift \(\lambda\).

2.9 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\).

2.9-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\).

2.9-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)\).

2.9-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\).

2.9-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\).

2.9-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\).

2.9-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\).

2.9-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\).

2.9-8 AddInjectiveColift
‣ AddInjectiveColift( 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 InjectiveColift. The function \(F\) maps a pair \((\iota, \beta)\) to an injective colift \(\lambda\) if it exists, and to fail otherwise.

2.10 Simplified Objects

Let \(i\) be a positive integer or \(\infty\). For a given object \(A\), an \(i\)-th simplified object of \(A\) consists of

The idea is that the greater the \(i\), the "simpler" the \(A_i\) (but this could mean the harder the computation) with \(\infty\) as a possible value.

2.10-1 Simplify
‣ Simplify( A )( attribute )

Returns: an object

The argument is an object \(A\). The output is a simplified object \(A_{\infty}\).

2.10-2 SimplifyObject
‣ SimplifyObject( A, i )( operation )

Returns: an object

The arguments are an object \(A\) and a positive integer \(i\) or infinity. The output is a simplified object \(A_i\).

2.10-3 AddSimplifyObject
‣ AddSimplifyObject( 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 SimplifyObject. The function \(F\) maps \((A,i)\) to \(A_i\).

2.10-4 SimplifyObject_IsoFromInputObject
‣ SimplifyObject_IsoFromInputObject( A, i )( operation )

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

The arguments are an object \(A\) and a positive integer \(i\) or infinity. The output is an isomorphism to a simplified object \(\iota_A^i: A \rightarrow A_i\).

2.10-5 AddSimplifyObject_IsoFromInputObject
‣ AddSimplifyObject_IsoFromInputObject( 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 SimplifyObject_IsoFromInputObject. The function \(F\) maps \((A,i)\) to \(\iota_A^i\).

2.10-6 SimplifyObject_IsoToInputObject
‣ SimplifyObject_IsoToInputObject( A, i )( operation )

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

The arguments are an object \(A\) and a positive integer \(i\) or infinity. The output is an isomorphism from a simplified object \((\iota_A^i)^{-1}: A_i \rightarrow A\) which is the inverse of the output of SimplifyObject_IsoFromInputObject.

2.10-7 AddSimplifyObject_IsoToInputObject
‣ AddSimplifyObject_IsoToInputObject( 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 SimplifyObject_IsoToInputObject. The function \(F\) maps \((A,i)\) to \((\iota_A^i)^{-1}\).

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

generated by GAPDoc2HTML