Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/cap/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 22.8.2025 mit Größe 71 kB image not shown  

SSL chap1_mj.html   Sprache: HTML

 
 products/Sources/formale Sprachen/GAP/pkg/cap/doc/chap1_mj.html


<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<script type="text/javascript"
  src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (CAP) - Chapter 1: CAP Categories</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap1"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chap8_mj.html">8</a>  <a href="chap9_mj.html">9</a>  <a href="chap10_mj.html">10</a>  <a href="chap11_mj.html">11</a>  <a href="chap12_mj.html">12</a>  <a href="chap13_mj.html">13</a>  <a href="chap14_mj.html">14</a>  <a href="chap15_mj.html">15</a>  <a href="chap16_mj.html">16</a>  <a href="chap17_mj.html">17</a>  <a href="chap18_mj.html">18</a>  <a href="chapInd_mj.html">Ind</a>  </div>

<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap0_mj.html">[Previous Chapter]</a>    <a href="chap2_mj.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap1.html">[MathJax off]</a></p>
<p><a id="X7C99ABCB7DEEDE2A" name="X7C99ABCB7DEEDE2A"></a></p>
<div class="ChapSects"><a href="chap1_mj.html#X7C99ABCB7DEEDE2A">1 <span class="Heading">CAP Categories</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7CC6903E78F24167">1.1 <span class="Heading">Categories</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X80E47D0E86A9F916">1.1-1 IsCapCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7E2CFDC482566454">1.1-2 IsCapCategoryCell</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7DAEF54180094D1E">1.1-3 IsCapCategoryObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X84413C4978765A3F">1.1-4 IsCapCategoryMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7F3B964286D98710">1.1-5 IsCapCategoryTwoCell</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7A853C6D8096E14B">1.2 <span class="Heading">Categorical properties</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7D6EA1307DFCCE46">1.2-1 AddCategoricalProperty</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X806B382F8077EB7B">1.2-2 IsObjectFiniteCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8296B39C789BE6A9">1.2-3 IsFiniteCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8347FF9C81E7385C">1.2-4 IsFinite</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8572BE547C73D308">1.2-5 IsEquivalentToFiniteCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X83F78D2C7AAC115D">1.2-6 IsEquippedWithHomomorphismStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X829DB5497D58C7E5">1.2-7 IsCategoryWithDecidableLifts</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7C22FA787967E694">1.2-8 IsCategoryWithDecidableColifts</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7C2B7A5F87EE5322">1.2-9 IsCategoryWithInitialObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X828327367FA16BDD">1.2-10 IsCategoryWithTerminalObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7BFEEC3779A5EE2F">1.2-11 IsCategoryWithZeroObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8451BCF67F0C4F62">1.2-12 IsCategoryWithEqualizers</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X79D864BB79744E4E">1.2-13 IsCategoryWithCoequalizers</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X82C2B6D37DA78465">1.2-14 IsEnrichedOverCommutativeRegularSemigroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7DBCD7237CF9100A">1.2-15 IsSkeletalCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X79295B4680B0F22B">1.2-16 IsAbCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X861DBAC181A15E1F">1.2-17 IsLinearCategoryOverCommutativeRing</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X86D45F0D7804F023">1.2-18 IsLinearCategoryOverCommutativeRingWithFinitelyGeneratedFreeExternalHoms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7EB29BA681AE1F28">1.2-19 IsCategoryWithKernels</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8226AEFF7F6F7FC3">1.2-20 IsCategoryWithCokernels</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X87C4C37D7F75E681">1.2-21 IsAdditiveCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7A64E2B978685471">1.2-22 IsPreAbelianCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X79DB288F84457967">1.2-23 IsAbelianCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X83EDCC4886FEE4B1">1.2-24 IsAbelianCategoryWithEnoughProjectives</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X860EB7977F78EE3F">1.2-25 IsAbelianCategoryWithEnoughInjectives</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X87AA6D6282FD1C02">1.2-26 IsLocallyOfFiniteProjectiveDimension</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7EDD2B4386ABE96E">1.2-27 IsLocallyOfFiniteInjectiveDimension</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X87434CEF86BC38D4">1.2-28 ListOfDefiningOperations</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7ABF649E831D4D8E">1.3 <span class="Heading">Constructor</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X86EDB84D7E3F0194">1.3-1 CreateCapCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X854CC42E828C120D">1.3-2 CreateCapCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7A1D562178FC3DDF">1.3-3 CreateCapCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8090078F7C5EF5E9">1.3-4 CreateCapCategoryWithDataTypes</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X79CE135F7E6EBFEE">1.4 <span class="Heading">Internal Attributes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X79251D5C85B0F3D3">1.4-1 Name</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7C7B1EAF7D786508">1.4-2 CategoryFilter</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7BD6E2B887F86E9C">1.4-3 ObjectFilter</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7F62E0C47C778CBB">1.4-4 MorphismFilter</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X850D0E978090D0C0">1.4-5 TwoCellFilter</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X834BBE4085A42FAC">1.4-6 ObjectDatumType</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8090D81F78B1F25A">1.4-7 MorphismDatumType</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X850E7C0C807F3402">1.4-8 TwoCellDatumType</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X78D0C0057817DBC3">1.4-9 CommutativeRingOfLinearCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X80AF18E4797A5BB4">1.4-10 RangeCategoryOfHomomorphismStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7CF2F93F8258DAD5">1.4-11 AdditiveGenerators</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7E094E2680348C88">1.4-12 IndecomposableProjectiveObjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X85E6A5AF7DDA4F2C">1.4-13 IndecomposableInjectiveObjects</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X8305A19E86EC7B67">1.5 <span class="Heading">Logic switcher</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X82C32E8C790EAB42">1.5-1 CapCategorySwitchLogicPropagationForObjectsOn</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7FEF6F218491CD45">1.5-2 CapCategorySwitchLogicPropagationForObjectsOff</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X80C98B547A76705D">1.5-3 CapCategorySwitchLogicPropagationForMorphismsOn</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X86469EBF8261E1D4">1.5-4 CapCategorySwitchLogicPropagationForMorphismsOff</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7C06E84F78D82C0D">1.5-5 CapCategorySwitchLogicPropagationOn</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X84F114757E964E1E">1.5-6 CapCategorySwitchLogicPropagationOff</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X84824AC3793D872B">1.5-7 CapCategorySwitchLogicOn</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X84A995A687D031B7">1.5-8 CapCategorySwitchLogicOff</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7A15CCB67FBCF3E3">1.6 <span class="Heading">Tool functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X851D0435816DDB40">1.6-1 CanCompute</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X820DD63180AE4BAB">1.6-2 OperationWeight</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7AA6C5857FB663EB">1.6-3 MissingOperationsForConstructivenessOfCategory</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7DB3D2BD8792ABBC">1.7 <span class="Heading">Well-Definedness of Cells</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X839EA4D7805D4F97">1.7-1 IsWellDefined</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7D2E74CE87255099">1.8 <span class="Heading">Unpacking data structures</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X8790DC5F7A2BD22E">1.8-1 Down</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X858B64487B2DA04E">1.8-2 DownOnlyMorphismData</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7BABD65A821C138F">1.8-3 DownToBottom</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X79DB9EE785F723D1">1.9 <span class="Heading">Caching</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7DB820A686B4059F">1.9-1 SetCachingOfCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X87AA14F27892F14F">1.9-2 SetCachingOfCategoryWeak</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X844903657E52E6D1">1.9-3 SetDefaultCaching</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7EC631BC7CFCF5DB">1.10 <span class="Heading">Sanity checks</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7BB84C7B83FE3D80">1.10-1 DisableInputSanityChecks</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7984C0E986CF0986">1.11 <span class="Heading">Timing statistics</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X86C6F8828628B070">1.11-1 EnableTimingStatistics</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X81A1CDD77D375231">1.12 <span class="Heading">Enable automatic calls of <code class="code">Add</code></span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7C01E3727D08D219">1.12-1 EnableAddForCategoricalOperations</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7876FF1F831F58B0">1.13 <span class="Heading">Performance tweaks</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7B6A66AA7D212DDC">1.14 <span class="Heading">LaTeX</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X831B157D7CC3DDA3">1.14-1 LaTeXOutput</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap1_mj.html#X7B34A09D7AF0F683">1.14-2 LaTeXOutput</a></span>
</div></div>
</div>

