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.