Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/corelg/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 7.6.2024 mit Größe 153 B image not shown  

Quelle  chap2.html   Sprache: unbekannt

 
<?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>
<title>GAP (MonoidalCategories) - Chapter 2: Examples and Tests</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="chap2"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chapInd.html">Ind</a>  </div>

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

<p id="mathjaxlink" class="pcenter"><a href="chap2_mj.html">[MathJax on]</a></p>
<p><a id="X7967FE8E7BBDF485" name="X7967FE8E7BBDF485"></a></p>
<div class="ChapSects"><a href="chap2.html#X7967FE8E7BBDF485">2 <span class="Heading">Examples and Tests</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2.html#X7862428B781B1F3D">2.1 <span class="Heading">Test functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X8131040685BBC24E">2.1-1 AdditiveMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X803EED927C6BFB83">2.1-2 TestBraidingForInvertibility</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X794ADC5E7B9ED6E9">2.1-3 TestBraidingCompatibility</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X85D661D482543648">2.1-4 TestBraidingCompatibilityForAllTriplesInList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7D87D6737E0B485F">2.1-5 BraidedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7CDDEF3E87731A54">2.1-6 ClosedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7EAC790E85CC1D26">2.1-7 ClosedMonoidalCategoriesTestWithGiven</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X83E919E984B367B1">2.1-8 CoclosedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7F29A16A810D390D">2.1-9 CoclosedMonoidalCategoriesTestWithGiven</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7B0D72D07AAA7B9B">2.1-10 LeftClosedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7BCAE7FE7E32B70A">2.1-11 LeftClosedMonoidalCategoriesTestWithGiven</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X865E82AA7FB9B0BE">2.1-12 LeftCoclosedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7BF584B6805BB8DA">2.1-13 LeftCoclosedMonoidalCategoriesTestWithGiven</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7B05AB7F7BAF2B62">2.1-14 MonoidalCategoriesTensorProductOnObjectsAndTensorUnitTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7FE8E3E581929705">2.1-15 TestMonoidalUnitorsForInvertibility</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X78A123237F5F81BE">2.1-16 TestAssociatorForInvertibility</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7EB6CE877FDBFAE5">2.1-17 TestMonoidalTriangleIdentity</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7B0890C57F20717C">2.1-18 TestMonoidalTriangleIdentityForAllPairsInList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X8786C1FF7F09F124">2.1-19 TestMonoidalPentagonIdentity</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7D45BF317D6237DC">2.1-20 TestMonoidalPentagonIdentityUsingWithGivenOperations</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7E96BEF17CD1B38B">2.1-21 TestMonoidalPentagonIdentityForAllQuadruplesInList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X7BCAF88A806E562D">2.1-22 MonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X85AB97E9788D543D">2.1-23 TestZigZagIdentitiesForDual</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X78CAAAE77DC5CF4F">2.1-24 RigidSymmetricClosedMonoidalCategoriesTest</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2.html#X8154BEE7850EFEEA">2.1-25 RigidSymmetricCoclosedMonoidalCategoriesTest</a></span>
</div></div>
</div>

<h3>2 <span class="Heading">Examples and Tests</span></h3>

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

<h4>2.1 <span class="Heading">Test functions</span></h4>

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

<h5>2.1-1 AdditiveMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdditiveMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">L</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>an object <span class="Math">a</span></p>

</li>
<li><p>a list <span class="Math">L</span> of objects</p>

</li>
</ul>
<p>This function checks for every operation declared in AdditiveMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-2 TestBraidingForInvertibility</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestBraidingForInvertibility</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are three objects <span class="Math">obj_1, obj_2</span> in a braided monoidal category <span class="Math">cat</span>. The output is true if the braiding is invertible, false otherwise.</p>

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

<h5>2.1-3 TestBraidingCompatibility</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestBraidingCompatibility</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var>, <var class="Arg">obj_3</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are three objects <span class="Math">obj_1, obj_2, obj_3</span> in a braided monoidal category <span class="Math">cat</span>. The output is true if the braiding compatabilities with the associator hold, false otherwise.</p>

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