<h3>1 <span class="Heading">CAP Categories</span></h3>

<p>Categories are the main GAP objects in CAP. They are used to associate GAP objects which represent objects and morphisms with their category. By associating a GAP object to the category, one of two filters belonging to the category (ObjectFilter/MorphismFilter) are set to true. Via Add methods, functions for specific existential quantifiers can be associated to the category and after that can be applied to GAP objects in the category. A GAP category object also knows which constructions are currently possible in this category.</p>

<p>Classically, a category consists of a class of objects, a set of morphisms, identity morphisms, and a composition function satisfying some simple axioms. In CAP, we use a slightly different notion of a category.</p>

<p>A CAP category <span class="SimpleMath">\(\mathbf{C}\)</span> consists of the following data:</p>


<ul>
<li><p>A set <span class="SimpleMath">\(\mathrm{Obj}_{\mathbf{C}}\)</span> of <em>objects</em>.</p>

</li>
<li><p>For every pair <span class="SimpleMath">\(a,b \in \mathrm{Obj}_{\mathbf{C}}\)</span>, a set <span class="SimpleMath">\(\mathrm{Hom}_{\mathbf{C}}( a, b )\)</span> of <em>morphisms</em>.</p>

</li>
<li><p>For every pair <span class="SimpleMath">\(a,b \in \mathrm{Obj}_{\mathbf{C}}\)</span>, an equivalence relation <span class="SimpleMath">\(\sim_{a,b}\)</span> on <span class="SimpleMath">\(\mathrm{Hom}_{\mathbf{C}}( a, b )\)</span> called <em>congruence for morphisms</em>.</p>

</li>
<li><p>For every <span class="SimpleMath">\(a \in \mathrm{Obj}_{\mathbf{C}}\)</span>, an <em>identity morphism</em> <span class="SimpleMath">\(\mathrm{id}_a \in \mathrm{Hom}_{\mathbf{C}}( a, a )\)</span>.</p>

</li>
<li><p>For every triple <span class="SimpleMath">\(a, b, c \in \mathrm{Obj}_{\mathbf{C}}\)</span>, a <em>composition function</em></p>

<p class="center">\[\circ: \mathrm{Hom}_{\mathbf{C}}( b, c ) \times \mathrm{Hom}_{\mathbf{C}}( a, b ) \rightarrow \mathrm{Hom}_{\mathbf{C}}( a, c )\]</p>

<p>compatible with the congruence, i.e., if <span class="SimpleMath">\(\alpha, \alpha' \in \mathrm{Hom}_{\mathbf{C}}( a, b )\), \(\beta, \beta' \in \mathrm{Hom}_{\mathbf{C}}( b, c )\)</span>, <span class="SimpleMath">\(\alpha \sim_{a,b} \alpha'\) and \(\beta \sim_{b,c} \beta'\)</span>, then <span class="SimpleMath">\(\beta \circ \alpha \sim_{a,c} \beta' \circ \alpha'\)</span>.</p>

</li>
<li><p>For all <span class="SimpleMath">\(a, b \in \mathrm{Obj}_{\mathbf{C}}\)</span>, <span class="SimpleMath">\(\alpha \in \mathrm{Hom}_{\mathbf{C}}( a, b )\)</span>, we have</p>

<p class="center">\[\left( \mathrm{id}_{b} \circ \alpha \right) \sim_{a,b} \alpha\]</p>

<p>and</p>

<p class="center">\[\alpha \sim_{a,b} \left( \alpha \circ \mathrm{id}_{a} \right).\]</p>

</li>
<li><p>For all <span class="SimpleMath">\(a,b,c,d \in \mathrm{Obj}_{\mathbf{C}}\)</span>, <span class="SimpleMath">\(\alpha \in \mathrm{Hom}_{\mathbf{C}}( a, b )\)</span>, <span class="SimpleMath">\(\beta \in \mathrm{Hom}_{\mathbf{C}}( b, c )\)</span>, <span class="SimpleMath">\(\gamma \in \mathrm{Hom}_{\mathbf{C}}( c, d )\)</span>, we have</p>

<p class="center">\[\left(( \gamma \circ \beta ) \circ \alpha \right) \sim_{a,d} \left( \gamma \circ ( \beta \circ \alpha ) \right)\]</p>

</li>
</ul>
<p><a id="X7CC6903E78F24167" name="X7CC6903E78F24167"></a></p>

<h4>1.1 <span class="Heading">Categories</span></h4>

<p><a id="X80E47D0E86A9F916" name="X80E47D0E86A9F916"></a></p>

