Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

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

Quelle  chap3.html

  Sprache: HTML 		 

 products/Sources/formale Sprachen/GAP/pkg/cap/doc/chap3.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>
<title>GAP (CAP) - Chapter 3: Morphisms</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="chap3"  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="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</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="chap2.html">[Previous Chapter]</a>    <a href="chap4.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap3_mj.html">[MathJax on]</a></p>
<p><a id="X7BEB6C617FED52DA" name="X7BEB6C617FED52DA"></a></p>
<div class="ChapSects"><a href="chap3.html#X7BEB6C617FED52DA">3 <span class="Heading">Morphisms</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X8642E3327E96BBDD">3.1 <span class="Heading">Attributes for the Type of Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E923036810C606E">3.1-1 CapCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E1373E385E7315A">3.1-2 Source</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X817496B987A1ADFC">3.1-3 Range</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83A0A39587BD6383">3.1-4 Target</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X867B9398854FEFFD">3.2 <span class="Heading">Adding Morphisms to a Category</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BDADB628232C280">3.2-1 Add</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82453E55857562AB">3.2-2 AddMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X78005D357A051FC6">3.2-3 CreateCapCategoryMorphismWithAttributes</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7AE302BE7C2E829F">3.2-4 AsCapCategoryMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7893F08182290038">3.2-5 AsPrimitiveValue</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X8279E00178F05A66">3.3 <span class="Heading">Morphism constructors</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F1FB34F789ECB10">3.3-1 MorphismConstructor</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BBFB178866108FA">3.3-2 MorphismDatum</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7A00D0C181471D06">3.4 <span class="Heading">Categorical Properties of Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A6F64027EEAF42B">3.4-1 IsMonomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E85E0A67BA11091">3.4-2 IsEpimorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F29CF0282EFEAA3">3.4-3 IsIsomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X871A71747E03207D">3.4-4 IsSplitMonomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7B4DB8C887F37D02">3.4-5 IsSplitEpimorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7FA10AFB7F441434">3.4-6 IsOne</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BA4290882AFFCA3">3.4-7 IsIdempotent</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7B655F2678F605D3">3.5 <span class="Heading">Random Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79EBA1717D89B0A4">3.5-1 RandomMorphismWithFixedSourceByInteger</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X84FDBEED7844CDB6">3.5-2 RandomMorphismWithFixedSourceByList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X844B1DDC8488B7CA">3.5-3 RandomMorphismWithFixedRangeByInteger</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8568D71882C30501">3.5-4 RandomMorphismWithFixedRangeByList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X80F66E9D809EA6A7">3.5-5 RandomMorphismWithFixedSourceAndRangeByInteger</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BF231C57B40B1A1">3.5-6 RandomMorphismWithFixedSourceAndRangeByList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81DB09BA7CBD3DB4">3.5-7 RandomMorphismByInteger</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E79F7A9802F622D">3.5-8 RandomMorphismByList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83D121E787FDC6E8">3.5-9 RandomMorphismWithFixedSource</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7EA50D6587A93936">3.6 <span class="Heading">Non-Categorical Properties of Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8211959783AFF307">3.6-1 IsEqualToIdentityMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79D407A3807309FC">3.6-2 IsEqualToZeroMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81057B3E812B06CC">3.6-3 IsEndomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X84E5DE257F241830">3.6-4 IsAutomorphism</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X850CFDD48773998E">3.7 <span class="Heading">Equality and Congruence for Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7FABCFBF865F4179">3.7-1 IsCongruentForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8004F1DA7D9BFA8B">3.7-2 IsEqualForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8589E5A4814C3DA5">3.7-3 IsEqualForMorphismsOnMor</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X8312421679CAAE35">3.8 <span class="Heading">Basic Operations for Morphisms in Ab-Categories</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X844684AD86DCC2DC">3.8-1 IsZeroForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83B77FBB85927F14">3.8-2 AdditionForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7B6461F5873F3F9D">3.8-3 SubtractionForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83177713785DCFFC">3.8-4 AdditiveInverseForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8187CAF17EB5D6D0">3.8-5 MultiplyWithElementOfCommutativeRingForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X877D74C67D041F74">3.8-6 *</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X873412DB7BD0FBD3">3.8-7 ZeroMorphism</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7C81E153817F489F">3.9 <span class="Heading">Subobject and Factorobject Operations</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E99DAA884674DE2">3.9-1 IsEqualAsSubobjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79389FBF86CF87A4">3.9-2 IsEqualAsFactorobjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C21531C7EE65C72">3.9-3 IsDominating</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C77E9D479C8D502">3.9-4 IsCodominating</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X82ADC0BF82DA2122">3.10 <span class="Heading">Identity Morphism and Composition of Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C9F3D8086238443">3.10-1 IdentityMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8244F7A0868BE27D">3.10-2 PreCompose</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83CB57FB81931CFE">3.10-3 PreCompose</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87A5FFE97BB5190A">3.10-4 PreComposeList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X84293B8381256A08">3.10-5 PostCompose</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81222A1084A4F637">3.10-6 PostCompose</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BD83BF3835870E9">3.10-7 PostComposeList</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D50F754822C30D7">3.10-8 SumOfMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C101B5C7AC9089C">3.10-9 LinearCombinationOfMorphisms</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7D5182B48598FBC5">3.11 <span class="Heading">Well-Definedness of Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7968A871832877B8">3.11-1 IsWellDefinedForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X820A29637F48E932">3.11-2 IsWellDefinedForMorphismsWithGivenSourceAndRange</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X83339BB37B01DB19">3.12 <span class="Heading">Lift/Colift</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83CDF65582CD9921">3.12-1 LiftAlongMonomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79AA9F638487EE32">3.12-2 ColiftAlongEpimorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D9BA8D67892BD48">3.12-3 IsLiftableAlongMonomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DCDD2B2859EFD2D">3.12-4 IsColiftableAlongEpimorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87C471D583C1CD9E">3.12-5 Lift</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8597DE1C83CFE89D">3.12-6 LiftOrFail</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F895375875BE5B9">3.12-7 IsLiftable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BA38B0F797AFE20">3.12-8 Colift</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79FFE43E7962CFBA">3.12-9 ColiftOrFail</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8685B04087B1E52A">3.12-10 IsColiftable</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X864F84C47DC1A620">3.13 <span class="Heading">Inverses</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8371BF227B4C32EF">3.13-1 InverseForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83E4A87F7B2290F1">3.13-2 PreInverseForMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X800447917F75989A">3.13-3 PostInverseForMorphisms</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7DD668627932185C">3.14 <span class="Heading">Tool functions for caches</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83F87AE07ED534ED">3.14-1 IsEqualForCacheForMorphisms</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X84563B1A835E9766">3.15 <span class="Heading">IsHomSetInhabited</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81DB15B87D1A946D">3.15-1 IsHomSetInhabited</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X858111977D44BC9C">3.16 <span class="Heading">SetOfMorphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X824691307DEF08FC">3.16-1 SetOfMorphismsOfFiniteCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8426F188818F02B7">3.16-2 SetOfMorphisms</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7F065B9A78922547">3.17 <span class="Heading">Homomorphism structures</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81BC29A679416C45">3.17-1 HomomorphismStructureOnObjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8257E3787865C5E0">3.17-2 HomomorphismStructureOnMorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7FBC94B983CBA64F">3.17-3 HomomorphismStructureOnMorphismsWithGivenObjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7999CCFF82DA16D7">3.17-4 DistinguishedObjectOfHomomorphismStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81F1237C7DBF7603">3.17-5 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A5A05C682EB033D">3.17-6 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8760D39C865239E8">3.17-7 InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BE5E2687FC110AC">3.17-8 SolveLinearSystemInAbCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7CAAF16981546CE0">3.17-9 SolveLinearSystemInAbCategoryOrFail</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A722FA5817D5F76">3.17-10 MereExistenceOfSolutionOfLinearSystemInAbCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8666962D84B81665">3.17-11 MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E6E1269854E4B94">3.17-12 MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X85A7BE3185E58026">3.17-13 BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X798F78CE7EAA7F95">3.17-14 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X860621FE7C1E6634">3.17-15 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D473D9D83C53185">3.17-16 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7848040086B41266">3.17-17 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X834C3BB480D6561D">3.17-18 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7BFD58C57EC23BD5">3.17-19 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7CDC08947CF2022E">3.17-20 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X820B9AC886D78944">3.17-21 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8705DA127E089709">3.17-22 HomStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X873E91D180B3057C">3.17-23 ExtendRangeOfHomomorphismStructureByFullEmbedding</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C551C8F7BA2F3F1">3.17-24 ExtendRangeOfHomomorphismStructureByIdentityAsFullEmbedding</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8510A7E08672FD73">3.17-25 MorphismsOfExternalHom</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7CC9C1A487AE6086">3.17-26 BasisOfExternalHom</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8636593C845B23D2">3.17-27 CoefficientsOfMorphism</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7B39E2927B533D10">3.18 <span class="Heading">Simplified Morphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7FCE611883F6A56B">3.18-1 SimplifyMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DAD0E437D28F300">3.18-2 SimplifySource</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X843C68B97ED31DD4">3.18-3 SimplifySource_IsoToInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7CE5C1BB7BA7AA16">3.18-4 SimplifySource_IsoFromInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F80C5357F84A39A">3.18-5 SimplifyRange</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82FCEC277F3A1A70">3.18-6 SimplifyRange_IsoToInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X865CD95E7D068A77">3.18-7 SimplifyRange_IsoFromInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X821E16DF8071B8A4">3.18-8 SimplifySourceAndRange</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X84C39DE584D38D4E">3.18-9 SimplifySourceAndRange_IsoToInputRange</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X859DF3C2819FFE4D">3.18-10 SimplifySourceAndRange_IsoFromInputRange</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DD0915A7E23283E">3.18-11 SimplifySourceAndRange_IsoToInputSource</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X783C20A47889C4A8">3.18-12 SimplifySourceAndRange_IsoFromInputSource</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X830C7337864DB3D6">3.18-13 SimplifyEndo</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X78189F508549ABAA">3.18-14 SimplifyEndo_IsoToInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C07985D844FD715">3.18-15 SimplifyEndo_IsoFromInputObject</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D80D2B2792A7A50">3.18-16 Simplify</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X8379B7817AA67F2D">3.19 <span class="Heading">Reduction by split epi summands</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F997AF37E59411F">3.19-1 SomeReductionBySplitEpiSummand</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C92D8AF82E65289">3.19-2 SomeReductionBySplitEpiSummand_MorphismToInputRange</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A0F381279955981">3.19-3 SomeReductionBySplitEpiSummand_MorphismFromInputRange</a></span>
</div></div>
</div>