<h5>2.1-4 TestBraidingCompatibilityForAllTriplesInList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestBraidingCompatibilityForAllTriplesInList</code>( <var class="Arg">cat</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The argument is a list <span class="Math">L</span> of objects in a braided monoidal category <span class="Math">cat</span>. The output is true if the braiding compatabilities with the associator hold for all triples of objects in <span class="Math">L</span>, otherwise false.</p>

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

<h5>2.1-5 BraidedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BraidedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b</span></p>

</li>
</ul>
<p>This function checks for every operation declared in BraidedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-6 ClosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ClosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
<li><p>a morphism <span class="Math">\gamma: a \otimes b \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\delta: c \otimes d \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\epsilon: 1 \rightarrow \mathrm{Hom}(a,b)</span></p>

</li>
<li><p>a morphism <span class="Math">\zeta: 1 \rightarrow \mathrm{Hom}(c,d)</span></p>

</li>
</ul>
<p>This function checks for every operation declared in ClosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-7 ClosedMonoidalCategoriesTestWithGiven</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ClosedMonoidalCategoriesTestWithGiven</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
</ul>
<p>This function checks for some *WithGiven operations declared in ClosedMonoidalCategories.gd if they are computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-8 CoclosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CoclosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
<li><p>a morphism <span class="Math">\gamma: 1 \rightarrow a \otimes b</span></p>

</li>
<li><p>a morphism <span class="Math">\delta: 1 \rightarrow c \otimes d</span></p>

</li>
<li><p>a morphism <span class="Math">\epsilon: \mathrm{coHom}(a,b) \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\zeta: \mathrm{coHom}(c,d) \rightarrow 1</span></p>

</li>
</ul>
<p>This function checks for every operation declared in CoclosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-9 CoclosedMonoidalCategoriesTestWithGiven</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CoclosedMonoidalCategoriesTestWithGiven</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
</ul>
<p>This function checks for some *WithGiven operations declared in CoclosedMonoidalCategories.gd if they are computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-10 LeftClosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftClosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
<li><p>a morphism <span class="Math">\gamma: a \otimes b \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\delta: c \otimes d \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\epsilon: 1 \rightarrow \mathrm{Hom}(a,b)</span></p>

</li>
<li><p>a morphism <span class="Math">\zeta: 1 \rightarrow \mathrm{Hom}(c,d)</span></p>

</li>
</ul>
<p>This function checks for every operation declared in LeftClosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-11 LeftClosedMonoidalCategoriesTestWithGiven</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftClosedMonoidalCategoriesTestWithGiven</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
</ul>
<p>This function checks for some *WithGiven operationS declared in LeftClosedMonoidalCategories.gd if they are computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-12 LeftCoclosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftCoclosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
<li><p>a morphism <span class="Math">\gamma: 1 \rightarrow a \otimes b</span></p>

</li>
<li><p>a morphism <span class="Math">\delta: 1 \rightarrow c \otimes d</span></p>

</li>
<li><p>a morphism <span class="Math">\epsilon: \mathrm{coHom}(a,b) \rightarrow 1</span></p>

</li>
<li><p>a morphism <span class="Math">\zeta: \mathrm{coHom}(c,d) \rightarrow 1</span></p>

</li>
</ul>
<p>This function checks for every operation declared in LeftCoclosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-13 LeftCoclosedMonoidalCategoriesTestWithGiven</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LeftCoclosedMonoidalCategoriesTestWithGiven</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var>, <var class="Arg">epsilon</var>, <var class="Arg">zeta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
</ul>
<p>This function checks for some *WithGiven operations declared in LeftCoclosedMonoidalCategories.gd if they are computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-14 MonoidalCategoriesTensorProductOnObjectsAndTensorUnitTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MonoidalCategoriesTensorProductOnObjectsAndTensorUnitTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b</span></p>

</li>
</ul>
<p>This function checks for every operation declared in MonoidalCategoriesTensorProductOnObjectsAndTensorUnit.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-15 TestMonoidalUnitorsForInvertibility</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalUnitorsForInvertibility</code>( <var class="Arg">cat</var>, <var class="Arg">obj</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are two objects <span class="Math">obj</span> in a monoidal category <span class="Math">cat</span>. The output is true if the left and right unitors are invertible for <span class="Math">obj</span>.</p>

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

<h5>2.1-16 TestAssociatorForInvertibility</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestAssociatorForInvertibility</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var>, <var class="Arg">obj_3</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are two objects <span class="Math">obj_1, obj_2, obj_3</span> in a monoidal category <span class="Math">cat</span>. The output is true if the associator are invertible for these 3 objects, false otherwise.</p>

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

<h5>2.1-17 TestMonoidalTriangleIdentity</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalTriangleIdentity</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are two objects <span class="Math">obj_1, obj_2</span> in a monoidal category <span class="Math">cat</span>. The output is true if the triangle identity holds for these 2 objects, false otherwise.</p>

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

<h5>2.1-18 TestMonoidalTriangleIdentityForAllPairsInList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalTriangleIdentityForAllPairsInList</code>( <var class="Arg">cat</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The argument is a list <span class="Math">L</span> of objects in a monoidal category <span class="Math">cat</span>. The output is true if the triangle identity holds for all pairs of objects in <span class="Math">L</span>, otherwise false.</p>

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

<h5>2.1-19 TestMonoidalPentagonIdentity</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalPentagonIdentity</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var>, <var class="Arg">obj_3</var>, <var class="Arg">obj_4</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are 4 objects <span class="Math">obj_1, obj_2, obj_3, obj_4</span> in a monoidal category <span class="Math">cat</span>. The output is true if the pentagon identity holds for these 4 objects, false otherwise.</p>

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

<h5>2.1-20 TestMonoidalPentagonIdentityUsingWithGivenOperations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalPentagonIdentityUsingWithGivenOperations</code>( <var class="Arg">cat</var>, <var class="Arg">obj_1</var>, <var class="Arg">obj_2</var>, <var class="Arg">obj_3</var>, <var class="Arg">obj_4</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The arguments are 4 objects <span class="Math">obj_1, obj_2, obj_3, obj_4</span> in a monoidal category <span class="Math">cat</span>. The output is true if the pentagon identity holds for these 4 objects, false otherwise. This test uses the WithGiven-operations.</p>

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

<h5>2.1-21 TestMonoidalPentagonIdentityForAllQuadruplesInList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestMonoidalPentagonIdentityForAllQuadruplesInList</code>( <var class="Arg">cat</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The argument is a list <span class="Math">L</span> of objects in a monoidal category <span class="Math">cat</span>. The output is true if the pentagon identity holds for all quadruples of objects in <span class="Math">L</span>, otherwise false.</p>

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

<h5>2.1-22 MonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c</span></p>

</li>
<li><p>a morphism <span class="Math">\alpha: a \rightarrow b</span></p>

</li>
<li><p>a morphism <span class="Math">\beta: c \rightarrow d</span></p>

</li>
</ul>
<p>This function checks for every operation declared in MonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-23 TestZigZagIdentitiesForDual</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TestZigZagIdentitiesForDual</code>( <var class="Arg">cat</var>, <var class="Arg">obj</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a boolean</p>

<p>This is a debug operation. The argument is an object <span class="Math">obj</span> in a rigid symmetric monoidal category <span class="Math">cat</span>. The output is true if the zig zag identity for duals hold, false otherwise.</p>

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

<h5>2.1-24 RigidSymmetricClosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RigidSymmetricClosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>an endomorphism <span class="Math">\alpha: a \rightarrow a</span></p>

</li>
</ul>
<p>This function checks for every object and morphism declared in RigidSymmetricClosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

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

<h5>2.1-25 RigidSymmetricCoclosedMonoidalCategoriesTest</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RigidSymmetricCoclosedMonoidalCategoriesTest</code>( <var class="Arg">cat</var>, <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">c</var>, <var class="Arg">d</var>, <var class="Arg">alpha</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The arguments are</p>


<ul>
<li><p>a CAP category <span class="Math">cat</span></p>

</li>
<li><p>objects <span class="Math">a, b, c, d</span></p>

</li>
<li><p>an endomorphism <span class="Math">\alpha: a \rightarrow a</span></p>

</li>
</ul>
<p>This function checks for every object and morphism declared in RigidSymmetricCoclosedMonoidalCategories.gd if it is computable in the CAP category <span class="Math">cat</span>. If yes, then the operation is executed with the parameters given above and compared to the equivalent computation in the opposite category of <span class="Math">cat</span>. Pass the options</p>


<ul>
<li><p><code class="code">verbose := true</code> to output more information.</p>

</li>
<li><p><code class="code">only_primitive_operations := true</code>, which is passed on to Opposite(), to only primitively install dual operations for primitively installed operations in <span class="Math">cat</span>. The advantage is, that more derivations might be tested. On the downside, this might test fewer dual_pre/postprocessor_funcs.</p>

</li>
</ul>

<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a>   <a href="chap0.html#contents">[Contents]</a>    <a href="chap1.html">[Previous Chapter]</a>    <a href="chap3.html">[Next Chapter]</a>   </div>


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chapInd.html">Ind</a>  </div>

<hr />
<p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>

100%


[ Dauer der Verarbeitung: 0.19 Sekunden  (vorverarbeitet)  ]