<h5>1.1-1 IsCapCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCapCategory</code>( <var class="Arg">object</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The GAP category of CAP categories. Objects of this type handle the CAP category information, the caching, and filters for objects in the CAP category. Please note that the object itself is not related to methods, you only need it as a handler and a presentation of the CAP category.</p>

<p><a id="X7E2CFDC482566454" name="X7E2CFDC482566454"></a></p>

<h5>1.1-2 IsCapCategoryCell</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCapCategoryCell</code>( <var class="Arg">object</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The GAP category of CAP category cells. Every object, morphism, and <span class="SimpleMath">\(2\)</span>-cell of a CAP category lies in this GAP category.</p>

<p><a id="X7DAEF54180094D1E" name="X7DAEF54180094D1E"></a></p>

<h5>1.1-3 IsCapCategoryObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCapCategoryObject</code>( <var class="Arg">object</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The GAP category of CAP category objects. Every object of a CAP category lies in this GAP category.</p>

<p><a id="X84413C4978765A3F" name="X84413C4978765A3F"></a></p>

<h5>1.1-4 IsCapCategoryMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCapCategoryMorphism</code>( <var class="Arg">object</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The GAP category of CAP category morphisms. Every morphism of a CAP category lies in this GAP category.</p>

<p><a id="X7F3B964286D98710" name="X7F3B964286D98710"></a></p>

<h5>1.1-5 IsCapCategoryTwoCell</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCapCategoryTwoCell</code>( <var class="Arg">object</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The GAP category of CAP category <span class="SimpleMath">\(2\)</span>-cells. Every <span class="SimpleMath">\(2\)</span>-cell of a CAP category lies in this GAP category.</p>

<p><a id="X7A853C6D8096E14B" name="X7A853C6D8096E14B"></a></p>

<h4>1.2 <span class="Heading">Categorical properties</span></h4>

<p><a id="X7D6EA1307DFCCE46" name="X7D6EA1307DFCCE46"></a></p>

<h5>1.2-1 AddCategoricalProperty</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AddCategoricalProperty</code>( <var class="Arg">list</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Adds a categorical property to the list of CAP categorical properties. <var class="Arg">list</var> must be a list containing one entry, if the property is self dual, or two, if the dual property has a different name. If the first entry of the list is empty and the second is a property name, the property is assumed to have no dual.</p>

<p><a id="X806B382F8077EB7B" name="X806B382F8077EB7B"></a></p>

<h5>1.2-2 IsObjectFiniteCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsObjectFiniteCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The (evil) property of <var class="Arg">C</var> being a category with finitely many objects.</p>

<p><a id="X8296B39C789BE6A9" name="X8296B39C789BE6A9"></a></p>

<h5>1.2-3 IsFiniteCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFiniteCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The (evil) property of <var class="Arg">C</var> being a finite category.</p>

<p><a id="X8347FF9C81E7385C" name="X8347FF9C81E7385C"></a></p>

<h5>1.2-4 IsFinite</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFinite</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>Synonym for <code class="code">IsFiniteCategory</code>.</p>

<p><a id="X8572BE547C73D308" name="X8572BE547C73D308"></a></p>

<h5>1.2-5 IsEquivalentToFiniteCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEquivalentToFiniteCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of <var class="Arg">C</var> being equivalent to a finite category.</p>

<p><a id="X83F78D2C7AAC115D" name="X83F78D2C7AAC115D"></a></p>

<h5>1.2-6 IsEquippedWithHomomorphismStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEquippedWithHomomorphismStructure</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being equipped with a homomorphism structure.</p>

<p><a id="X829DB5497D58C7E5" name="X829DB5497D58C7E5"></a></p>

<h5>1.2-7 IsCategoryWithDecidableLifts</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithDecidableLifts</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having decidable lifts.</p>

<p><a id="X7C22FA787967E694" name="X7C22FA787967E694"></a></p>

<h5>1.2-8 IsCategoryWithDecidableColifts</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithDecidableColifts</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having decidable colifts.</p>

<p><a id="X7C2B7A5F87EE5322" name="X7C2B7A5F87EE5322"></a></p>

<h5>1.2-9 IsCategoryWithInitialObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithInitialObject</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having an initial object.</p>

<p><a id="X828327367FA16BDD" name="X828327367FA16BDD"></a></p>

<h5>1.2-10 IsCategoryWithTerminalObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithTerminalObject</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having a terminal object.</p>

<p><a id="X7BFEEC3779A5EE2F" name="X7BFEEC3779A5EE2F"></a></p>

<h5>1.2-11 IsCategoryWithZeroObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithZeroObject</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having a zero object.</p>

<p><a id="X8451BCF67F0C4F62" name="X8451BCF67F0C4F62"></a></p>

<h5>1.2-12 IsCategoryWithEqualizers</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithEqualizers</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having all equalizers.</p>

<p><a id="X79D864BB79744E4E" name="X79D864BB79744E4E"></a></p>

<h5>1.2-13 IsCategoryWithCoequalizers</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithCoequalizers</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having all coequalizers.</p>

<p><a id="X82C2B6D37DA78465" name="X82C2B6D37DA78465"></a></p>

<h5>1.2-14 IsEnrichedOverCommutativeRegularSemigroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEnrichedOverCommutativeRegularSemigroup</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being enriched over a commutative regular semigroup.</p>

<p><a id="X7DBCD7237CF9100A" name="X7DBCD7237CF9100A"></a></p>

<h5>1.2-15 IsSkeletalCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSkeletalCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being skeletal, that is, whether <code class="code">IsEqualForObjects</code> and <code class="code">IsIsomorphicForObjects</code> coincide.</p>

<p><a id="X79295B4680B0F22B" name="X79295B4680B0F22B"></a></p>

<h5>1.2-16 IsAbCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAbCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being preadditive.</p>

<p><a id="X861DBAC181A15E1F" name="X861DBAC181A15E1F"></a></p>

<h5>1.2-17 IsLinearCategoryOverCommutativeRing</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsLinearCategoryOverCommutativeRing</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being linear over a commutative ring.</p>

<p><a id="X86D45F0D7804F023" name="X86D45F0D7804F023"></a></p>

<h5>1.2-18 IsLinearCategoryOverCommutativeRingWithFinitelyGeneratedFreeExternalHoms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsLinearCategoryOverCommutativeRingWithFinitelyGeneratedFreeExternalHoms</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being linear over a commutative ring <span class="SimpleMath">\(k\)</span> such that all external homs are finitely generated free <span class="SimpleMath">\(k\)</span>-modules.</p>

<p><a id="X7EB29BA681AE1F28" name="X7EB29BA681AE1F28"></a></p>

<h5>1.2-19 IsCategoryWithKernels</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithKernels</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having all kernels.</p>

<p><a id="X8226AEFF7F6F7FC3" name="X8226AEFF7F6F7FC3"></a></p>

<h5>1.2-20 IsCategoryWithCokernels</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCategoryWithCokernels</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> having all cokernels.</p>

<p><a id="X87C4C37D7F75E681" name="X87C4C37D7F75E681"></a></p>

<h5>1.2-21 IsAdditiveCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAdditiveCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being additive.</p>

<p><a id="X7A64E2B978685471" name="X7A64E2B978685471"></a></p>

<h5>1.2-22 IsPreAbelianCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPreAbelianCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being preabelian.</p>

<p><a id="X79DB288F84457967" name="X79DB288F84457967"></a></p>

<h5>1.2-23 IsAbelianCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAbelianCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being abelian.</p>

<p><a id="X83EDCC4886FEE4B1" name="X83EDCC4886FEE4B1"></a></p>

<h5>1.2-24 IsAbelianCategoryWithEnoughProjectives</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAbelianCategoryWithEnoughProjectives</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being abelian with enough projectives.</p>

<p><a id="X860EB7977F78EE3F" name="X860EB7977F78EE3F"></a></p>

<h5>1.2-25 IsAbelianCategoryWithEnoughInjectives</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsAbelianCategoryWithEnoughInjectives</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being abelian with enough injectives.</p>

<p><a id="X87AA6D6282FD1C02" name="X87AA6D6282FD1C02"></a></p>

<h5>1.2-26 IsLocallyOfFiniteProjectiveDimension</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsLocallyOfFiniteProjectiveDimension</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being locally of finite projective dimension.</p>

<p><a id="X7EDD2B4386ABE96E" name="X7EDD2B4386ABE96E"></a></p>

<h5>1.2-27 IsLocallyOfFiniteInjectiveDimension</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsLocallyOfFiniteInjectiveDimension</code>( <var class="Arg">C</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code></p>

<p>The property of the category <var class="Arg">C</var> being locally of finite injective dimension.</p>

<p><a id="X87434CEF86BC38D4" name="X87434CEF86BC38D4"></a></p>

<h5>1.2-28 ListOfDefiningOperations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ListOfDefiningOperations</code>( <var class="Arg">categorical_property</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a list</p>

<p>The input <var class="Arg">categorical_property</var> is the name of a valid categorical property. The output is the list of names of the CAP operations needed to make this categorical property constructive.</p>

<p><a id="X7ABF649E831D4D8E" name="X7ABF649E831D4D8E"></a></p>

<h4>1.3 <span class="Heading">Constructor</span></h4>

<p><a id="X86EDB84D7E3F0194" name="X86EDB84D7E3F0194"></a></p>

<h5>1.3-1 CreateCapCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CreateCapCategory</code>(  )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a category</p>

<p>Creates a new CAP category from scratch. It gets a generic name.</p>

<p><a id="X854CC42E828C120D" name="X854CC42E828C120D"></a></p>

<h5>1.3-2 CreateCapCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CreateCapCategory</code>( <var class="Arg">s</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a category</p>

<p>The argument is a string <span class="SimpleMath">\(s\)</span>. This operation creates a new CAP category from scratch. Its name is set to <span class="SimpleMath">\(s\)</span>.</p>

<p><a id="X7A1D562178FC3DDF" name="X7A1D562178FC3DDF"></a></p>

<h5>1.3-3 CreateCapCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CreateCapCategory</code>( <var class="Arg">s</var>, <var class="Arg">category_filter</var>, <var class="Arg">object_filter</var>, <var class="Arg">morphism_filter</var>, <var class="Arg">two_cell_filter</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a category</p>

<p>The argument is a string <span class="SimpleMath">\(s\)</span>. This operation creates a new CAP category from scratch. Its name is set to <span class="SimpleMath">\(s\)</span>. The category, its objects, its morphisms, and its two cells will lie in the corresponding given filters.</p>

<p><a id="X8090078F7C5EF5E9" name="X8090078F7C5EF5E9"></a></p>

<h5>1.3-4 CreateCapCategoryWithDataTypes</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CreateCapCategoryWithDataTypes</code>( <var class="Arg">s</var>, <var class="Arg">category_filter</var>, <var class="Arg">object_filter</var>, <var class="Arg">morphism_filter</var>, <var class="Arg">two_cell_filter</var>, <var class="Arg">object_datum_type</var>, <var class="Arg">morphism_datum_type</var>, <var class="Arg">two_cell_datum_type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a category</p>

<p>The argument is a string <span class="SimpleMath">\(s\)</span>. This operation creates a new CAP category from scratch. Its name is set to <span class="SimpleMath">\(s\)</span>. The category, its objects, its morphisms, and its two cells will lie in the corresponding given filters. The data types of the object/morphism/two cell datum can be given as described in <code class="func">CapJitInferredDataTypes</code> (<a href="https://homalg-project.github.io/CAP_project/CompilerForCAP/doc/chap2_mj.html#X821BE2CE7C30674E"><span class="RefLink">CompilerForCAP: CapJitInferredDataTypes</span></a>). As a convenience, simply a filter can be given if this suffices to fully determine the data type. If a data type is not specified, pass <code class="code">fail</code> instead.</p>

<p><a id="X79CE135F7E6EBFEE" name="X79CE135F7E6EBFEE"></a></p>

<h4>1.4 <span class="Heading">Internal Attributes</span></h4>

<p><a id="X79251D5C85B0F3D3" name="X79251D5C85B0F3D3"></a></p>

<h5>1.4-1 Name</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Name</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a string</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is its name.</p>

<p>Each category <span class="SimpleMath">\(C\)</span> stores various filters. They are used to apply the right functions in the method selection.</p>

<p><a id="X7C7B1EAF7D786508" name="X7C7B1EAF7D786508"></a></p>

<h5>1.4-2 CategoryFilter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CategoryFilter</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a filter</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is a filter in which <span class="SimpleMath">\(C\)</span> lies.</p>

<p><a id="X7BD6E2B887F86E9C" name="X7BD6E2B887F86E9C"></a></p>

<h5>1.4-3 ObjectFilter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjectFilter</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a filter</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is a filter in which all objects of <span class="SimpleMath">\(C\)</span> shall lie.</p>

<p><a id="X7F62E0C47C778CBB" name="X7F62E0C47C778CBB"></a></p>

<h5>1.4-4 MorphismFilter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MorphismFilter</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a filter</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is a filter in which all morphisms of <span class="SimpleMath">\(C\)</span> shall lie.</p>

<p><a id="X850D0E978090D0C0" name="X850D0E978090D0C0"></a></p>

<h5>1.4-5 TwoCellFilter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TwoCellFilter</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a filter</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is a filter in which all <span class="SimpleMath">\(2\)</span>-cells of <span class="SimpleMath">\(C\)</span> shall lie.</p>

<p><a id="X834BBE4085A42FAC" name="X834BBE4085A42FAC"></a></p>

<h5>1.4-6 ObjectDatumType</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjectDatumType</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a data type or <code class="code">fail</code></p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is the data type (see <code class="func">CapJitInferredDataTypes</code> (<a href="https://homalg-project.github.io/CAP_project/CompilerForCAP/doc/chap2_mj.html#X821BE2CE7C30674E"><span class="RefLink">CompilerForCAP: CapJitInferredDataTypes</span></a>)) of object data of <span class="SimpleMath">\(C\)</span> (or <code class="code">fail</code> if this data type is not specified).</p>

<p><a id="X8090D81F78B1F25A" name="X8090D81F78B1F25A"></a></p>

<h5>1.4-7 MorphismDatumType</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MorphismDatumType</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a data type or <code class="code">fail</code></p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is the data type (see <code class="func">CapJitInferredDataTypes</code> (<a href="https://homalg-project.github.io/CAP_project/CompilerForCAP/doc/chap2_mj.html#X821BE2CE7C30674E"><span class="RefLink">CompilerForCAP: CapJitInferredDataTypes</span></a>)) of morphism data of <span class="SimpleMath">\(C\)</span> (or <code class="code">fail</code> if this data type is not specified).</p>

<p><a id="X850E7C0C807F3402" name="X850E7C0C807F3402"></a></p>

<h5>1.4-8 TwoCellDatumType</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TwoCellDatumType</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a data type or <code class="code">fail</code></p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span>. The output is the data type (see <code class="func">CapJitInferredDataTypes</code> (<a href="https://homalg-project.github.io/CAP_project/CompilerForCAP/doc/chap2_mj.html#X821BE2CE7C30674E"><span class="RefLink">CompilerForCAP: CapJitInferredDataTypes</span></a>)) of two cell data of <span class="SimpleMath">\(C\)</span> (or <code class="code">fail</code> if this data type is not specified).</p>

<p><a id="X78D0C0057817DBC3" name="X78D0C0057817DBC3"></a></p>

<h5>1.4-9 CommutativeRingOfLinearCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CommutativeRingOfLinearCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a ring</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span> which is expected to lie in the filter <code class="code">IsLinearCategoryOverCommutativeRing</code>. The output is a commutative ring over which the category is linear.</p>

<p><a id="X80AF18E4797A5BB4" name="X80AF18E4797A5BB4"></a></p>

<h5>1.4-10 RangeCategoryOfHomomorphismStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RangeCategoryOfHomomorphismStructure</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a category</p>

<p>The argument is a category <span class="SimpleMath">\(C\)</span> which is expected to lie in the filter <code class="code">IsEquippedWithHomomorphismStructure</code>. The output is the range category <span class="SimpleMath">\(D\)</span> of the defining functor <span class="SimpleMath">\(H: C^{\mathrm{op}} \times C \rightarrow D\)</span> of the homomorphism structure.</p>

<p><a id="X7CF2F93F8258DAD5" name="X7CF2F93F8258DAD5"></a></p>

<h5>1.4-11 AdditiveGenerators</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdditiveGenerators</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of objects</p>

<p>The argument is an additive category <span class="SimpleMath">\(C\)</span>. The output is a list <span class="SimpleMath">\(L\)</span> of objects in <span class="SimpleMath">\(C\)</span> such that every object in <span class="SimpleMath">\(C\)</span> is a finite direct sum of objects in <span class="SimpleMath">\(L\)</span>.</p>

<p><a id="X7E094E2680348C88" name="X7E094E2680348C88"></a></p>

<h5>1.4-12 IndecomposableProjectiveObjects</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IndecomposableProjectiveObjects</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of objects</p>

<p>The argument is an Abelian category <span class="SimpleMath">\(C\)</span> with enough projectives. The output is the set of indecomposable projective objects in <span class="SimpleMath">\(C\)</span> up to isomorphism. That is every projective object in <span class="SimpleMath">\(C\)</span> is isomorphic to a finite direct sum over these objects.</p>

<p><a id="X85E6A5AF7DDA4F2C" name="X85E6A5AF7DDA4F2C"></a></p>

<h5>1.4-13 IndecomposableInjectiveObjects</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IndecomposableInjectiveObjects</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of objects</p>

<p>The argument is an Abelian category <span class="SimpleMath">\(C\)</span> with enough injectives. The output is the set of indecomposable injective objects in <span class="SimpleMath">\(C\)</span> up to isomorphism. That is every injective object in <span class="SimpleMath">\(C\)</span> is isomorphic to a finite direct sum over these objects.</p>

<p><a id="X8305A19E86EC7B67" name="X8305A19E86EC7B67"></a></p>

<h4>1.5 <span class="Heading">Logic switcher</span></h4>

<p><a id="X82C32E8C790EAB42" name="X82C32E8C790EAB42"></a></p>

<h5>1.5-1 CapCategorySwitchLogicPropagationForObjectsOn</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationForObjectsOn</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Activates the predicate logic propagation between equal objects for the category <var class="Arg">C</var>.</p>

<p><a id="X7FEF6F218491CD45" name="X7FEF6F218491CD45"></a></p>

<h5>1.5-2 CapCategorySwitchLogicPropagationForObjectsOff</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationForObjectsOff</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Deactivates the predicate logic propagation between equal objects for the category <var class="Arg">C</var>.</p>

<p><a id="X80C98B547A76705D" name="X80C98B547A76705D"></a></p>

<h5>1.5-3 CapCategorySwitchLogicPropagationForMorphismsOn</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationForMorphismsOn</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Activates the predicate logic propagation between equal morphisms for the category <var class="Arg">C</var>.</p>

<p><a id="X86469EBF8261E1D4" name="X86469EBF8261E1D4"></a></p>

<h5>1.5-4 CapCategorySwitchLogicPropagationForMorphismsOff</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationForMorphismsOff</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Deactivates the predicate logic propagation between equal morphisms for the category <var class="Arg">C</var>.</p>

<p><a id="X7C06E84F78D82C0D" name="X7C06E84F78D82C0D"></a></p>

<h5>1.5-5 CapCategorySwitchLogicPropagationOn</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationOn</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Activates the predicate logic propagation between equal cells for the category <var class="Arg">C</var>.</p>

<p><a id="X84F114757E964E1E" name="X84F114757E964E1E"></a></p>

<h5>1.5-6 CapCategorySwitchLogicPropagationOff</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicPropagationOff</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Deactivates the predicate logic propagation between equal cells for the category <var class="Arg">C</var>.</p>

<p><a id="X84824AC3793D872B" name="X84824AC3793D872B"></a></p>

<h5>1.5-7 CapCategorySwitchLogicOn</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicOn</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Activates the predicate implication logic for the category <var class="Arg">C</var>.</p>

<p><a id="X84A995A687D031B7" name="X84A995A687D031B7"></a></p>

<h5>1.5-8 CapCategorySwitchLogicOff</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CapCategorySwitchLogicOff</code>( <var class="Arg">C</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Deactivates the predicate implication logic for the category <var class="Arg">C</var>.</p>

<p><a id="X7A15CCB67FBCF3E3" name="X7A15CCB67FBCF3E3"></a></p>

<h4>1.6 <span class="Heading">Tool functions</span></h4>

<p><a id="X851D0435816DDB40" name="X851D0435816DDB40"></a></p>

<h5>1.6-1 CanCompute</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CanCompute</code>( <var class="Arg">C</var>, <var class="Arg">string</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CanCompute</code>( <var class="Arg">C</var>, <var class="Arg">operation</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: <code class="code">true</code> or <code class="code">false</code></p>

<p>The argument is a category <var class="Arg">C</var> and a string <var class="Arg">string</var>, which should be the name of a CAP operation, e.g., PreCompose. If applying this method is possible in <span class="SimpleMath">\(C\)</span>, the method returns <code class="code">true</code>, <code class="code">false</code> otherwise. If the string is not the name of a CAP operation, an error is raised. For debugging purposes one can also pass the CAP operation instead of its name.</p>

<p><a id="X820DD63180AE4BAB" name="X820DD63180AE4BAB"></a></p>

<h5>1.6-2 OperationWeight</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OperationWeight</code>( <var class="Arg">cat</var>, <var class="Arg">op_name</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: an integer</p>

<p>Returns the weight of the operation currently installed as <var class="Arg">op_name</var> in <var class="Arg">cat</var>.</p>

<p><a id="X7AA6C5857FB663EB" name="X7AA6C5857FB663EB"></a></p>

<h5>1.6-3 MissingOperationsForConstructivenessOfCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MissingOperationsForConstructivenessOfCategory</code>( <var class="Arg">C</var>, <var class="Arg">s</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list</p>

<p>The arguments are a category <span class="SimpleMath">\(C\)</span> and a string <span class="SimpleMath">\(s\)</span>. If <span class="SimpleMath">\(s\)</span> is a categorical property (e.g. <code class="code">"IsAbelianCategory"</code>), the output is a list of strings with CAP operations which are missing in <span class="SimpleMath">\(C\)</span> to have the categorical property constructively. If <span class="SimpleMath">\(s\)</span> is not a categorical property, an error is raised.</p>

<p><a id="X7DB3D2BD8792ABBC" name="X7DB3D2BD8792ABBC"></a></p>

<h4>1.7 <span class="Heading">Well-Definedness of Cells</span></h4>

<p><a id="X839EA4D7805D4F97" name="X839EA4D7805D4F97"></a></p>

<h5>1.7-1 IsWellDefined</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWellDefined</code>( <var class="Arg">c</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>The argument is a cell <span class="SimpleMath">\(c\)</span>. The output is <code class="code">true</code> if <span class="SimpleMath">\(c\)</span> is well-defined, otherwise the output is <code class="code">false</code>.</p>

<p><a id="X7D2E74CE87255099" name="X7D2E74CE87255099"></a></p>

<h4>1.8 <span class="Heading">Unpacking data structures</span></h4>

<p><a id="X8790DC5F7A2BD22E" name="X8790DC5F7A2BD22E"></a></p>

<h5>1.8-1 Down</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Down</code>( <var class="Arg">x</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a GAP object</p>

<p>The argument is a GAP object <span class="SimpleMath">\(x\)</span>. If <span class="SimpleMath">\(x\)</span> is an object in a CAP category, the output consists of data which are needed to reconstruct <span class="SimpleMath">\(x\)</span> (e.g., by passing them to an appropriate constructor). If <span class="SimpleMath">\(x\)</span> is a morphism in a CAP category, the output consists of a triple whose first entry is the source of <span class="SimpleMath">\(x\)</span>, the third entry is the range of <span class="SimpleMath">\(x\)</span>, and the second entry consists of data which are needed to reconstruct <span class="SimpleMath">\(x\)</span> (e.g., by passing them to an appropriate constructor, possibly together with the source and range of <span class="SimpleMath">\(x\)</span>).</p>

<p><a id="X858B64487B2DA04E" name="X858B64487B2DA04E"></a></p>

<h5>1.8-2 DownOnlyMorphismData</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DownOnlyMorphismData</code>( <var class="Arg">x</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a GAP object</p>

<p>The argument is a morphism in a CAP category, the output consists of data which are needed to reconstruct <span class="SimpleMath">\(x\)</span> (e.g., by passing it to an appropriate constructor, possibly together with its source and range).</p>

<p><a id="X7BABD65A821C138F" name="X7BABD65A821C138F"></a></p>

<h5>1.8-3 DownToBottom</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DownToBottom</code>( <var class="Arg">x</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a GAP object</p>

<p>The argument is a GAP object <span class="SimpleMath">\(x\)</span>. This function iteratively calls <code class="code">Down</code> until it becomes stable.</p>

<p><a id="X79DB9EE785F723D1" name="X79DB9EE785F723D1"></a></p>

<h4>1.9 <span class="Heading">Caching</span></h4>

<p><a id="X7DB820A686B4059F" name="X7DB820A686B4059F"></a></p>

<h5>1.9-1 SetCachingOfCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetCachingOfCategory</code>( <var class="Arg">category</var>, <var class="Arg">type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Sets the caching of <var class="Arg">category</var> to <var class="Arg">type</var>.</p>

<p><a id="X87AA14F27892F14F" name="X87AA14F27892F14F"></a></p>

<h5>1.9-2 SetCachingOfCategoryWeak</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetCachingOfCategoryWeak</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetCachingOfCategoryCrisp</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DeactivateCachingOfCategory</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Sets the caching of <var class="Arg">category</var> to <code class="code">weak</code>, <code class="code">crisp</code> or <code class="code">none</code>, respectively.</p>

<p><a id="X844903657E52E6D1" name="X844903657E52E6D1"></a></p>

<h5>1.9-3 SetDefaultCaching</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetDefaultCaching</code>( <var class="Arg">type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetDefaultCachingWeak</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetDefaultCachingCrisp</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DeactivateDefaultCaching</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>Sets the default caching behaviour, all new categories will have their caching set to either <code class="code">weak</code>, <code class="code">crisp</code>, or <code class="code">none</code>. The default at startup is <code class="code">weak</code>.</p>

<p><a id="X7EC631BC7CFCF5DB" name="X7EC631BC7CFCF5DB"></a></p>

<h4>1.10 <span class="Heading">Sanity checks</span></h4>

<p><a id="X7BB84C7B83FE3D80" name="X7BB84C7B83FE3D80"></a></p>

<h5>1.10-1 DisableInputSanityChecks</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DisableInputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DisableOutputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnablePartialInputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnablePartialOutputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnableFullInputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnableFullOutputSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DisableSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnablePartialSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EnableFullSanityChecks</code>( <var class="Arg">category</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Most operations can perform optional sanity checks on their arguments and results. The checks can either be partial (set by default), full, or disabled. With the following commands you can either enable the full checks, the partial checks or, for performance, disable the checks altogether. You can do this for input checks, output checks or for both at once.</p>

<p><a id="X7984C0E986CF0986" name="X7984C0E986CF0986"></a></p>

<h4>1.11 <span class="Heading">Timing statistics</span></h4>

<p><a id="X86C6F8828628B070" name="X86C6F8828628B070"></a></p>

<h5>1.11-1 EnableTimingStatistics</h5>

--> --------------------

--> maximum size reached

--> --------------------

100%


¤ Dauer der Verarbeitung: 0.33 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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.