<h3>2 <span class="Heading">2d-groups : crossed modules and cat<span class="SimpleMath">^1</span>-groups</span></h3>
<p>The term <em>2d-group</em> refers to a set of equivalent categories of which the most common are the categories of <em>crossed modules</em>; <em>cat<span class="SimpleMath">^1</span>-groups</em>; and <em>group-groupoids</em>, all of which involve a pair of groups.</p>
<h4>2.1 <span class="Heading">Constructions for crossed modules</span></h4>
<p>A crossed module (of groups) <span class="SimpleMath">calX = (∂ : S -> R )</span> consists of a group homomorphism <span class="SimpleMath">∂</span>, called the <em>boundary</em> of <span class="SimpleMath">calX</span>, with <em>source</em> <span class="SimpleMath">S</span> and <em>range</em> <span class="SimpleMath">R</span>. The group <span class="SimpleMath">R</span> acts on itself by conjugation, and on <span class="SimpleMath">S</span> by an <em>action</em> <span class="SimpleMath">α : R -> Aut(S)</span> such that, for all <span class="SimpleMath">s,s_1,s_2 ∈ S</span> and <span class="SimpleMath">r ∈ R</span>,</p>
<p>When only the first of these axioms is satisfied, the resulting structure is a <em>pre-crossed module</em> (see section <a href="chap2.html#X7D435B6279032D4D"><span class="RefLink">2.3</span></a>). The kernel of <span class="SimpleMath">∂</span> is abelian.</p>
<p>(Much of the literature on crossed modules uses left actions, but we have chosen to use right actions in this package since that is the standard choice for group actions in <strong class="pkg">GAP</strong>.)</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XMod</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByBoundaryAndAction</code>( <var class="Arg">bdy</var>, <var class="Arg">act</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The global function <code class="code">XMod</code> calls one of the standard constructions described in the following subsections. In the example the boundary is the identity mapping on <codeclass="code">c5</code> and the action is trivial.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByNormalSubgroup</code>( <var class="Arg">G</var>, <var class="Arg">N</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>A <em>conjugation crossed module</em> is the inclusion of a normal subgroup <span class="SimpleMath">S ⊴ R</span>, where <span class="SimpleMath">R</span> acts on <span class="SimpleMath">S</span> by conjugation.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByTrivialAction</code>( <var class="Arg">bdy</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>A <em>trivial action crossed module</em> <span class="SimpleMath">(∂ : S -> R)</span> has <span class="SimpleMath">s^r = s</span> for all <span class="SimpleMath">s ∈ S, r ∈ R</span>, the source is abelian and the image lies in the centre of the range.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByCentralExtension</code>( <var class="Arg">bdy</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>A <em>central extension crossed module</em> has as boundary a surjection <span class="SimpleMath">∂ : S -> R</span>, with central kernel, where <span class="SimpleMath">r ∈ R</span> acts on <span class="SimpleMath">S</span> by conjugation with <span class="SimpleMath">∂^-1r</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByPullback</code>( <var class="Arg">xmod</var>, <var class="Arg">hom</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Let <span class="SimpleMath">calX_0 = (μ : M -> P)</span> be a crossed module. If <span class="SimpleMath">ν : N -> P</span> is a group homomorphism with the same range as <span class="SimpleMath">calX_0</span>, form the pullback group <span class="SimpleMath">L = M ×_P N</span>, with projection <span class="SimpleMath">λ : L -> N</span> (as defined in the <strong class="pkg">Utils</strong> package). Then <span class="SimpleMath">N</span> acts on <span class="SimpleMath">L</span> by <span class="SimpleMath">(m,n)^n' := (m^ν n',n^n'), so that calX_1 = (λ : L -> N) is the pullback crossed module determined by calX_0 and ν. There is also a morphism of crossed modules (κ,ν) : calX_1 -> calX_2.
<p>The example forms a pullback of the crossed module <code class="code">X12</code> of the previous subsection.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ XModByAbelianModule</code>( <var class="Arg">abmod</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>A <em>crossed abelian module</em> has an abelian module as source and the zero map as boundary. See section <a href="chap14.html#X852BD9CA84C2AFF0"><span class="RefLink">14.2</span></a> for an example.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DirectProduct</code>( <var class="Arg">X1</var>, <var class="Arg">X2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The direct product <span class="SimpleMath">calX_1 × calX_2</span> of two crossed modules has source <span class="SimpleMath">S_1 × S_2</span>, range <span class="SimpleMath">R_1 × R_2</span> and boundary <span class="SimpleMath">∂_1 × ∂_2</span>, with <span class="SimpleMath">R_1, R_2</span> acting trivially on <span class="SimpleMath">S_2, S_1</span> respectively. The embeddings and projections are constructed automatically, and placed in the <code class="code">DirectProductInfo</code> attribute, together with the two <em>objects</em> <span class="SimpleMath">calX_1 × calX_2</span>.</p>
<p>The example constructs the product of the two crossed modules formed in subsection <code class="func">XModByTrivialAction</code> (<a href="chap2.html#X867B2D53832EF05E"><span class="RefLink">2.1-3</span></a>).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Source</code>( <var class="Arg">X0</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">‣ Range</code>( <var class="Arg">X0</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">‣ Boundary</code>( <var class="Arg">X0</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">‣ XModAction</code>( <var class="Arg">X0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The following attributes are used in the construction of a crossed module <code class="code">X0</code>.</p>
<ul>
<li><p><code class="code">Source(X0)</code> and <code class="code">Range(X0)</code> are the source <span class="SimpleMath">S</span> and range <span class="SimpleMath">R</span> of <span class="SimpleMath">∂</span>, the boundary <code class="code">Boundary(X0)</code>;</p>
</li>
<li><p><code class="code">XModAction(X0)</code> is a homomorphism from <span class="SimpleMath">R</span> to a group of automorphisms of <code class="code">X0</code>.</p>
</li>
</ul>
<p>(Up until version 2.63 there was an additional attribute <code class="code">AutoGroup</code>, the range of <code class="code">XModAction(X0)</code>.)</p>
<p>The example uses the crossed module <code class="code">X12</code> constructed in subsection <code class="func">XModByCentralExtension</code> (<a href="chap2.html#X7D0F6FAA7AF69844"><span class="RefLink">2.1-5</span></a>).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Size2d</code>( <var class="Arg">X0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The standard operation <code class="code">Size</code> cannot be used for crossed modules because the size of a collection is required to be a number, and we wish to return a list. <code class="code">Size2d( X0 )</code> returns the two-element list, <code class="code">[ Size( Source(X0) ), Size( Range(X0) ) ]</code>.</p>
<p>In the simple example below, <code class="code">X5</code> is the automorphism crossed module constructed in subsection <code class="func">XModByAutomorphismGroup</code> (<a href="chap2.html#X78B14FDA817CCEEF"><span class="RefLink">2.1-4</span></a>).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Name</code>( <var class="Arg">X0</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">‣ IdGroup</code>( <var class="Arg">X0</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">‣ ExternalSetXMod</code>( <var class="Arg">X0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>More familiar attributes are <code class="code">Name</code> and <code class="code">IdGroup</code>. The name is formed by concatenating the names of the source and range (if these exist). <code class="code">IdGroup( X0 )</code> returns a two-element list <code class="code">[ IdGroup( Source(X0) ), IdGroup( Range(X0) ) ]</code>.</p>
<p>The <code class="func">ExternalSetXMod</code> for a crossed module is the source group considered as a G-set of the range group using the crossed module action.</p>
<p>The <code class="code">Display</code> function is used to print details of 2d-groups.</p>
<p>The <code class="code">Print</code> statements at the end of the example list the <strong class="pkg">GAP</strong> representations and attributes of <code class="code">X5</code>.</p>
<h4>2.2 <span class="Heading">Properties of crossed modules</span></h4>
<p>The underlying category structures for the objects constructed in this chapter follow the sequence <code class="code">Is2DimensionalDomain</code>; <code class="code">Is2DimensionalMagma</code>; <code class="code">Is2DimensionalMagmaWithOne</code>; <code class="code">Is2DimensionalMagmaWithInverses</code>, mirroring the situation for (one-dimensional) groups. From these we construct <code class="code">Is2DimensionalSemigroup</code>, <code class="code">Is2DimensionalMonoid</code> and <code class="code">Is2DimensionalGroup</code>.</p>
<p>There are then a variety of properties associated with crossed modules, starting with <code class="code">IsPreXMod</code> and <code class="code">IsXMod</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsXMod</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPreXMod</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Is2DimensionalGroup</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPerm2DimensionalGroup</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPc2DimensionalGroup</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFp2DimensionalGroup</code>( <var class="Arg">X0</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>A structure which has <code class="code">Is2DimensionalGroup</code> is a precrossed module or a pre-cat<span class="SimpleMath">^1</span>-group (see section <a href="chap2.html#X7AAABC1D7E110988"><span class="RefLink">2.4</span></a>). Such an object whose source and range are both permutation groups has <code class="code">IsPerm2DimensionalGroup</code>. The properties <code class="code">IsPc2DimensionalGroup</code>, <code class="code">IsFp2DimensionalGroup</code> are defined similarly. In the example below we see that <code class="code">X5</code> has <code class="code">IsPreXMod</code>, <code class="code">IsXMod</code> and <code class="code">IsPerm2DimensionalGroup</code>.</p>
<p>There are also properties corresponding to the various construction methods which are listed in section <a href="chap2.html#X7BAD9A7F7AFEEC89"><span class="RefLink">2.1</span></a>: <code class="code">IsTrivialAction2DimensionalGroup</code>; <code class="code">IsNormalSubgroup2DimensionalGroup</code>; <code class="code">IsCentralExtension2DimensionalGroup</code>; <code class="code">IsAutomorphismGroup2DimensionalGroup</code> and <code class="code">IsAbelianModule2DimensionalGroup</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubXMod</code>( <var class="Arg">X0</var>, <var class="Arg">src</var>, <var class="Arg">rng</var> )</td><tdclass="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TrivialSubXMod</code>( <var class="Arg">X0</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">‣ NormalSubXMods</code>( <var class="Arg">X0</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">‣ IsNormal</code>( <var class="Arg">X0</var>, <var class="Arg">S0</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>With the standard crossed module constructors listed above as building blocks, sub-crossed modules, normal sub-crossed modules <span class="SimpleMath">calN ⊲ calX</span>, and also quotients <span class="SimpleMath">calX/calN</span> may be constructed. A sub-crossed module <span class="SimpleMath">calS = (δ : N -> M)</span> is <em>normal</em> in <span class="SimpleMath">calX = (∂ : S -> R)</span> if</p>
<ul>
<li><p><span class="SimpleMath">N,M</span> are normal subgroups of <span class="SimpleMath">S,R</span> respectively,</p>
</li>
<li><p><span class="SimpleMath">δ</span> is the restriction of <span class="SimpleMath">∂</span>,</p>
</li>
<li><p><span class="SimpleMath">n^r ∈ N</span> for all <span class="SimpleMath">n ∈ N,~r ∈ R</span>,</p>
</li>
<li><p><span class="SimpleMath">(s^-1)^ms ∈ N</span> for all <span class="SimpleMath">m ∈ M,~s ∈ S</span>.</p>
</li>
</ul>
<p>These conditions ensure that <span class="SimpleMath">M ⋉ N</span> is normal in the semidirect product <span class="SimpleMath">R ⋉ S</span>. (Note that <span class="SimpleMath">⟨ s,m ⟩ = (s^-1)^ms</span> is a displacement: see <code class="func">Displacement</code> (<a href="chap4.html#X7E20208279038BB8"><span class="RefLink">4.1-3</span></a>).)</p>
<p>A method for <code class="code">IsNormal</code> for precrossed modules is provided. See section <a href="chap4.html#X7E373BF3836B3A9C"><span class="RefLink">4.1</span></a> for factor crossed modules and their natural morphisms.</p>
<p>The five normal subcrossed modules of <code class="code">X4</code> found in the following example are <code class="code">[id,id], [k4,k4], [k4,a4], [a4,a4]</code> and <code class="code">X4</code> itself.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ KernelCokernelXMod</code>( <var class="Arg">X0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Let <span class="SimpleMath">calX = (∂ : S -> R)</span>. If <span class="SimpleMath">K leqslant S</span> is the kernel of <span class="SimpleMath">∂</span>, and <span class="SimpleMath">J leqslant R</span> is the image of <span class="SimpleMath">∂</span>, form <span class="SimpleMath">C = R/J</span>. Then <span class="SimpleMath">(ν∂|_K : K -> C)</span> is a crossed module where <span class="SimpleMath">ν : R -> C, r ↦ Jr</span> is the natural map, and the action of <span class="SimpleMath">C</span> on <span class="SimpleMath">K</span> is given by <span class="SimpleMath">k^Jr = k^r</span>.</p>
<p>A special case of this operation is when the range is a trivial group (not necessarily a subgroup of the source), and so the action is trivial. This case will be used when constructing a special type of double groupoid in Chapter <a href="chap11.html#X83B7E8A287C9284A"><span class="RefLink">11</span></a>.</p>
<p>Then <span class="SimpleMath">calP = (0 : P -> {1_R})</span> is a normal sub-pre-crossed module of <span class="SimpleMath">calX</span> and <span class="SimpleMath">calX/calP = (∂ : S/P -> R)</span> is a crossed module.</p>
<p>In the following example the Peiffer subgroup is cyclic of size <span class="SimpleMath">4</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">P := PeifferSubgroup( P16 );</span>
Group( [ (11,15)(12,16)(13,17)(14,18), (11,17,15,13)(12,18,16,14) ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">X16 := XModByPeifferQuotient( P16 );</span>
Peiffer([d16->sk4])
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( X16 );</span>
Crossed module Peiffer([d16->sk4]) :-
: Source group has generators:
[ f1, f2 ]
: Range group has generators:
[ (11,15)(12,16)(13,17)(14,18), (12,18)(13,17)(14,16) ]
: Boundary homomorphism maps source generators to:
[ (12,18)(13,17)(14,16), (11,15)(12,16)(13,17)(14,18) ]
The automorphism group is trivial
<span class="GAPprompt">gap></span> <span class="GAPinput">iso16 := IsomorphismPermGroup( Source( X16 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">S16 := Image( iso16 );</span>
Group([ (1,2), (3,4) ])
<h4>2.4 <span class="Heading">Cat<span class="SimpleMath">^1</span>-groups and pre-cat<span class="SimpleMath">^1</span>-groups</span></h4>
<p>In <a href="chapBib.html#biBL1">[Lod82]</a>, Loday reformulated the notion of a crossed module as a cat<span class="SimpleMath">^1</span>-group, namely a group <span class="SimpleMath">G</span> with a pair of endomorphisms <span class="SimpleMath">t,h : G -> G</span> having a common image <span class="SimpleMath">R</span> and satisfying certain axioms. We find it computationally convenient to define a cat<span class="SimpleMath">^1</span>-group <span class="SimpleMath">calC = (e;t,h : G -> R )</span> as having source group <span class="SimpleMath">G</span>, range group <span class="SimpleMath">R</span>, and three homomorphisms: two surjections <span class="SimpleMath">t,h : G -> R</span> and an embedding <span class="SimpleMath">e : R -> G</span> satisfying:</p>
<p class="pcenter">
{\bf Cat\ 1} : ~t \circ e ~=~ h \circ e = {\rm id}_R,
\qquad
{\bf Cat\ 2} : ~[\ker t, \ker h] ~=~ \{ 1_G \}.
</p>
<p>It follows that <span class="SimpleMath">t ∘ e ∘ h = h,~ h ∘ e ∘ t = t,~ t ∘ e ∘ t = t~</span> and <span class="SimpleMath">~h ∘ e ∘ h = h</span>.</p>
<p>See section <code class="func">IsPreCat1GroupWithIdentityEmbedding</code> (<a href="chap2.html#X7B7CF88F83B0129D"><span class="RefLink">2.5-2</span></a>) for the case when <span class="SimpleMath">t</span> and <span class="SimpleMath">h</span> are endomorphisms and <span class="SimpleMath">e</span> an inclusion.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Cat1Group</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreCat1Group</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PreCat1GroupByTailHeadEmbedding</code>( <var class="Arg">t</var>, <var class="Arg">h</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">‣ PreCat1GroupWithIdentityEmbedding</code>( <var class="Arg">t</var>, <var class="Arg">h</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The global functions <code class="code">Cat1Group</code> and <code class="code">PreCat1Group</code> can be called in various ways.</p>
<ul>
<li><p>as <code class="code">Cat1Group(t,h,e);</code> when <span class="SimpleMath">t,h,e</span> are three homomorphisms, which is equivalent to <code class="code">PreCat1GroupByTailHeadEmbedding(t,h,e);</code></p>
</li>
<li><p>as <code class="code">Cat1Group(t,h);</code> when <span class="SimpleMath">t,h</span> are two endomorphisms, which is equivalent to <code class="code">PreCat1GroupWithIdentityEmbedding(t,h);</code></p>
</li>
<li><p>as <code class="code">Cat1Group(t);</code> when <span class="SimpleMath">t=h</span> is an endomorphism, which is equivalent to <code class="code">PreCat1GroupWithIdentityEmbedding(t,t);</code></p>
</li>
<li><p>as <code class="code">Cat1Group(t,e);</code> when <span class="SimpleMath">t=h</span> and <span class="SimpleMath">e</span> are homomorphisms, which is equivalent to <code class="code">PreCat1GroupByTailHeadEmbedding(t,t,e);</code></p>
</li>
<li><p>as <code class="code">Cat1Group(i,j,k);</code> when <span class="SimpleMath">i,j,k</span> are integers, which is equivalent to <code class="code">Cat1Select(i,j,k);</code> as described in section <a href="chap2.html#X7A6A70BD86DE458D"><span class="RefLink">2.7</span></a>.</p>
<p>The maps <span class="SimpleMath">t,h</span> are often referred to as the <em>source</em> and <em>target</em>, but we choose to call them the <em>tail</em> and <em>head</em> of <span class="SimpleMath">calC</span>, because <em>source</em> is the <strong class="pkg">GAP</strong> term for the domain of a function. The <code class="code">RangeEmbedding</code> is the embedding of <code class="code">R</code> in <code class="code">G</code>, the <code class="code">KernelEmbedding</code> is the inclusion of the kernel of <code class="code">t</code> in <code class="code">G</code>, and the <code class="code">Boundary</code> is the restriction of <code class="code">h</code> to the kernel of <code class="code">t</code>. It is frequently the case that <span class="SimpleMath">t=h</span>, but not in the example <code class="code">C18</code> above.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DiagonalCat1Group</code>( <var class="Arg">genG</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation constructs examples of cat<span class="SimpleMath">^1</span>-groups of the form <span class="SimpleMath">G × G ⇒ G</span>. The tail map is the identity on the first factor and kills of the second, while the head map does the reverse. The range embedding maps <span class="SimpleMath">G</span> to the diagonal in <span class="SimpleMath">G × G</span>. The corresponding crossed module is isomorphic to the identity crossed module on <span class="SimpleMath">G</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">C4 := DiagonalCat1Group( [ (1,2,3), (2,3,4) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Source(C4), "a4a4" ); SetName( Range(C4_, "a4d" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( C4 );</span>
Cat1-group [a4a4=>a4d] :-
: Source group a4a4 has generators:
[ (1,2,3), (2,3,4), (5,6,7), (6,7,8) ]
: Range group a4d has generators:
[ ( 9,10,11), (10,11,12) ]
: tail homomorphism maps source generators to:
[ ( 9,10,11), (10,11,12), (), () ]
: head homomorphism maps source generators to:
[ (), (), ( 9,10,11), (10,11,12) ]
: range embedding maps range generators to:
[ (1,2,3)(5,6,7), (2,3,4)(6,7,8) ]
: kernel has generators:
[ (5,6,7), (6,7,8) ]
: boundary homomorphism maps generators of kernel to:
[ ( 9,10,11), (10,11,12) ]
: kernel embedding maps generators of kernel to:
[ (5,6,7), (6,7,8) ]
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TransposeCat1Group</code>( <var class="Arg">C0</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">‣ TransposeIsomorphism</code>( <var class="Arg">C0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The <em>transpose</em> of a cat<span class="SimpleMath">^1</span>-group <span class="SimpleMath">C</span> has the same source, range and embedding, but has the tail and head maps interchanged. The <code class="code">TransposeIsomorphism</code> gives the isomorphism between the two.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Cat1GroupByPeifferQuotient</code>( <var class="Arg">P</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If <span class="SimpleMath">C = (e;t,h : G -> R)</span> is a pre-cat<span class="SimpleMath">^1</span>-group, its Peiffer subgroup is <span class="SimpleMath">P = [ker t,ker h]</span> and the associated cat<span class="SimpleMath">^1</span>-group <span class="SimpleMath">C_2</span> has source <span class="SimpleMath">G/P</span>. In the example, <span class="SimpleMath">t=h : s4 -> c2</span> with <span class="SimpleMath">ker t = ker h = a4</span> and <span class="SimpleMath">P = [a4,a4]=k4</span>, so that <span class="SimpleMath">G/P = s4/k4 ≅ s3</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubCat1Group</code>( <var class="Arg">C1</var>, <var class="Arg">S1</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">‣ SubPreCat1Group</code>( <var class="Arg">C1</var>, <var class="Arg">S1</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><span class="SimpleMath">S_1</span> is a sub-cat<span class="SimpleMath">^1</span>-group of <span class="SimpleMath">C_1</span> provided the source and range of <span class="SimpleMath">S_1</span> are subgroups of the source and range of <span class="SimpleMath">C_1</span> and that the tail, head and embedding of <span class="SimpleMath">S_1</span> are the appropriate restrictions of those of <span class="SimpleMath">C_1</span>.</p>
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.42Bemerkung:
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