<h3>3 <span class="Heading">Morphisms</span></h3>

<p>Any GAP object satisfying <code class="code">IsCapCategoryMorphism</code> can be added to a category and then becomes a morphism in this category. Any morphism can belong to one or no category. After a GAP object is added to the category, it knows which things can be computed in its category and to which category it belongs. It knows categorical properties and attributes, and the functions for existential quantifiers can be applied to the morphism.</p>

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

<h4>3.1 <span class="Heading">Attributes for the Type of Morphisms</span></h4>

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

<h5>3.1-1 CapCategory</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is the category <span class="Math">\mathbf{C}</span> to which <span class="Math">\alpha</span> was added.</p>

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

<h5>3.1-2 Source</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Source</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an object</p>

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is its source <span class="Math">a</span>.</p>

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

<h5>3.1-3 Range</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Range</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an object</p>

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is its range <span class="Math">b</span>.</p>

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

<h5>3.1-4 Target</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Target</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an object</p>

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is its target <span class="Math">b</span>.</p>

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

<h4>3.2 <span class="Heading">Adding Morphisms to a Category</span></h4>

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

<h5>3.2-1 Add</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Add</code>( <var class="Arg">category</var>, <var class="Arg">morphism</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Adds <var class="Arg">morphism</var> as a morphism to <var class="Arg">category</var>.</p>

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

<h5>3.2-2 AddMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AddMorphism</code>( <var class="Arg">category</var>, <var class="Arg">morphism</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Adds <var class="Arg">morphism</var> as a morphism to <var class="Arg">category</var>. If <var class="Arg">morphism</var> already lies in the filter <code class="code">IsCapCategoryMorphism</code>, the operation <code class="func">Add</code> (<a href="chap3.html#X7BDADB628232C280"><span class="RefLink">3.2-1</span></a>) can be used instead.</p>

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

<h5>3.2-3 CreateCapCategoryMorphismWithAttributes</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CreateCapCategoryMorphismWithAttributes</code>( <var class="Arg">category</var>, <var class="Arg">source</var>, <var class="Arg">range</var>[, <var class="Arg">attr1</var>, <var class="Arg">val1</var>, <var class="Arg">attr2</var>, <var class="Arg">val2</var>, <var class="Arg">...</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a morphism</p>

<p>Creates a morphism in <var class="Arg">category</var> with the given attributes.</p>

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

<h5>3.2-4 AsCapCategoryMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsCapCategoryMorphism</code>( <var class="Arg">category</var>, <var class="Arg">source</var>, <var class="Arg">value</var>, <var class="Arg">range</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a morphism</p>

<p>EXPERIMENTAL: This specification might change any time without prior notice. Views <var class="Arg">value</var> as a morphism from <var class="Arg">source</var> to <var class="Arg">range</var> in <var class="Arg">category</var>.</p>

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

<h5>3.2-5 AsPrimitiveValue</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsPrimitiveValue</code>( <var class="Arg">morphism</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsInteger</code>( <var class="Arg">morphism</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AsHomalgMatrix</code>( <var class="Arg">morphism</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a value</p>

<p>EXPERIMENTAL: This specification might change any time without prior notice. Views a morphism obtained via <code class="func">AsCapCategoryMorphism</code> (<a href="chap3.html#X7AE302BE7C2E829F"><span class="RefLink">3.2-4</span></a>) as a primitive value again. Here, the word <em>primitive</em> means <em>primitive from the perspective of the category</em>. For example, from the perspective of an opposite category, morphisms of the underlying category are primitive values. The attribute is chosen according to the morphism datum type:</p>


<ul>
<li><p>For <code class="code">IsInt</code>, the attribute <code class="code">AsInteger</code> is used.</p>

</li>
<li><p>For <code class="code">IsHomalgMatrix</code>, the attribute <code class="code">AsHomalgMatrix</code> is used.</p>

</li>
</ul>
<p>In all other cases or if no morphism datum type is given, the attribute <code class="code">AsPrimitiveValue</code> is used.</p>

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

<h4>3.3 <span class="Heading">Morphism constructors</span></h4>

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

<h5>3.3-1 MorphismConstructor</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MorphismConstructor</code>( <var class="Arg">S</var>, <var class="Arg">a</var>, <var class="Arg">T</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(S,T)</span></p>

<p>The arguments are two objects <span class="Math">S</span> and <span class="Math">T</span> in a category, and a morphism datum <span class="Math">a</span> (type and semantics of the morphism datum depend on the category). The output is a morphism in <span class="Math">\mathrm{Hom}(S,T)</span> defined by <span class="Math">a</span>. Note that by default this CAP operation is not cached. You can change this behaviour by calling <code class="code">SetCachingToWeak( C, "MorphismConstructor" )</code> resp. <code class="code">SetCachingToCrisp( C, "MorphismConstructor" )</code>.</p>

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

<h5>3.3-2 MorphismDatum</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MorphismDatum</code>( <var class="Arg">mor</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: depends on the category</p>

<p>The argument is a CAP category morphism <var class="Arg">mor</var>. The output is a datum which can be used to construct <var class="Arg">mor</var>, that is, <code class="code">IsEqualForMorphisms( </code><var class="Arg">mor</var><code class="code">, MorphismConstructor( Source( </code><var class="Arg">mor</var><code class="code"> ), MorphismDatum( </code><var class="Arg">mor</var><code class="code"> ), Range( </code><var class="Arg">mor</var><code class="code"> ) ) )</code>. Note that by default this CAP operation is not cached. You can change this behaviour by calling <code class="code">SetCachingToWeak( C, "MorphismDatum" )</code> resp. <code class="code">SetCachingToCrisp( C, "MorphismDatum" )</code>.</p>

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

<h4>3.4 <span class="Heading">Categorical Properties of Morphisms</span></h4>

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

<h5>3.4-1 IsMonomorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is a monomorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-2 IsEpimorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is an epimorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-3 IsIsomorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is an isomorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-4 IsSplitMonomorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is a split monomorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-5 IsSplitEpimorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is a split epimorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-6 IsOne</h5>

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

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow a</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is congruent to the identity of <span class="Math">a</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.4-7 IsIdempotent</h5>

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

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow a</span>. The output is <code class="code">true</code> if <span class="Math">\alpha^2 \sim_{a,a} \alpha</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.5 <span class="Heading">Random Morphisms</span></h4>

<p>CAP provides two principal methods to generate random morphisms with or without fixed source and range:</p>


<ul>
<li><p><em>By integers</em>: The integer is simply a parameter that can be used to create a random morphism.</p>

</li>
<li><p><em>By lists</em>: The list is used when creating a random morphism would need more than one parameter. Lists offer more flexibility at the expense of the genericity of the methods. This happens because lists that are valid as input in some category may be not valid for other categories. Hence, these operations are not thought to be used in generic categorical algorithms.</p>

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

<h5>3.5-1 RandomMorphismWithFixedSourceByInteger</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedSourceByInteger</code>( <var class="Arg">a</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are an object <span class="Math">a</span> in a category <span class="Math">C</span> and an integer <span class="Math">n</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> for some object <span class="Math">b</span> in <span class="Math">C</span>. If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByInteger</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphismWithFixedSourceByInteger</code><span class="Math">(C,a,n)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code>(<span class="Math">C</span>,<span class="Math">a</span>,<span class="Math">b</span>,<span class="Math">1</span>+<code class="code">Log2Int</code>(<span class="Math">n</span>)) where <span class="Math">b</span> is computed via <code class="code">RandomObjectByInteger</code>(<span class="Math">C</span>,<span class="Math">n</span>).</p>

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

<h5>3.5-2 RandomMorphismWithFixedSourceByList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedSourceByList</code>( <var class="Arg">a</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are an object <span class="Math">a</span> in a category <span class="Math">C</span> and a list <span class="Math">L</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> for some object <span class="Math">b</span> in <span class="Math">C</span>. If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByList</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphismWithFixedSourceByList</code><span class="Math">(C,a,L)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code>(<span class="Math">C,a,b,L[2]</span>) where <span class="Math">b</span> is computed via <code class="code">RandomObjectByList</code>(<span class="Math">C,L[1]</span>).</p>

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

<h5>3.5-3 RandomMorphismWithFixedRangeByInteger</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedRangeByInteger</code>( <var class="Arg">b</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are an object <span class="Math">b</span> in a category <span class="Math">C</span> and an integer <span class="Math">n</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> for some object <span class="Math">a</span> in <span class="Math">C</span>. If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByInteger</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphismWithFixedRangeByInteger</code><span class="Math">(C,b,n)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code>(<span class="Math">C</span>,<span class="Math">a</span>,<span class="Math">b</span>,<span class="Math">1</span>+<code class="code">Log2Int</code>(<span class="Math">n</span>)) where <span class="Math">a</span> is computed via <code class="code">RandomObjectByInteger</code>(<span class="Math">C</span>,<span class="Math">n</span>).</p>

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

<h5>3.5-4 RandomMorphismWithFixedRangeByList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedRangeByList</code>( <var class="Arg">b</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are an object <span class="Math">b</span> in a category <span class="Math">C</span> and a list <span class="Math">L</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> for some object <span class="Math">a</span> in <span class="Math">C</span>. If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByList</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphismWithFixedRangeByList</code><span class="Math">(C,b,L)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code>(<span class="Math">C,a,b,L[2]</span>) where <span class="Math">a</span> is computed via <code class="code">RandomObjectByList</code>(<span class="Math">C,L[1]</span>).</p>

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

<h5>3.5-5 RandomMorphismWithFixedSourceAndRangeByInteger</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedSourceAndRangeByInteger</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span> in a category <span class="Math">C</span> and an integer <span class="Math">n</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> in <span class="Math">C</span>.</p>

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

<h5>3.5-6 RandomMorphismWithFixedSourceAndRangeByList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedSourceAndRangeByList</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>This operation is not a CAP basic operation The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span> in a category <span class="Math">C</span> and a list <span class="Math">L</span>. The output is a random morphism <span class="Math">\alpha: a \rightarrow b</span> in <span class="Math">C</span>.</p>

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

<h5>3.5-7 RandomMorphismByInteger</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismByInteger</code>( <var class="Arg">C</var>, <var class="Arg">n</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">C</span></p>

<p>The arguments are a category <span class="Math">C</span> and an integer <span class="Math">n</span>. The output is a random morphism in <span class="Math">C</span>. The operation can be derived in three different ways:</p>


<ul>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByInteger</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphism</code><span class="Math">(C,n)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByInteger</code>(<span class="Math">C,a,b</span>,<span class="Math">1</span>+<code class="code">Log2Int</code>(<span class="Math">n</span>)) where <span class="Math">a</span> and <span class="Math">b</span> are computed via <code class="code">RandomObjectByInteger</code>(<span class="Math">C,n</span>).</p>

</li>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByInteger</code> and <code class="code">RandomMorphismWithFixedSourceByInteger</code>, then <code class="code">RandomMorphism</code><span class="Math">(C,n)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceByInteger</code>(<span class="Math">C,a,1</span>+<code class="code">Log2Int</code>(<span class="Math">n</span>)) where <span class="Math">a</span> is computed via <code class="code">RandomObjectByInteger</code>(<span class="Math">C,n</span>).</p>

</li>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByInteger</code> and <code class="code">RandomMorphismWithFixedRangeByInteger</code>, then <code class="code">RandomMorphism</code><span class="Math">(C,n)</span> can be derived as <code class="code">RandomMorphismWithFixedRangeByInteger</code>(<span class="Math">C,b,1</span>+<code class="code">Log2Int</code>(<span class="Math">n</span>)) where <span class="Math">b</span> is computed via <code class="code">RandomObjectByInteger</code>(<span class="Math">C,n</span>).</p>

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

<h5>3.5-8 RandomMorphismByList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismByList</code>( <var class="Arg">C</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">C</span></p>

<p>The arguments are a category <span class="Math">C</span> and a list <span class="Math">L</span>. The output is a random morphism in <span class="Math">C</span>. The operation can be derived in three different ways:</p>


<ul>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByList</code> and <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code> and <span class="Math">C</span> is an Ab-category, then <code class="code">RandomMorphism</code><span class="Math">(C,L)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceAndRangeByList</code>(<span class="Math">C,a,b,L[3]</span>)) where <span class="Math">a</span> and <span class="Math">b</span> are computed via <code class="code">RandomObjectByList</code>(<span class="Math">C,L[i]</span>) for <span class="Math">i=1,2</span> respectively.</p>

</li>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByList</code> and <code class="code">RandomMorphismWithFixedSourceByList</code>, then <code class="code">RandomMorphism</code><span class="Math">(C,L)</span> can be derived as <code class="code">RandomMorphismWithFixedSourceByList</code>(<span class="Math">C,a,L[2]</span>) where <span class="Math">a</span> is computed via <code class="code">RandomObjectByList</code>(<span class="Math">C,L[1]</span>).</p>

</li>
<li><p>If <span class="Math">C</span> is equipped with the methods <code class="code">RandomObjectByList</code> and <code class="code">RandomMorphismWithFixedRangeByList</code>, then <code class="code">RandomMorphism</code><span class="Math">(C,L)</span> can be derived as <code class="code">RandomMorphismWithFixedRangeByList</code>(<span class="Math">C,b,L[2]</span>) where <span class="Math">b</span> is computed via <code class="code">RandomObjectByList</code>(<span class="Math">C,L[1]</span>).</p>

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

<h5>3.5-9 RandomMorphismWithFixedSource</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RandomMorphismWithFixedSource</code>( <var class="Arg">a</var>, <var class="Arg">n</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">‣ RandomMorphismWithFixedSource</code>( <var class="Arg">a</var>, <var class="Arg">L</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">‣ RandomMorphismWithFixedRange</code>( <var class="Arg">b</var>, <var class="Arg">n</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">‣ RandomMorphismWithFixedRange</code>( <var class="Arg">b</var>, <var class="Arg">L</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">‣ RandomMorphismWithFixedSourceAndRange</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">n</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">‣ RandomMorphismWithFixedSourceAndRange</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">L</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">‣ RandomMorphism</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">n</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">‣ RandomMorphism</code>( <var class="Arg">a</var>, <var class="Arg">b</var>, <var class="Arg">L</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">‣ RandomMorphism</code>( <var class="Arg">C</var>, <var class="Arg">n</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">‣ RandomMorphism</code>( <var class="Arg">C</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>These are convenient methods and they, depending on the input, delegate to one of the above methods.</p>

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

<h4>3.6 <span class="Heading">Non-Categorical Properties of Morphisms</span></h4>

<p>Non-categorical properties are not stable under equivalences of categories.</p>

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

<h5>3.6-1 IsEqualToIdentityMorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is <code class="code">true</code> if <span class="Math">\alpha = \mathrm{id}_a</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.6-2 IsEqualToZeroMorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is <code class="code">true</code> if <span class="Math">\alpha = 0</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.6-3 IsEndomorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is an endomorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.6-4 IsAutomorphism</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is an automorphism, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.7 <span class="Heading">Equality and Congruence for Morphisms</span></h4>

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

<h5>3.7-1 IsCongruentForMorphisms</h5>

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

<p>The arguments are two morphisms <span class="Math">\alpha, \beta: a \rightarrow b</span>. The output is <code class="code">true</code> if <span class="Math">\alpha \sim_{a,b} \beta</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.7-2 IsEqualForMorphisms</h5>

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

<p>The arguments are two morphisms <span class="Math">\alpha, \beta: a \rightarrow b</span>. The output is <code class="code">true</code> if <span class="Math">\alpha = \beta</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.7-3 IsEqualForMorphismsOnMor</h5>

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

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow b, \beta: c \rightarrow d</span>. The output is <code class="code">true</code> if <span class="Math">\alpha = \beta</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.8 <span class="Heading">Basic Operations for Morphisms in Ab-Categories</span></h4>

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

<h5>3.8-1 IsZeroForMorphisms</h5>

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

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is <code class="code">true</code> if <span class="Math">\alpha \sim_{a,b} 0</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.8-2 AdditionForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdditionForMorphisms</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha, \beta: a \rightarrow b</span>. The output is the addition <span class="Math">\alpha + \beta</span>. Note: The addition has to be compatible with the congruence of morphisms.</p>

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

<h5>3.8-3 SubtractionForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubtractionForMorphisms</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha, \beta: a \rightarrow b</span>. The output is the addition <span class="Math">\alpha - \beta</span>. Note: The addition has to be compatible with the congruence of morphisms.</p>

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

<h5>3.8-4 AdditiveInverseForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdditiveInverseForMorphisms</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is its additive inverse <span class="Math">-\alpha</span>. Note: The addition has to be compatible with the congruence of morphisms.</p>

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

<h5>3.8-5 MultiplyWithElementOfCommutativeRingForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MultiplyWithElementOfCommutativeRingForMorphisms</code>( <var class="Arg">r</var>, <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are an element <span class="Math">r</span> of a commutative ring and a morphism <span class="Math">\alpha: a \rightarrow b</span>. The output is the multiplication with the ring element <span class="Math">r \cdot \alpha</span>. Note: The multiplication has to be compatible with the congruence of morphisms.</p>

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

<h5>3.8-6 *</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ *</code>( <var class="Arg">r</var>, <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>This is a convenience method. It has two arguments. The first argument is either a rational number <span class="Math">q</span> or an element <span class="Math">r</span> of a commutative ring <span class="Math">R</span>. The second argument is a morphism <span class="Math">\alpha: a \rightarrow b</span> in a linear category over the commutative ring <span class="Math">R</span>. In the case where the first element is a rational number, this method tries to interpret <span class="Math">q</span> as an element <span class="Math">r</span> of <span class="Math">R</span> via <code class="code">R!.interpret_rationals_func</code>. If no such interpretation exists, this method throws an error. The output is the multiplication with the ring element <span class="Math">r \cdot \alpha</span>.</p>

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

<h5>3.8-7 ZeroMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ZeroMorphism</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span>. The output is the zero morphism <span class="Math">0: a \rightarrow b</span>.</p>

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

<h4>3.9 <span class="Heading">Subobject and Factorobject Operations</span></h4>

<p>Subobjects of an object <span class="Math">c</span> are monomorphisms with range <span class="Math">c</span> and a special function for comparision. Similarly, factorobjects of an object <span class="Math">c</span> are epimorphisms with source <span class="Math">c</span> and a special function for comparision.</p>

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

<h5>3.9-1 IsEqualAsSubobjects</h5>

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

<p>The arguments are two subobjects <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span>. The output is <code class="code">true</code> if there exists an isomorphism <span class="Math">\iota: a \rightarrow b</span> such that <span class="Math">\beta \circ \iota \sim_{a,c} \alpha</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.9-2 IsEqualAsFactorobjects</h5>

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

<p>The arguments are two factorobjects <span class="Math">\alpha: c \rightarrow a</span>, <span class="Math">\beta: c \rightarrow b</span>. The output is <code class="code">true</code> if there exists an isomorphism <span class="Math">\iota: b \rightarrow a</span> such that <span class="Math">\iota \circ \beta \sim_{c,a} \alpha</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.9-3 IsDominating</h5>

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

<p>In short: Returns <code class="code">true</code> iff <span class="Math">\alpha</span> is smaller than <span class="Math">\beta</span>. Full description: The arguments are two subobjects <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span>. The output is <code class="code">true</code> if there exists a morphism <span class="Math">\iota: a \rightarrow b</span> such that <span class="Math">\beta \circ \iota \sim_{a,c} \alpha</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.9-4 IsCodominating</h5>

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

<p>In short: Returns <code class="code">true</code> iff <span class="Math">\alpha</span> is smaller than <span class="Math">\beta</span>. Full description: The arguments are two factorobjects <span class="Math">\alpha: c \rightarrow a</span>, <span class="Math">\beta: c \rightarrow b</span>. The output is <code class="code">true</code> if there exists a morphism <span class="Math">\iota: b \rightarrow a</span> such that <span class="Math">\iota \circ \beta \sim_{c,a} \alpha</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.10 <span class="Heading">Identity Morphism and Composition of Morphisms</span></h4>

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

<h5>3.10-1 IdentityMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IdentityMorphism</code>( <var class="Arg">a</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,a)</span></p>

<p>The argument is an object <span class="Math">a</span>. The output is its identity morphism <span class="Math">\mathrm{id}_a</span>.</p>

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

<h5>3.10-2 PreCompose</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreCompose</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}( a, c )</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow b</span>, <span class="Math">\beta: b \rightarrow c</span>. The output is the composition <span class="Math">\beta \circ \alpha: a \rightarrow c</span>.</p>

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

<h5>3.10-3 PreCompose</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreCompose</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a_1, a_{n+1})</span></p>

<p>This is a convenience method. The argument is a list of morphisms <span class="Math">L = ( \alpha_1: a_1 \rightarrow a_2, \alpha_2: a_2 \rightarrow a_3, \dots, \alpha_n: a_n \rightarrow a_{n+1} )</span>. The output is the composition <span class="Math">\alpha_{n} \circ ( \alpha_{n-1} \circ ( \dots ( \alpha_2 \circ \alpha_1 ) ) )</span>.</p>

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

<h5>3.10-4 PreComposeList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreComposeList</code>( <var class="Arg">s</var>, <var class="Arg">L</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(s, r)</span></p>

<p>The arguments are two objects <var class="Arg">s</var> = <span class="Math">a_1</span>, <var class="Arg">r</var> = <span class="Math">a_{n+1}</span>, and a list of morphisms <span class="Math">L = ( \alpha_1: a_1 \rightarrow a_2, \alpha_2: a_2 \rightarrow a_3, \dots, \alpha_n: a_n \rightarrow a_{n+1} )</span> in <span class="Math">C</span>. The output is the composition <span class="Math">\alpha_{n} \circ ( \alpha_{n-1} \circ ( \dots ( \alpha_2 \circ \alpha_1 ) ) )</span>. If <span class="Math">L</span> is empty, then <span class="Math">s</span> must be equal to <span class="Math">r</span> and the output is congruent to the identity morphism of <span class="Math">s</span>.</p>

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

<h5>3.10-5 PostCompose</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PostCompose</code>( <var class="Arg">beta</var>, <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}( a, c )</span></p>

<p>The arguments are two morphisms <span class="Math">\beta: b \rightarrow c</span>, <span class="Math">\alpha: a \rightarrow b</span>. The output is the composition <span class="Math">\beta \circ \alpha: a \rightarrow c</span>.</p>

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

<h5>3.10-6 PostCompose</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PostCompose</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a_1, a_{n+1})</span></p>

<p>This is a convenience method. The argument is a list of morphisms <span class="Math">L = ( \alpha_n: a_n \rightarrow a_{n+1}, \alpha_{n-1}: a_{n-1} \rightarrow a_n, \dots, \alpha_1: a_1 \rightarrow a_2 )</span>. The output is the composition <span class="Math">((\alpha_{n} \circ \alpha_{n-1}) \circ \dots \alpha_2) \circ \alpha_1</span>.</p>

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

<h5>3.10-7 PostComposeList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PostComposeList</code>( <var class="Arg">s</var>, <var class="Arg">L</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(s, r)</span></p>

<p>The arguments are two objects <var class="Arg">s</var> = <span class="Math">a_1</span>, <var class="Arg">r</var> = <span class="Math">a_{n+1}</span>, and a list of morphisms <span class="Math">L = ( \alpha_n: a_n \rightarrow a_{n+1}, \alpha_{n-1}: a_{n-1} \rightarrow a_n, \dots, \alpha_1: a_1 \rightarrow a_2 )</span>. The output is the composition <span class="Math">((\alpha_{n} \circ \alpha_{n-1}) \circ \dots \alpha_2) \circ \alpha_1</span>. If <span class="Math">L</span> is empty, then <span class="Math">s</span> must be equal to <span class="Math">r</span> and the output is congruent to the identity morphism of <span class="Math">s</span>.</p>

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

<h5>3.10-8 SumOfMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SumOfMorphisms</code>( <var class="Arg">s</var>, <var class="Arg">morphisms</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(s,r)</span></p>

<p>The arguments are two objects <var class="Arg">s</var>, <var class="Arg">r</var> and a list <var class="Arg">morphisms</var> of morphisms from <var class="Arg">s</var> to <var class="Arg">r</var>. The output is the sum of all elements in <var class="Arg">morphisms</var>, or the zero-morphism from <var class="Arg">s</var> to <var class="Arg">r</var> if <var class="Arg">morphisms</var> is empty.</p>

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

<h5>3.10-9 LinearCombinationOfMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LinearCombinationOfMorphisms</code>( <var class="Arg">s</var>, <var class="Arg">coeffs</var>, <var class="Arg">mors</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(s,r)</span></p>

<p>The arguments are two objects <var class="Arg">s</var>, <var class="Arg">r</var> in some linear category over a ring <span class="Math">R</span>, a list <var class="Arg">coeffs</var> of ring elements in <span class="Math">R</span> and a list <var class="Arg">mors</var> of morphisms from <var class="Arg">s</var> to <var class="Arg">r</var>. The output is the linear combination of the morphisms in <var class="Arg">mors</var> with respect to the coefficients list <var class="Arg">coeffs</var>, or the zero morphism from <var class="Arg">s</var> to <var class="Arg">r</var> if <var class="Arg">coeffs</var> and <var class="Arg">mors</var> are the empty lists.</p>

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

<h4>3.11 <span class="Heading">Well-Definedness of Morphisms</span></h4>

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

<h5>3.11-1 IsWellDefinedForMorphisms</h5>

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

<p>The argument is a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is well-defined, otherwise the output is <code class="code">false</code>.</p>

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

<h5>3.11-2 IsWellDefinedForMorphismsWithGivenSourceAndRange</h5>

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

<p>The arguments are two well-defined objects <span class="Math">S</span> and <span class="Math">T</span> and a morphism <span class="Math">\alpha</span>. The output is <code class="code">true</code> if <span class="Math">\alpha</span> is a well-defined morphism from <span class="Math">S</span> to <span class="Math">T</span>, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.12 <span class="Heading">Lift/Colift</span></h4>


<ul>
<li><p>For any pair of morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span>, we call each morphism <span class="Math">\alpha / \beta: a \rightarrow b</span> such that <span class="Math">\beta \circ (\alpha / \beta) \sim_{a,c} \alpha</span> a <em>lift of <span class="Math">\alpha</span> along <span class="Math">\beta</span></em>.</p>

</li>
<li><p>For any pair of morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: a \rightarrow b</span>, we call each morphism <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> such that <span class="Math">(\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta</span> a <em> colift of <span class="Math">\beta</span> along <span class="Math">\alpha</span></em>.</p>

</li>
</ul>
<p>Note that such lifts (or colifts) do not have to be unique. So in general, we do not expect that algorithms computing lifts (or colifts) do this in a functorial way. Thus the operations <span class="Math">\mathtt{Lift}</span> and <span class="Math">\mathtt{Colift}</span> are not regarded as categorical operations, but only as set-theoretic operations.</p>

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

<h5>3.12-1 LiftAlongMonomorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LiftAlongMonomorphism</code>( <var class="Arg">iota</var>, <var class="Arg">tau</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(t,k)</span></p>

<p>The arguments are a monomorphism <span class="Math">\iota: k \hookrightarrow a</span> and a morphism <span class="Math">\tau: t \rightarrow a</span> such that there is a morphism <span class="Math">u: t \rightarrow k</span> with <span class="Math">\iota \circ u \sim_{t,a} \tau</span>. The output is such a <span class="Math">u</span>.</p>

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

<h5>3.12-2 ColiftAlongEpimorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ColiftAlongEpimorphism</code>( <var class="Arg">epsilon</var>, <var class="Arg">tau</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(c,t)</span></p>

<p>The arguments are an epimorphism <span class="Math">\epsilon: a \rightarrow c</span> and a morphism <span class="Math">\tau: a \rightarrow t</span> such that there is a morphism <span class="Math">u: c \rightarrow t</span> with <span class="Math">u \circ \epsilon \sim_{a,t} \tau</span>. The output is such a <span class="Math">u</span>.</p>

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

<h5>3.12-3 IsLiftableAlongMonomorphism</h5>

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

<p>The arguments are a monomorphism <span class="Math">\iota: k \hookrightarrow a</span> and a morphism <span class="Math">\tau: t \rightarrow a</span>. The output is <code class="code">true</code> if there exists a morphism <span class="Math">u: t \rightarrow k</span> with <span class="Math">\iota \circ u \sim_{t,a} \tau</span>. Otherwise, the output is <code class="code">false</code>.</p>

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

<h5>3.12-4 IsColiftableAlongEpimorphism</h5>

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

<p>The arguments are an epimorphism <span class="Math">\epsilon: a \rightarrow c</span> and a morphism <span class="Math">\tau: a \rightarrow t</span>. The output is <code class="code">true</code> if there exists a morphism <span class="Math">u: c \rightarrow t</span> with <span class="Math">u \circ \epsilon \sim_{a,t} \tau</span>. Otherwise, the output is <code class="code">false</code>.</p>

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

<h5>3.12-5 Lift</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Lift</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b)</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span> such that a lift <span class="Math">\alpha / \beta: a \rightarrow b</span> of <span class="Math">\alpha</span> along <span class="Math">\beta</span> exists. The output is such a lift <span class="Math">\alpha / \beta: a \rightarrow b</span>. Recall that a lift <span class="Math">\alpha / \beta: a \rightarrow b</span> of <span class="Math">\alpha</span> along <span class="Math">\beta</span> is a morphism such that <span class="Math">\beta \circ (\alpha / \beta) \sim_{a,c} \alpha</span>.</p>

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

<h5>3.12-6 LiftOrFail</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LiftOrFail</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(a,b) + \{ \mathtt{fail} \}</span></p>

<p>This is a convenience operation. The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span>. The output is a lift <span class="Math">\alpha / \beta: a \rightarrow b</span> of <span class="Math">\alpha</span> along <span class="Math">\beta</span> if such a lift exists or <span class="Math">\mathtt{fail}</span> if it doesn't. Recall that a lift <span class="Math">\alpha / \beta: a \rightarrow b</span> of <span class="Math">\alpha</span> along <span class="Math">\beta</span> is a morphism such that <span class="Math">\beta \circ (\alpha / \beta) \sim_{a,c} \alpha</span>.</p>

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

<h5>3.12-7 IsLiftable</h5>

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

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: b \rightarrow c</span>. The output is <code class="code">true</code> if there exists a lift <span class="Math">\alpha / \beta: a \rightarrow b</span> of <span class="Math">\alpha</span> along <span class="Math">\beta</span>, i.e., a morphism such that <span class="Math">\beta \circ (\alpha / \beta) \sim_{a,c} \alpha</span>. Otherwise, the output is <code class="code">false</code>.</p>

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

<h5>3.12-8 Colift</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Colift</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(c,b)</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: a \rightarrow b</span> such that a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> of <span class="Math">\beta</span> along <span class="Math">\alpha</span> exists. The output is such a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span>. Recall that a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> of <span class="Math">\beta</span> along <span class="Math">\alpha</span> is a morphism such that <span class="Math">(\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta</span>.</p>

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

<h5>3.12-9 ColiftOrFail</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ColiftOrFail</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(c,b) + \{ \mathtt{fail} \}</span></p>

<p>This is a convenience operation. The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: a \rightarrow b</span>. The output is a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> of <span class="Math">\beta</span> along <span class="Math">\alpha</span> if such a colift exists or <span class="Math">\mathtt{fail}</span> if it doesn't. Recall that a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> of <span class="Math">\beta</span> along <span class="Math">\alpha</span> is a morphism such that <span class="Math">(\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta</span>.</p>

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

<h5>3.12-10 IsColiftable</h5>

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

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow c</span>, <span class="Math">\beta: a \rightarrow b</span>. The output is <code class="code">true</code> if there exists a colift <span class="Math">\alpha \backslash \beta: c \rightarrow b</span> of <span class="Math">\beta</span> along <span class="Math">\alpha</span>., i.e., a morphism such that <span class="Math">(\alpha \backslash \beta) \circ \alpha \sim_{a,b} \beta</span>. Otherwise, the output is <code class="code">false</code>.</p>

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

<h4>3.13 <span class="Heading">Inverses</span></h4>

<p>Let <span class="Math">\alpha: a \rightarrow b</span> be a morphism. An inverse of <span class="Math">\alpha</span> is a morphism <span class="Math">\alpha^{-1}: b \rightarrow a</span> such that <span class="Math">\alpha \circ \alpha^{-1} \sim_{b,b} \mathrm{id}_b</span> and <span class="Math">\alpha^{-1} \circ \alpha \sim_{a,a} \mathrm{id}_a</span>.</p>

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

<h5>3.13-1 InverseForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InverseForMorphisms</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(b,a)</span></p>

<p>The argument is an isomorphism <span class="Math">\alpha: a \rightarrow b</span>. The output is its inverse <span class="Math">\alpha^{-1}: b \rightarrow a</span>.</p>

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

<h5>3.13-2 PreInverseForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreInverseForMorphisms</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(b,a)</span></p>

<p>The argument is a split-epimorphism <span class="Math">\alpha: a \rightarrow b</span>. The output is a pre-inverse <span class="Math">\iota: b \rightarrow a</span> of <span class="Math">\alpha</span>, i.e., <span class="Math">\iota</span> satisfies <span class="Math">\alpha \circ \iota \sim_{b,b} \mathrm{id}_b</span>. The morphism <span class="Math">\iota</span> is also known as a section or a right-inverse of <span class="Math">\alpha</span>.</p>

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

<h5>3.13-3 PostInverseForMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PostInverseForMorphisms</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(b,a)</span></p>

<p>The argument is a split-monomorphism <span class="Math">\alpha: a \rightarrow b</span>. The output is a post-inverse <span class="Math">\pi: b \rightarrow a</span> of <span class="Math">\alpha</span>, i.e., <span class="Math">\pi</span> satisfies <span class="Math">\pi \circ \alpha \sim_{a,a} \mathrm{id}_a</span>. The morphism <span class="Math">\pi</span> is also known as a contraction or a left-inverse of <span class="Math">\alpha</span>.</p>

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

<h4>3.14 <span class="Heading">Tool functions for caches</span></h4>

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

<h5>3.14-1 IsEqualForCacheForMorphisms</h5>

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

<p>By default, CAP uses caches to store the values of Categorical operations. To get a value out of the cache, one needs to compare the input of a basic operation with its previous input. To compare morphisms in the category, IsEqualForCacheForMorphisms is used. By default, IsEqualForCacheForMorphisms falls back to IsEqualForCache (see ToolsForHomalg), which in turn defaults to recursive comparison for lists and <code class="code">IsIdenticalObj</code> in all other cases. If you add a function via <code class="code">AddIsEqualForCacheForMorphisms</code>, that function is used instead. A function <span class="Math">F: a,b \mapsto bool</span> is expected there. The output has to be true or false. Fail is not allowed in this context.</p>

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

<h4>3.15 <span class="Heading">IsHomSetInhabited</span></h4>

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

<h5>3.15-1 IsHomSetInhabited</h5>

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

<p>The arguments are two objects <var class="Arg">A</var> and <var class="Arg">B</var>. The output is <code class="code">true</code> if there exists a morphism from <var class="Arg">A</var> to <var class="Arg">B</var>, otherwise the output is <code class="code">false</code>.</p>

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

<h4>3.16 <span class="Heading">SetOfMorphisms</span></h4>

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

<h5>3.16-1 SetOfMorphismsOfFiniteCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SetOfMorphismsOfFiniteCategory</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of a <strong class="pkg">CAP</strong> category morphisms</p>

<p>Return a duplicate free list of morphisms of the finite category <var class="Arg">C</var>.</p>

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

<h5>3.16-2 SetOfMorphisms</h5>

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

<p>Return a duplicate free list of morphisms of the finite category <var class="Arg">C</var>. The corresponding <strong class="pkg">CAP</strong> operation is <code class="code">SetOfMorphismsOfFiniteCategory</code>.</p>

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

<h4>3.17 <span class="Heading">Homomorphism structures</span></h4>

<p>Homomorphism structures are way to "oversee" the homomorphisms between two given objects. Let <span class="Math">C</span>, <span class="Math">D</span> be categories. A <span class="Math">D</span>-homomorphism structure for <span class="Math">C</span> consists of the following data:</p>


<ul>
<li><p>a functor <span class="Math">H: C^{\mathrm{op}} \times C \rightarrow D</span> (when <span class="Math">C</span> and <span class="Math">D</span> are Ab-categories, <span class="Math">H</span> is assumed to be bilinear).</p>

</li>
<li><p>an object <span class="Math">1 \in D</span>, called the distinguished object,</p>

</li>
<li><p>a bijection <span class="Math">\nu: \mathrm{Hom}_{C}(a,b) \simeq \mathrm{Hom}_{D}(1, H(a,b))</span> natural in <span class="Math">a,b \in C</span>.</p>

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

<h5>3.17-1 HomomorphismStructureOnObjects</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomomorphismStructureOnObjects</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: an object in <span class="Math">D</span></p>

<p>The arguments are two objects <span class="Math">a, b</span> in <span class="Math">C</span>. The output is the value of the homomorphism structure on objects <span class="Math">H(a,b)</span>.</p>

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

<h5>3.17-2 HomomorphismStructureOnMorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomomorphismStructureOnMorphisms</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(H(a',b), H(a,b'))</span></p>

<p>The arguments are two morphisms <span class="Math">\alpha: a \rightarrow a', \beta: b \rightarrow b'</span> in <span class="Math">C</span>. The output is the value of the homomorphism structure on morphisms <span class="Math">H(\alpha, \beta )</span>.</p>

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

<h5>3.17-3 HomomorphismStructureOnMorphismsWithGivenObjects</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomomorphismStructureOnMorphismsWithGivenObjects</code>( <var class="Arg">s</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(H(a',b), H(a,b'))</span></p>

<p>The arguments are an object <span class="Math">s = H(a',b)</span> in <span class="Math">D</span>, two morphisms <span class="Math">\alpha: a \rightarrow a', \beta: b \rightarrow b'</span> in <span class="Math">C</span>, and an object <span class="Math">r = H(a,b')</span> in <span class="Math">D</span>. The output is the value of the homomorphism structure on morphisms <span class="Math">H(\alpha, \beta )</span>.</p>

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

<h5>3.17-4 DistinguishedObjectOfHomomorphismStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DistinguishedObjectOfHomomorphismStructure</code>( <var class="Arg">C</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: an object in <span class="Math">D</span></p>

<p>The argument is a category <span class="Math">C</span>. The output is the distinguished object <span class="Math">1</span> in <span class="Math">D</span> of the homomorphism structure.</p>

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

<h5>3.17-5 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(1, H(a,a'))</span></p>

<p>The argument is a morphism <span class="Math">\alpha: a \rightarrow a'</span> in <span class="Math">C</span>. The output is the corresponding morphism <span class="Math">\nu( \alpha ): 1 \rightarrow H(a,a')</span> in <span class="Math">D</span> of the homomorphism structure.</p>

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

<h5>3.17-6 InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjects</code>( <var class="Arg">distinguished_object</var>, <var class="Arg">alpha</var>, <var class="Arg">r</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(1, r)</span></p>

<p>The arguments are the distinguished object <span class="Math">1</span>, a morphism <span class="Math">\alpha: a \rightarrow a'</span>, and the object <span class="Math">r = H(a,a')</span>. The output is the corresponding morphism <span class="Math">\nu( \alpha ): 1 \rightarrow r</span> in <span class="Math">D</span> of the homomorphism structure.</p>

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

<h5>3.17-7 InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism</code>( <var class="Arg">a</var>, <var class="Arg">a'</var>, <var class="Arg">iota</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{C}(a,a')</span></p>

<p>The arguments are objects <span class="Math">a,a'</span> in <span class="Math">C</span> and a morphism <span class="Math">\iota: 1 \rightarrow H(a,a')</span> in <span class="Math">D</span>. The output is the corresponding morphism <span class="Math">\nu^{-1}(\iota): a \rightarrow a'</span> in <span class="Math">C</span> of the homomorphism structure.</p>

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

<h5>3.17-8 SolveLinearSystemInAbCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SolveLinearSystemInAbCategory</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of morphisms <span class="Math">[X_1, \dots, X_n]</span></p>

<p>The arguments are three lists <span class="Math">\alpha</span>, <span class="Math">\beta</span>, and <span class="Math">\gamma</span>. The first list <span class="Math">\alpha</span> (the left coefficients) is a list of list of morphisms <span class="Math">\alpha_{ij}: A_i \rightarrow B_j</span>, where <span class="Math">i = 1 \dots m</span> and <span class="Math">j = 1 \dots n</span> for integers <span class="Math">m,n \geq 1</span>. The second list <span class="Math">\beta</span> (the right coefficients) is a list of list of morphisms <span class="Math">\beta_{ij}: C_j \rightarrow D_i</span>, where <span class="Math">i = 1 \dots m</span> and <span class="Math">j = 1 \dots n</span>. The third list <span class="Math">\gamma</span> (the right side) is a list of morphisms <span class="Math">\gamma_i: A_i \rightarrow D_i</span>, where <span class="Math">i = 1, \dots, m</span>. Assumes that a solution to the linear system defined by <span class="Math">\alpha</span>, <span class="Math">\beta</span>, <span class="Math">\gamma</span> exists, i.e., there exist morphisms <span class="Math">X_j: B_j \rightarrow C_j</span> for <span class="Math">j=1\dots n</span> such that <span class="Math">\sum_{j = 1}^n \alpha_{ij}\cdot X_j \cdot \beta_{ij} = \gamma_i</span> for all <span class="Math">i = 1 \dots m</span>. The output is list of such morphisms <span class="Math">X_j: B_j \rightarrow C_j</span> for <span class="Math">j=1\dots n</span>.</p>

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

<h5>3.17-9 SolveLinearSystemInAbCategoryOrFail</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SolveLinearSystemInAbCategoryOrFail</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of morphisms <span class="Math">[X_1, \dots, X_n]</span> or <code class="code">fail</code></p>

<p>This is a convenience operation. Like <code class="code">SolveLinearSystemInAbCategory</code>, but without the assumption that a solution exists. If no solution exists, <code class="code">fail</code> is returned.</p>

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

<h5>3.17-10 MereExistenceOfSolutionOfLinearSystemInAbCategory</h5>

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

<p>Like <code class="code">SolveLinearSystemInAbCategory</code>, but the output is simply <code class="code">true</code> if a solution exists, <code class="code">false</code> otherwise.</p>

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

<h5>3.17-11 MereExistenceOfUniqueSolutionOfLinearSystemInAbCategory</h5>

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

<p>Like <code class="code">SolveLinearSystemInAbCategory</code>, but the output is simply <code class="code">true</code> if a unique solution exists, and <code class="code">false</code> otherwise.</p>

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

<h5>3.17-12 MereExistenceOfUniqueSolutionOfHomogeneousLinearSystemInAbCategory</h5>

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

<p>Like <code class="code">SolveLinearSystemInAbCategory</code> but the output is <code class="code">true</code> if the homogeneous system has only the trivial zero solution, and <code class="code">false</code> otherwise.</p>

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

<h5>3.17-13 BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BasisOfSolutionsOfHomogeneousLinearSystemInLinearCategory</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of lists of morphisms <span class="Math">[X^1, \dots, X^t]</span></p>

<p>The arguments are two lists of lists <span class="Math">\alpha</span> and <span class="Math">\beta</span> of morphisms in a linear category over a commutative ring <span class="Math">k</span>. The first list <span class="Math">\alpha</span> (the left coefficients) is a list of list of morphisms <span class="Math">\alpha_{ij}: A_i \rightarrow B_j</span>, where <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span> for integers <span class="Math">m,n \geq 1</span>. The second list <span class="Math">\beta</span> (the right coefficients) is a list of list of morphisms <span class="Math">\beta_{ij}: C_j \rightarrow D_i</span>, where <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span>. The output is a generating set <span class="Math">[X^1,\dots,X^t]</span> for the solutions of the homogeneous linear system: <span class="Math">\sum_{j = 1}^n \alpha_{ij}\cdot X_{j} \cdot \beta_{ij} = 0, ~i = 1, \dots, m</span>. Particularly, each <span class="Math">X^k</span> is a list (of length <span class="Math">n</span>) of morphisms <span class="Math">X^k_j:B_j \to C_j, j=1,\dots,n</span>.</p>

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

<h5>3.17-14 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">gamma</var>, <var class="Arg">delta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of lists of morphisms <span class="Math">[X^1, \dots, X^t]</span></p>

<p>The arguments are four lists of lists <span class="Math">\alpha</span>, <span class="Math">\beta</span>, <span class="Math">\gamma</span>, <span class="Math">\delta</span> of morphisms in some linear category over commutative ring. Each of <span class="Math">\alpha</span> and <span class="Math">\gamma</span> is a list of list of morphisms <span class="Math">\alpha_{ij}, \gamma_{ij}: A_i \rightarrow B_j</span>, where <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span> for integers <span class="Math">m,n \geq 1</span>. Each of <span class="Math">\beta</span> and <span class="Math">\delta</span> is also a list of list of morphisms <span class="Math">\beta_{ij}, \delta_{ij}: C_j \rightarrow D_i</span>, where <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span>. The output is a generating set <span class="Math">[X^1,\dots,X^t]</span> for the solutions of the homogeneous linear system defined by <span class="Math">\alpha</span>, <span class="Math">\beta</span>, <span class="Math">\gamma</span> and <span class="Math">\delta</span>, i.e., <span class="Math">\sum_{j = 1}^n \alpha_{ij}\cdot X^{k}_{j} \cdot \beta_{ij} = \sum_{j = 1}^n \gamma_{ij}\cdot X^{k}_{j} \cdot \delta_{ij}</span> for all <span class="Math">i = 1, \dots, m</span> and all <span class="Math">k = 1, \dots, t</span>.</p>

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

<h5>3.17-15 BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</code>( <var class="Arg">alpha</var>, <var class="Arg">delta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of lists of morphisms <span class="Math">[X^1, \dots, X^t]</span></p>

<p>The arguments are two lists of lists <span class="Math">\alpha</span>, <span class="Math">\delta</span> morphisms in some linear category over commutative ring. <span class="Math">\alpha</span> is a list of list of morphisms <span class="Math">\alpha_{ij}:A_i \rightarrow B_j</span> and <span class="Math">\delta</span> is a list of list of morphisms <span class="Math">\delta_{ij}:C_j \rightarrow D_i</span>, where <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span> for integers <span class="Math">m,n \geq 1</span>. The method delegates to <code class="code">BasisOfSolutionsOfHomogeneousDoubleLinearSystemInLinearCategory</code> applied on <span class="Math">\alpha</span>, <span class="Math">\beta</span>, <span class="Math">\gamma</span>, <span class="Math">\delta</span> where</p>


<ul>
<li><p><span class="Math">\beta_{ij}</span> equals <code class="code">IdentityMorphism</code>(<code class="code">Source</code>(<span class="Math">\delta_{ij}</span>)) if <span class="Math">\delta_{ij}</span> is an endomorphism, and <code class="code">ZeroMorphism</code>(<code class="code">Source</code>(<span class="Math">\delta_{ij}</span>), <code class="code">Range</code>(<span class="Math">\delta_{ij}</span>)) otherwise,</p>

</li>
<li><p><span class="Math">\gamma_{ij}</span> equals <code class="code">IdentityMorphism</code>(<code class="code">Source</code>(<span class="Math">\alpha_{ij}</span>)) if <span class="Math">\alpha_{ij}</span> is an endomorphism, and <code class="code">ZeroMorphism</code>(<code class="code">Source</code>(<span class="Math">\alpha_{ij}</span>), <code class="code">Range</code>(<span class="Math">\alpha_{ij}</span>)) otherwise;</p>

</li>
</ul>
<p>for all <span class="Math">i = 1, \dots, m</span> and <span class="Math">j = 1, \dots, n</span>.</p>

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

<h5>3.17-16 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">alpha</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(H(a',b), H(a,b'))</span></p>

<p>This is a convenience method. The arguments are two morphisms <span class="Math">\alpha: a \rightarrow a', \beta: b \rightarrow b'</span> in <span class="Math">C</span>. The output is <code class="code">HomomorphismStructureOnMorphisms</code> called on <span class="Math">\alpha</span>, <span class="Math">\beta</span>.</p>

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

<h5>3.17-17 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">alpha</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(H(a',b), H(a,b))</span></p>

<p>This is a convenience method. The arguments are a morphism <span class="Math">\alpha: a \rightarrow a'</span> and an object <span class="Math">b</span> in <span class="Math">C</span>. The output is <code class="code">HomomorphismStructureOnMorphisms</code> called on <span class="Math">\alpha</span>, <span class="Math">\mathrm{id}_b</span>.</p>

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

<h5>3.17-18 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">a</var>, <var class="Arg">beta</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}_{D}(H(a,b), H(a,b'))</span></p>

<p>This is a convenience method. The arguments are an object <span class="Math">a</span> and a morphism <span class="Math">\beta: b \rightarrow b'</span> in <span class="Math">C</span>. The output is <code class="code">HomomorphismStructureOnMorphisms</code> called on <span class="Math">\mathrm{id}_a</span>, <span class="Math">\beta</span>.</p>

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

<h5>3.17-19 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: an object</p>

<p>This is a convenience method. The arguments are two objects <span class="Math">a</span> and <span class="Math">b</span> in <span class="Math">C</span>. The output is <code class="code">HomomorphismStructureOnObjects</code> called on <span class="Math">a,b</span>.</p>

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

<h5>3.17-20 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">arg</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This is a convenience method for <code class="code">InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructure</code>.</p>

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

<h5>3.17-21 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">arg1</var>, <var class="Arg">arg2</var>, <var class="Arg">arg3</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This is a convenience method for <code class="code">InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphism</code>.</p>

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

<h5>3.17-22 HomStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomStructure</code>( <var class="Arg">arg</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This is a convenience method for <code class="code">DistinguishedObjectOfHomomorphismStructure</code>.</p>

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

<h5>3.17-23 ExtendRangeOfHomomorphismStructureByFullEmbedding</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ExtendRangeOfHomomorphismStructureByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">object_function</var>, <var class="Arg">morphism_function</var>, <var class="Arg">object_function_inverse</var>, <var class="Arg">morphism_function_inverse</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">‣ HomomorphismStructureOnObjectsExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">a</var>, <var class="Arg">b</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">‣ HomomorphismStructureOnMorphismsExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</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">‣ HomomorphismStructureOnMorphismsWithGivenObjectsExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">s</var>, <var class="Arg">alpha</var>, <var class="Arg">beta</var>, <var class="Arg">r</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">‣ DistinguishedObjectOfHomomorphismStructureExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</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">‣ InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">alpha</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">‣ InterpretMorphismAsMorphismFromDistinguishedObjectToHomomorphismStructureWithGivenObjectsExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">distinguished_object</var>, <var class="Arg">alpha</var>, <var class="Arg">r</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">‣ InterpretMorphismFromDistinguishedObjectToHomomorphismStructureAsMorphismExtendedByFullEmbedding</code>( <var class="Arg">C</var>, <var class="Arg">E</var>, <var class="Arg">a</var>, <var class="Arg">a'</var>, <var class="Arg">iota</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: nothing</p>

<p>If <span class="Math">\iota\colon D \to E</span> is a full embedding of categories, every <span class="Math">D</span>-homomorphism structure for a category <span class="Math">C</span> extends to a <span class="Math">E</span>-homomorphism structure for <span class="Math">C</span>. This operations accepts four functions and installs operations <code class="code">DistinguishedObjectOfHomomorphismStructureExtendedByFullEmbedding</code>, <code class="code">HomomorphismStructureOnObjectsExtendedByFullEmbedding</code> etc. which correspond to the <span class="Math">E</span>-homomorphism structure for <span class="Math">C</span>. Note: To distinguish embeddings in different categories, in addition to <span class="Math">C</span> also <span class="Math">E</span> is passed to the operations. When using this with different embeddings with the range category <span class="Math">E</span>, only the last embedding will be used. The arguments are:</p>


<ul>
<li><p><code class="code">object_function</code> gets the categories <span class="Math">C</span> and <span class="Math">E</span> and an object in <span class="Math">D</span>.</p>

</li>
<li><p><code class="code">morphism_function</code> gets the categories <span class="Math">C</span> and <span class="Math">E</span>, an object in <span class="Math">E</span>, a morphism in <span class="Math">D</span> and another object in <span class="Math">E</span>. The objects are the results of <code class="code">object_function</code> applied to the source and range of the morphism.</p>

</li>
<li><p><code class="code">object_function_inverse</code> gets the categories <span class="Math">C</span> and <span class="Math">E</span> and an object in <span class="Math">E</span>.</p>

</li>
<li><p><code class="code">morphism_function_inverse</code> gets the categories <span class="Math">C</span> and <span class="Math">E</span>, an object in <span class="Math">D</span>, a morphism in <span class="Math">E</span> and another object in <span class="Math">D</span>. The objects are the results of <code class="code">object_function_inverse</code> applied to the source and range of the morphism.</p>

</li>
</ul>
<p><code class="code">object_function</code> and <code class="code">morphism_function</code> define the embedding. <code class="code">object_function_inverse</code> and <code class="code">morphism_function_inverse</code> define the inverse of the embedding on its image.</p>

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

<h5>3.17-24 ExtendRangeOfHomomorphismStructureByIdentityAsFullEmbedding</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ExtendRangeOfHomomorphismStructureByIdentityAsFullEmbedding</code>( <var class="Arg">C</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: nothing</p>

<p>Chooses the identity on <span class="Math">D</span> as the full embedding in <code class="func">ExtendRangeOfHomomorphismStructureByFullEmbedding</code> (<a href="chap3.html#X873E91D180B3057C"><span class="RefLink">3.17-23</span></a>). This is useful to handle this case as a degenerate case of <code class="func">ExtendRangeOfHomomorphismStructureByFullEmbedding</code> (<a href="chap3.html#X873E91D180B3057C"><span class="RefLink">3.17-23</span></a>).</p>

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

<h5>3.17-25 MorphismsOfExternalHom</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MorphismsOfExternalHom</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of morphisms in <span class="Math">\mathrm{Hom}( a, b )</span></p>

<p>The argument are two objects <var class="Arg">a</var>, <var class="Arg">b</var>. The output is a list of all morphisms from <var class="Arg">a</var> to <var class="Arg">b</var>.</p>

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

<h5>3.17-26 BasisOfExternalHom</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BasisOfExternalHom</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a list of morphisms in <span class="Math">\mathrm{Hom}_{C}(a,b)</span></p>

<p>The arguments are objects <span class="Math">a,b</span> in a <span class="Math">k</span>-linear category <span class="Math">C</span>. The output is a list <span class="Math">L</span> of morphisms which is a basis of <span class="Math">\mathrm{Hom}_{C}(a,b)</span> in the sense that any given morphism <span class="Math">\alpha: a \to b</span> can uniquely be written as a linear combination of <span class="Math">L</span> with the coefficients in <code class="code">CoefficientsOfMorphism</code>(<span class="Math">\alpha</span>).</p>

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

<h5>3.17-27 CoefficientsOfMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CoefficientsOfMorphism</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of elements in <span class="Math">k</span></p>

<p>This is a convenience method. The argument is a morphism <span class="Math">\alpha: a \to b</span> in a <span class="Math">k</span>-linear category <span class="Math">C</span>. The output is a list of coefficients of <span class="Math">\alpha</span> with respect to the list <code class="code">BasisOfExternalHom</code>(<var class="Arg">a</var>,<var class="Arg">b</var>).</p>

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

<h4>3.18 <span class="Heading">Simplified Morphisms</span></h4>

<p>Let <span class="Math">\phi: A \rightarrow B</span> be a morphism. There are several different natural ways to look at <span class="Math">\phi</span> as an object in an ambient category:</p>


<ul>
<li><p><span class="Math">\mathrm{Hom}( A, B )</span>, the set of homomorphisms with the equivalence relation <span class="Math">\mathtt{IsCongruentForMorphisms}</span> regarded as a category,</p>

</li>
<li><p><span class="Math">\sum_{A}\mathrm{Hom}( A, B )</span>, the category of morphisms where the range is fixed,</p>

</li>
<li><p><span class="Math">\sum_{B}\mathrm{Hom}( A, B )</span>, the category of morphisms where the source is fixed,</p>

</li>
<li><p><span class="Math">\sum_{A,B}\mathrm{Hom}( A, B )</span>, the category of morphisms where neither source nor range is fixed,</p>

</li>
</ul>
<p>and furthermore, if <span class="Math">\phi</span> happens to be an endomorphism <span class="Math">A \rightarrow A</span>, we also have</p>


<ul>
<li><p><span class="Math">\sum_{A}\mathrm{Hom}(A,A)</span>, the category of endomorphisms.</p>

</li>
</ul>
<p>Let <span class="Math">\mathbf{C}</span> be one of the categories above in which <span class="Math">\phi</span> may reside as an object, and let <span class="Math">i</span> be a non-negative integer or <span class="Math">\infty</span>. CAP provides commands for passing from <span class="Math">\phi</span> to <span class="Math">\phi_i</span>, where <span class="Math">\phi_i</span> is isomorphic to <span class="Math">\phi</span> in <span class="Math">\mathbf{C}</span>, but "simpler". The idea is that the greater the <span class="Math">i</span>, the "simpler" the <span class="Math">\phi_i</span> (but this could mean the harder the computation), with <span class="Math">\infty</span> as a possible value. The case <span class="Math">i = 0</span> defaults to the identity operator for all simplifications. For the Add-operatations, only the cases <span class="Math">i \geq 1</span> have to be given as functions.</p>

<p><span class="Math">\ </span></p>

<p>If we regard <span class="Math">\phi</span> as an object in the category <span class="Math">\mathrm{Hom}( A, B )</span>, <span class="Math">\phi_i</span> is again in <span class="Math">\mathrm{Hom}( A, B )</span> such that <span class="Math">\phi \sim_{A,B} \phi_i</span>. This case is handled by the following commands:</p>

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

<h5>3.18-1 SimplifyMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyMorphism</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A,B)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified morphism <span class="Math">\phi_i</span>.</p>

<p><span class="Math">\ </span></p>

<p>If we regard <span class="Math">\phi</span> as an object in the category <span class="Math">\sum_{A}\mathrm{Hom}( A, B )</span>, then <span class="Math">\phi_i</span> is a morphism of type <span class="Math">A_i \rightarrow B</span> and there is an isomorphism <span class="Math">\sigma_i: A \rightarrow A_i</span> such that <span class="Math">\phi_i \circ \sigma_i \sim_{A,B} \phi</span>. This case is handled by the following commands:</p>

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

<h5>3.18-2 SimplifySource</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySource</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,B)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified morphism with simplified source <span class="Math">\phi_i: A_i \rightarrow B</span>.</p>

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

<h5>3.18-3 SimplifySource_IsoToInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySource_IsoToInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,A)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">(\sigma_i)^{-1}: A_i \rightarrow A</span>.</p>

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

<h5>3.18-4 SimplifySource_IsoFromInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySource_IsoFromInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A,A_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">\sigma_i: A \rightarrow A_i</span>.</p>

<p><span class="Math">\ </span></p>

<p>If we regard <span class="Math">\phi</span> as an object in the category <span class="Math">\sum_{B}\mathrm{Hom}( A, B )</span>, then <span class="Math">\phi_i</span> is a morphism of type <span class="Math">A \rightarrow B_i</span> and there is an isomorphism <span class="Math">\rho_i: B \rightarrow B_i</span> such that <span class="Math"> \rho_i^{-1} \circ \phi_i\sim_{A,B} \phi</span>. This case is handled by the following commands:</p>

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

<h5>3.18-5 SimplifyRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyRange</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A,B_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified morphism with simplified range <span class="Math">\phi_i: A \rightarrow B_i</span>.</p>

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

<h5>3.18-6 SimplifyRange_IsoToInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyRange_IsoToInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B_i,B)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">(\rho_i)^{-1}: B_i \rightarrow B</span>.</p>

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

<h5>3.18-7 SimplifyRange_IsoFromInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyRange_IsoFromInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B,B_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">\rho_i: B \rightarrow B_i</span>.</p>

<p><span class="Math">\ </span></p>

<p>If we regard <span class="Math">\phi</span> as an object in the category <span class="Math">\sum_{A, B}\mathrm{Hom}( A, B )</span>, then <span class="Math">\phi_i</span> is a morphism of type <span class="Math">A_i \rightarrow B_i</span> and there is are isomorphisms <span class="Math">\sigma_i: A \rightarrow A_i</span> and <span class="Math">\rho_i: B \rightarrow B_i</span> such that <span class="Math"> \rho_i^{-1} \circ \phi_i \circ \sigma_i \sim_{A,B} \phi</span>. This case is handled by the following commands:</p>

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

<h5>3.18-8 SimplifySourceAndRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySourceAndRange</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,B_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified morphism with simplified source and range <span class="Math">\phi_i: A_i \rightarrow B_i</span>.</p>

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

<h5>3.18-9 SimplifySourceAndRange_IsoToInputRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySourceAndRange_IsoToInputRange</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B_i,B)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">(\rho_i)^{-1}: B_i \rightarrow B</span>.</p>

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

<h5>3.18-10 SimplifySourceAndRange_IsoFromInputRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySourceAndRange_IsoFromInputRange</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B,B_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">\rho_i: B \rightarrow B_i</span>.</p>

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

<h5>3.18-11 SimplifySourceAndRange_IsoToInputSource</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySourceAndRange_IsoToInputSource</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,A)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">(\sigma_i)^{-1}: A_i \rightarrow A</span>.</p>

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

<h5>3.18-12 SimplifySourceAndRange_IsoFromInputSource</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifySourceAndRange_IsoFromInputSource</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A,A_i)</span></p>

<p>The arguments are a morphism <span class="Math">\phi: A \rightarrow B</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">\sigma_i: A \rightarrow A_i</span>.</p>

<p><span class="Math">\ </span></p>

<p>If <span class="Math">\phi:A \rightarrow A</span> is an endomorphism, we may regard it as an object in the category <span class="Math">\sum_{A}\mathrm{Hom}( A, A )</span>. In this case <span class="Math">\phi_i</span> is a morphism of type <span class="Math">A_i \rightarrow A_i</span> and there is an isomorphism <span class="Math">\sigma_i: A \rightarrow A_i</span> such that <span class="Math"> \sigma_i^{-1} \circ \phi_i \circ \sigma_i \sim_{A,A} \phi</span>. This case is handled by the following commands:</p>

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

<h5>3.18-13 SimplifyEndo</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyEndo</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,A_i)</span></p>

<p>The arguments are an endomorphism <span class="Math">\phi: A \rightarrow A</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is a simplified endomorphism <span class="Math">\phi_i: A_i \rightarrow A_i</span>.</p>

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

<h5>3.18-14 SimplifyEndo_IsoToInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyEndo_IsoToInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_i,A)</span></p>

<p>The arguments are an endomorphism <span class="Math">\phi: A \rightarrow A</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">(\sigma_i)^{-1}: A_i \rightarrow A</span>.</p>

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

<h5>3.18-15 SimplifyEndo_IsoFromInputObject</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimplifyEndo_IsoFromInputObject</code>( <var class="Arg">phi</var>, <var class="Arg">i</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A,A_i)</span></p>

<p>The arguments are an endomorphism <span class="Math">\phi: A \rightarrow A</span> and a non-negative integer <span class="Math">i</span> or <code class="code">infinity</code>. The output is the isomorphism <span class="Math">\sigma_i: A \rightarrow A_i</span>.</p>

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

<h5>3.18-16 Simplify</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Simplify</code>( <var class="Arg">phi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A_{\infty},B_{\infty})</span></p>

<p>This is a convenient method. The argument is a morphism <span class="Math">\phi: A \rightarrow B</span>. The output is a "simplified" version of <span class="Math">\phi</span> that may change the source and range of <span class="Math">\phi</span> (up to isomorphism). To be precise, the output is an <span class="Math">\infty</span>-th simplified morphism of <span class="Math">(\iota_A^{\infty})^{-1}\circ \phi \circ \iota_A^{\infty}</span>.</p>

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

<h4>3.19 <span class="Heading">Reduction by split epi summands</span></h4>

<p>Let <span class="Math">\alpha: A \rightarrow B</span> be a morphism in an additive category. Suppose we are given direct sum decompositions of <span class="Math">A \simeq A' \oplus A''</span> and <span class="Math">B \simeq B' \oplus B''</span> such that If <span class="Math">\alpha''</span> is a split epimorphism, then we call <span class="Math">\alpha': A' \rightarrow B'</span> <em>some reduction of <span class="Math">\alpha</span> by split epi summands</em>. The inclusions/projections of the decompositions into direct sums induce commutative diagrams and</p>

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

<h5>3.19-1 SomeReductionBySplitEpiSummand</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SomeReductionBySplitEpiSummand</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(A',B')</span></p>

<p>The argument is a morphism <span class="Math">\alpha: A \rightarrow B</span>. The output is some reduction of <span class="Math">\alpha</span> by split epi summands <span class="Math">\alpha': A' \rightarrow B'</span>.</p>

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

<h5>3.19-2 SomeReductionBySplitEpiSummand_MorphismToInputRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SomeReductionBySplitEpiSummand_MorphismToInputRange</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B',B)</span></p>

<p>The argument is a morphism <span class="Math">\alpha: A \rightarrow B</span>. The output is the morphism <span class="Math">\beta': B' \rightarrow B</span> linking <span class="Math">\alpha</span> with some reduction by split epi summands.</p>

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

<h5>3.19-3 SomeReductionBySplitEpiSummand_MorphismFromInputRange</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SomeReductionBySplitEpiSummand_MorphismFromInputRange</code>( <var class="Arg">alpha</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a morphism in <span class="Math">\mathrm{Hom}(B,B')</span></p>

<p>The argument is a morphism <span class="Math">\alpha: A \rightarrow B</span>. The output is the morphism <span class="Math">\beta: B \rightarrow B'</span> linking <span class="Math">\alpha</span> with some reduction by split epi summands.</p>


<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a>   <a href="chap0.html#contents">[Contents]</a>    <a href="chap2.html">[Previous Chapter]</a>    <a href="chap4.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="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</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>

Messung V0.5 in Prozent
C=100 H=100 G=100

¤ Dauer der Verarbeitung: 0.45 Sekunden  (vorverarbeitet am  2026-04-27) ¤

*© 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 und die Messung sind noch experimentell.





                                                                                                                                                                                                                                                                                                                                                                                                     

Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder
Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge