<p>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.</p>
<p>The argument is an object <span class="Math">a</span>. The output is the category <span class="Math">\mathbf{C}</span> to which <span class="Math">a</span> was added.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AddObject</code>( <var class="Arg">category</var>, <var class="Arg">object</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Adds <var class="Arg">object</var> as an object to <var class="Arg">category</var>. If <var class="Arg">object</var> already lies in the filter <code class="code">IsCapCategoryObject</code>, the operation <code class="func">Add</code> (<a href="chap2.html#X824AE09A81D2B184"><span class="RefLink">2.2-1</span></a>) can be used instead.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsCapCategoryObject</code>( <var class="Arg">category</var>, <var class="Arg">value</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: an object</p>
<p>EXPERIMENTAL: This specification might change any time without prior notice. Views <var class="Arg">value</var> as an object in <var class="Arg">category</var>.</p>
<p>EXPERIMENTAL: This specification might change any time without prior notice. Views an object obtained via <code class="func">AsCapCategoryObject</code> (<a href="chap2.html#X7F5D75377B0D54A6"><span class="RefLink">2.2-4</span></a>) as a primitive value again. Here, the word <em>primitive</em> means <em>primitive from the perspective of the category</em>. For example, from the perspective of an opposite category, objects of the underlying category are primitive values. The attribute is chosen according to the object datum type:</p>
<ul>
<li><p>For <code class="code">IsInt</code>, the attribute <code class="code">AsInteger</code> is used.</p>
</li>
<li><p>For <code class="code">IsHomalgMatrix</code>, the attribute <code class="code">AsHomalgMatrix</code> is used.</p>
</li>
</ul>
<p>In all other cases or if no object datum type is given, the attribute <code class="code">AsPrimitiveValue</code> is used.</p>
<p>The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span>. The output is <code class="code">true</code> if <span class="Math">a = b</span>, otherwise the output is <codeclass="code">false</code>.</p>
<p>The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span>. The output is <code class="code">true</code> if <span class="Math">a</span> and <span class="Math">b</span> are isomorphic, that is, if there exists an isomorphism <span class="Math">a \to b</span>, otherwise the output is <code class="code">false</code>.</p>
<p>The arguments are two isomorphic objects <span class="Math">a</span> and <span class="Math">b</span>. The output is an isomorphism <span class="Math">a \to b</span>.</p>
<p>The argument is an object <span class="Math">a</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is a bijective object, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is a projective object, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is an injective object, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span> of a category <span class="Math">\mathbf{C}</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is isomorphic to the terminal object of <span class="Math">\mathbf{C}</span>, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span> of a category <span class="Math">\mathbf{C}</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is isomorphic to the initial object of <span class="Math">\mathbf{C}</span>, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span> of a category <span class="Math">\mathbf{C}</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is isomorphic to the zero object of <span class="Math">\mathbf{C}</span>, otherwise the output is <code class="code">false</code>.</p>
<p>The argument is an object <span class="Math">a</span> of a category <span class="Math">\mathbf{C}</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is isomorphic to the zero object of <span class="Math">\mathbf{C}</span>, otherwise the output is <code class="code">false</code>.</p>
<p>CAP provides two principal methods to generate random objects:</p>
<ul>
<li><p><em>By integers</em>: The integer is simply a parameter that can be used to create a random object.</p>
</li>
<li><p><em>By lists</em>: The list is used when creating a random object would need more than one parameter. Lists offer more flexibility at the expense of the genericity of the methods. This happens because lists that are valid as input in some category may be not valid for other categories. Hence, these operations are not thought to be used in generic categorical algorithms.</p>
<p>The arguments are a category <span class="Math">C</span> and an integer <span class="Math">n</span>. The output is a random object in <span class="Math">C</span>.</p>
<p>The arguments are a category <span class="Math">C</span> and a list <span class="Math">L</span>. The output is a random object in <span class="Math">C</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomObject</code>( <var class="Arg">C</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>These are convenient methods and they, depending on the input, delegate to one of the above methods.</p>
<p>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 <code class="code">IsIdenticalObj</code> in all other cases. If you add a function via <code class="code">AddIsEqualForCacheForObjects</code>, that function is used instead. A function <span class="Math">F: a,b \mapsto bool</span> is expected there. The output has to be true or false. Fail is not allowed in this context.</p>
<p>The arguments are a category <span class="Math">C</span> and an object datum <span class="Math">a</span> (type and semantics of the object datum depend on the category). The output is an object of <span class="Math">C</span> defined by <span class="Math">a</span>. Note that by default this CAP operation is not cached. You can change this behaviour by calling <code class="code">SetCachingToWeak( C, "ObjectConstructor" )</code> resp. <code class="code">SetCachingToCrisp( C, "ObjectConstructor" )</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjectDatum</code>( <var class="Arg">obj</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: depends on the category</p>
<p>The argument is a CAP category object <var class="Arg">obj</var>. The output is a datum which can be used to construct <var class="Arg">obj</var>, that is, <code class="code">IsEqualForObjects( </code><var class="Arg">obj</var><code class="code">, ObjectConstructor( CapCategory( </code><var class="Arg">obj</var><code class="code"> ), ObjectDatum( </code><var class="Arg">obj</var><code class="code"> ) ) )</code>. Note that by default this CAP operation is not cached. You can change this behaviour by calling <code class="code">SetCachingToWeak( C, "ObjectDatum" )</code> resp. <code class="code">SetCachingToCrisp( C, "ObjectDatum" )</code>.</p>
<p>The argument is an object <span class="Math">a</span>. The output is <code class="code">true</code> if <span class="Math">a</span> is well-defined, otherwise the output is <code class="code">false</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetOfObjects</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of <strong class="pkg">CAP</strong> category objects</p>
<p>Return a duplicate free list of objects of the category <var class="Arg">C</var>. The ordering of the returned list must always be the same. The corresponding <strong class="pkg">CAP</strong> operation is <code class="code">SetOfObjectsOfCategory</code>.</p>
<p>For a given object <span class="Math">A</span> in an abelian category having enough projectives, the following commands allow us to compute some projective object <span class="Math">P</span> together with an epimorphism <span class="Math">\pi: P \rightarrow A</span>.</p>
<p>The argument is an object <span class="Math">A</span>. The output is some projective object <spanclass="Math">P</span> for which there exists an epimorphism <span class="Math">\pi: P \rightarrow A</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EpimorphismFromSomeProjectiveObject</code>( <var class="Arg">A</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(P,A)</span></p>
<p>The argument is an object <span class="Math">A</span>. The output is an epimorphism <span class="Math">\pi: P \rightarrow A</span> with <span class="Math">P</span> a projective object that equals the output of <span class="Math">\mathrm{SomeProjectiveObject}(A)</span>.</p>
<p>The arguments are an object <span class="Math">A</span> and a projective object <span class="Math">P</span> that equals the output of <span class="Math">\mathrm{SomeProjectiveObject}(A)</span>. The output is an epimorphism <span class="Math">\pi: P \rightarrow A</span>.</p>
<p>The arguments are a morphism <span class="Math">\pi: P \rightarrow A</span> with <span class="Math">P</span> a projective, and an epimorphism <span class="Math">\epsilon: B \rightarrow A</span>. The output is a morphism <span class="Math">\lambda: P \rightarrow B</span> such that <span class="Math">\epsilon \circ \lambda = \pi</span>.</p>
<p>For a given object <span class="Math">A</span> in an abelian category having enough injectives, the following commands allow us to compute some injective object <span class="Math">I</span> together with a monomorphism <span class="Math">\iota: A \rightarrow I</span>.</p>
<p>The argument is an object <span class="Math">A</span>. The output is some injective object <span class="Math">I</span> for which there exists a monomorphism <span class="Math">\iota: A \rightarrow I</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MonomorphismIntoSomeInjectiveObject</code>( <var class="Arg">A</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(I,A)</span></p>
<p>The argument is an object <span class="Math">A</span>. The output is a monomorphism <span class="Math">\iota: A \rightarrow I</span> with <span class="Math">I</span> an injective object that equals the output of <span class="Math">\mathrm{SomeInjectiveObject}(A)</span>.</p>
<p>The arguments are an object <span class="Math">A</span> and an injective object <span class="Math">I</span> that equals the output of <span class="Math">\mathrm{SomeInjectiveObject}(A)</span>. The output is a monomorphism <span class="Math">\iota: A \rightarrow I</span>.</p>
<p>The arguments are a monomorphism <span class="Math">\iota: B \rightarrow A</span> and a morphism <span class="Math">\beta: B \rightarrow I</span> where <span class="Math">I</span> is an injective object. The output is a morphism <span class="Math">\lambda: A \rightarrow I</span> such that <spanclass="Math">\lambda \circ \iota = \beta</span>.</p>
<p>Let <span class="Math">i</span> be a positive integer or <span class="Math">\infty</span>. For a given object <span class="Math">A</span>, an <span class="Math">i</span>-th simplified object of <spanclass="Math">A</span> consists of</p>
</li>
<li><p>an isomorphism <span class="Math">\iota_A^i: A \rightarrow A_i</span>.</p>
</li>
</ul>
<p>The idea is that the greater the <span class="Math">i</span>, the "simpler" the <span class="Math">A_i</span> (but this could mean the harder the computation) with <span class="Math">\infty</span> as a possible value.</p>
<p>The arguments are an object <span class="Math">A</span> and a positive integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified object <span class="Math">A_i</span>.</p>
<p>The arguments are an object <span class="Math">A</span> and a positive integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is an isomorphism to a simplified object <span class="Math">\iota_A^i: A \rightarrow A_i</span>.</p>
<p>The arguments are an object <span class="Math">A</span> and a positive integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is an isomorphism from a simplified object <span class="Math">(\iota_A^i)^{-1}: A_i \rightarrow A</span> which is the inverse of the output of <code class="code">SimplifyObject_IsoFromInputObject</code>.</p>
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
