Gedichte Musik Bilder Quellcodebibliothek Diashow Normaldarstellung
Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/dbaccess/qa/unoapi/   (Office von Apache Version 25.8.3.2©)  Datei vom 5.10.2025 mit Größe 952 B image not shown  

SSL chap8.html   Sprache: unbekannt

 
rahmenlose Ansicht.html DruckansichtUnknown {[0] [0] [0]}zum Wurzelverzeichnis wechseln

<?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 (XMod) - Chapter 8: Crossed squares and Cat^2-groups</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="chap8"  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="chapBib.html">Bib</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="chap7.html">[Previous Chapter]</a>    <a href="chap9.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap8_mj.html">[MathJax on]</a></p>
<p><a id="X780368C083C76EDC" name="X780368C083C76EDC"></a></p>
<div class="ChapSects"><a href="chap8.html#X780368C083C76EDC">8 <span class="Heading">Crossed squares and Cat<span class="SimpleMath">^2</span>-groups</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X7C4AFE8D85848C8F">8.1 <span class="Heading">Definition of a crossed square 
and a crossed <span class="SimpleMath">n</span>-cube of groups</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X820A7D30847BC828">8.2 <span class="Heading">Constructions for crossed squares</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X866A7FAC7FCB62C2">8.2-1 CrossedSquareByXMods</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7FA98BD47FF9B044">8.2-2 Size3d</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7896DAF786F46234">8.2-3 CrossedSquareByNormalSubgroups</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7FA367977B1895A7">8.2-4 CrossedSquareByNormalSubXMod</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X833362FE87ED3C48">8.2-5 ActorCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X82E4EA93824F7B26">8.2-6 CrossedSquareByAutomorphismGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X839E065783795CB8">8.2-7 CrossedSquareByPullback</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7F5554907AF73190">8.2-8 CrossedSquareByXModSplitting</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X87FBE3CE87DC8CD5">8.2-9 CrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7F94830681EA19BE">8.2-10 Transpose3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7C2647CB82DDD065">8.2-11 CentralQuotient</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X8645AA3686F126D5">8.2-12 IsCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X828CFC5A83097189">8.2-13 Up2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7F81DA90820F4405">8.2-14 IsSymmetric3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7AE671C7798F99FD">8.2-15 Crossed Pairing</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X79A59CED7C69BF18">8.3 <span class="Heading">Substructures of Crossed Squares</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X83F16E94857407F3">8.3-1 SubCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7D0D7F787D438D9A">8.3-2 TrivialSub3DimensionalGroup</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X78A79A7E85128C7B">8.4 <span class="Heading">Morphisms of crossed squares</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X83E733547A14FD61">8.4-1 CrossedSquareMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7DE8173F80E07AB1">8.4-2 Source</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X8284240C7B9BB783">8.4-3 IsCrossedSquareMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X8614E38E7A67690E">8.4-4 InclusionMorphismHigherDimensionalDomains</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X86D5AA247B64ED51">8.5 <span class="Heading">Definitions and constructions for cat<span class="SimpleMath">^2</span>-groups and their morphisms 
</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X849D845586F92444">8.5-1 Cat2Group</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X81BD4011837BCC2E">8.5-2 Up2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X861BA02C7902A4F4">8.5-3 DirectProduct</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X85713B1C7C34324E">8.5-4 DisplayLeadMaps</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X864B346686AAA522">8.5-5 Transpose3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X83616C237F4745FB">8.5-6 Cat2GroupMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7D46CB517FCAA83B">8.5-7 Cat2GroupOfCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X82F896C7851294B7">8.5-8 Subdiagonal2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7DB082D282C52855">8.5-9 SubCat2Group</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X838423B47FEE09B2">8.5-10 TrivialSubCat2Group</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X80FB2B328578DE42">8.6 <span class="Heading">Enumerating cat<span class="SimpleMath">^2</span>-groups with a given source</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7D421DE57B44F37A">8.6-1 AllCat2GroupsWithImagesIterator</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X783F7FEB7B79B062">8.6-2 AllCat2GroupsWithFixedUp</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X84636E047CDF2DF3">8.6-3 AllCat2GroupsMatrix</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7EFCF9697E845B2C">8.6-4 AllCat2GroupsIterator</a></span>
</div></div>
</div>

<h3>8 <span class="Heading">Crossed squares and Cat<span class="SimpleMath">^2</span>-groups</span></h3>

<p>The term <em>3d-group</em> refers to a set of equivalent categories of which the most common are the categories of <em>crossed squares</em> and <em>cat<span class="SimpleMath">^2</span>-groups</em>. A <em>3d-mapping</em> is a function between two 3d-groups which preserves all the structure.</p>

<p>The material in this chapter should be considered experimental. A major overhaul took place in time for <strong class="pkg">XMod</strong> version 2.73, with the names of a number of operations being changed.</p>

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

<h4>8.1 <span class="Heading">Definition of a crossed square 
and a crossed <span class="SimpleMath">n</span>-cube of groups</span></h4>

<p>Crossed squares were introduced by Guin-Waléry and Loday (see, for example, <a href="chapBib.html#biBbrow:lod">[BL87]</a>) as fundamental crossed squares of commutative squares of spaces, but are also of purely algebraic interest. We denote by <span class="SimpleMath">[n]</span> the set <span class="SimpleMath">{1,2,...,n}</span>. We use the <span class="SimpleMath">n=2</span> version of the definition of crossed <span class="SimpleMath">n</span>-cube as given by Ellis and Steiner <a href="chapBib.html#biBell:st">[ES87]</a>.</p>

<p>A <em>crossed square</em> <span class="SimpleMath">calS</span> consists of the following:</p>


<ul>
<li><p>groups <span class="SimpleMath">S_J</span> for each of the four subsets <span class="SimpleMath">J ⊆ [2]</span> (we often find it convenient to write <span class="SimpleMath">L = S_[2],~ M = S_{1},~ N = S_{2}</span> and <span class="SimpleMath">P = S_∅</span>);</p>

</li>
<li><p>a commutative diagram of group homomorphisms:</p>

<p class="pcenter">
  \ddot{\partial}_1 : S_{[2]} \to S_{\{2\}}, \quad 
  \ddot{\partial}_2 : S_{[2]} \to S_{\{1\}}, \quad 
  \dot{\partial}_2 : S_{\{2\}} \to S_{\emptyset}, \quad 
  \dot{\partial}_1 : S_{\{1\}} \to S_{\emptyset} 
  </p>

<p>(again we often write <span class="SimpleMath">κ = ddot∂_1,~ λ = ddot∂_2,~ μ = dot∂_2</span> and <span class="SimpleMath">ν = dot∂_1</span>);</p>

</li>
<li><p>actions of <span class="SimpleMath">S_∅</span> on <span class="SimpleMath">S_{1}, S_{2}</span> and <span class="SimpleMath">S_[2]</span> which determine actions of <span class="SimpleMath">S_{1}</span> on <span class="SimpleMath">S_{2}</span> and <span class="SimpleMath">S_[2]</span> via <span class="SimpleMath">dot∂_1</span> and actions of <span class="SimpleMath">S_{2}</span> on <span class="SimpleMath">S_{1}</span> and <span class="SimpleMath">S_[2]</span> via <span class="SimpleMath">dot∂_2</span>;</p>

</li>
<li><p>a function <span class="SimpleMath">⊠ : S_{1} × S_{2} -> S_[2]</span>.</p>

</li>
</ul>
<p>Here is a picture of the situation:</p>

<p class="pcenter">

\vcenter{\xymatrix{
       &   &  S_{[2]} \ar[rr]^{\ddot{\partial}_1} \ar[dd]_{\ddot{\partial}_2} 
              && S_{\{2\}} \ar[dd]^{\dot{\partial}_2} && 
              L \ar[rr]^{\kappa} \ar[dd]_{\lambda} 
              && M \ar[dd]^{\mu} &   \\
\mathcal{S}  & = &  &&  & = &&  \\
       &   &  S_{\{1\}} \ar[rr]_{\dot{\partial}_1}  
              && S_{\emptyset} &&  
              N \ar[rr]_{\nu}  
              && P 
}}
</p>

<p>The following axioms must be satisfied for all <span class="SimpleMath">l ∈ L, m,m_1,m_2 ∈ M, n,n_1,n_2 ∈ N, p ∈ P</span>.</p>


<ul>
<li><p>The homomorphisms <span class="SimpleMath">κ, λ</span> preserve the action of <span class="SimpleMath">P</span>.</p>

</li>
<li><p>Each of the upper, left-hand, right-hand and lower sides of the square,</p>

<p class="pcenter">
 \ddot{\calS}_1 = (\kappa : L \to M), \quad 
 \ddot{\calS}_2 = (\lambda : L \to N), \quad 
  \dot{\calS}_2  = (\mu : M \to P), \quad
  \dot{\calS}_1  = (\nu : N \to P), 
</p>

<p>and the diagonal</p>

<p class="pcenter">
\calS_{12} = (\partial_{12} := 
                   \mu \circ \kappa = \nu \circ \lambda : L \to P)
</p>

<p>are crossed modules (with actions via <span class="SimpleMath">P</span>).</p>

<p>These will be called the <em>up, left, right, down</em> and <em>diagonal</em> crossed modules of <span class="SimpleMath">calS</span>.</p>

</li>
<li><p><span class="SimpleMath">⊠</span> is a <em>crossed pairing</em>:</p>


<ul>
<li><p><span class="SimpleMath">(n_1n_2 ⊠ m) = (n_1 ⊠ m)^n_2 (n_2 ⊠ m)</span>,</p>

</li>
<li><p><span class="SimpleMath">(n ⊠ m_1m_2) = (n ⊠ m_2) (n ⊠ m_1)^m_2</span>,</p>

</li>
<li><p><span class="SimpleMath">(n ⊠ m)^p = (n^p ⊠ m^p)</span>.</p>

</li>
</ul>
</li>
<li><p><span class="SimpleMath">κ(n ⊠ m) = (m^-1)^n m quad mboxand quad λ(n ⊠ m) = n^-1 n^m</span>.</p>

</li>
<li><p><span class="SimpleMath">(n ⊠ κ l) = (l^-1)^n l quad mboxand quad (λ l ⊠ m) = l^-1 l^m</span>.</p>

</li>
</ul>
<p>Note that the actions of <span class="SimpleMath">M</span> on <span class="SimpleMath">N</span> and <span class="SimpleMath">N</span> on <span class="SimpleMath">M</span> via <span class="SimpleMath">P</span> are compatible since</p>

<p class="pcenter">
{n_1}^{(m^n)} \;=\; {n_1}^{\mu(m^n)} 
              \;=\; {n_1}^{n^{-1}(\mu m)n}
\;=\; (({n_1}^{n^{-1}})^m)^n.
</p>

<p>A <em>precrossed square</em> is a similar structure which satisfies some subset of these axioms. (This theoretical notion needs to be clarified.) In this implementation <code class="code">IsPreCrossedSquare</code> only checks that the five pre-crossed modules fit together correctly and that <span class="SimpleMath">(κ,ν)</span> and <span class="SimpleMath">(λ,μ)</span> are both morphisms of pre-crossed modules.</p>

<p>Crossed squares are the <span class="SimpleMath">n=2</span> case of a crossed <span class="SimpleMath">n</span>-cube of groups, defined as follows. (This is an attempt to translate Definition 2.1 in Ronnie Brown's <em>Computing homotopy types using crossed n-cubes of groups</em> into right actions -- but this definition is not yet completely understood!)</p>

<p>A <em>crossed</em> <span class="SimpleMath">n</span><em>-cube of groups</em> consists of the following:</p>


<ul>
<li><p>groups <span class="SimpleMath">S_A</span> for every subset <span class="SimpleMath">A ⊆ [n]</span>;</p>

</li>
<li><p>a commutative diagram of group homomorphisms <span class="SimpleMath">∂_i : S_A -> S_A ∖ {i}, i ∈ [n]</span>; with composites <span class="SimpleMath">∂_B : S_A -> S_A ∖ B, B ⊆ [n]</span>;</p>

</li>
<li><p>actions of <span class="SimpleMath">S_∅</span> on each <span class="SimpleMath">S_A</span>; and hence actions of <span class="SimpleMath">S_B</span> on <span class="SimpleMath">S_A</span> via <span class="SimpleMath">∂_B</span> for each <span class="SimpleMath">B ⊆ [n]</span>;</p>

</li>
<li><p>functions <span class="SimpleMath">⊠_A,B : S_A × S_B -> S_A ∪ B, (A,B ⊆ [n])</span>.</p>

</li>
</ul>
<p>There is then a long list of axioms which must be satisfied.</p>

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

<h4>8.2 <span class="Heading">Constructions for crossed squares</span></h4>

<p>Analogously to the data structure used for crossed modules, crossed squares are implemented as <code class="code">3d-groups</code>. There are also experimental implementations of cat<span class="SimpleMath">^2</span>-groups, with conversion between the two types of structure. Some standard constructions of crossed squares are listed below. At present, a limited number of constructions is implemented. Morphisms of crossed squares have also been implemented, though there is still a great deal to be done.</p>

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

<h5>8.2-1 CrossedSquareByXMods</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByXMods</code>( <var class="Arg">up</var>, <var class="Arg">left</var>, <var class="Arg">right</var>, <var class="Arg">down</var>, <var class="Arg">diag</var>, <var class="Arg">pairing</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">‣ PreCrossedSquareByPreXMods</code>( <var class="Arg">up</var>, <var class="Arg">left</var>, <var class="Arg">right</var>, <var class="Arg">down</var>, <var class="Arg">diag</var>, <var class="Arg">pairing</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If <em>up,left,right,down,diag</em> are five (pre-)crossed modules whose sources and ranges agree, as above, then we just have to add a crossed pairing to complete the data for a (pre-)crossed square.</p>

<p>The <code class="code">Display</code> function is used to print details of 3d-groups.</p>

<p>We take as our example a simple, but significant case. We start with five crossed modules formed from subgroups of <span class="SimpleMath">D_8</span> with generators <span class="SimpleMath">[(1,2,3,4),(3,4)</span>. The result is a pre-crossed square which is <em>not</em> a crossed square.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">b := (2,4);; c := (1,2)(3,4);; p := (1,2,3,4);; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">d8 := Group( b, c );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( d8, "d8" );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">L := Subgroup( d8, [p^2] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">M := Subgroup( d8, [b] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup( d8, [c] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P := TrivialSubgroup( d8 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">kappa := GroupHomomorphismByImages( L, M, [p^2], [b] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">lambda := GroupHomomorphismByImages( L, N, [p^2], [c] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">delta := GroupHomomorphismByImages( L, P, [p^2], [()] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mu := GroupHomomorphismByImages( M, P, [b], [()] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nu := GroupHomomorphismByImages( N, P, [c], [()] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">up := XModByTrivialAction( kappa );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">left := XModByTrivialAction( lambda );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">diag := XModByTrivialAction( delta );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">right := XModByTrivialAction( mu );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">down := XModByTrivialAction( nu );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xp := CrossedPairingByCommutators( N, M, L );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( "xp([c,b]) = ", xp( c, b ), "\n" ); </span>
xp([c,b]) = (1,3)(2,4)
<span class="GAPprompt">gap></span> <span class="GAPinput">PXS := PreCrossedSquareByPreXMods( up, left, right, down, diag, xp );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( PXS ); </span>
(pre-)crossed square with (pre-)crossed modules:
      up = [Group( [ (1,3)(2,4) ] ) -> Group( [ (2,4) ] )]
    left = [Group( [ (1,3)(2,4) ] ) -> Group( [ (1,2)(3,4) ] )]
   right = [Group( [ (2,4) ] ) -> Group( () )]
    down = [Group( [ (1,2)(3,4) ] ) -> Group( () )]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsCrossedSquare( PXS ); </span>
false

</pre></div>

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

<h5>8.2-2 Size3d</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Size3d</code>( <var class="Arg">XS</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Just as <code class="code">Size2d</code> was used in place of <code class="code">Size</code> for crossed modules, so <code class="code">Size3d</code> is used for crossed squares: <code class="code">Size3d( XS )</code> returns a four-element list containing the sizes of the four groups at the corners of the square.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">Size3d( PXS ); </span>
[ 2, 2, 2, 1 ]

</pre></div>

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

<h5>8.2-3 CrossedSquareByNormalSubgroups</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByNormalSubgroups</code>( <var class="Arg">L</var>, <var class="Arg">M</var>, <var class="Arg">N</var>, <var class="Arg">P</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">‣ CrossedPairingByCommutators</code>( <var class="Arg">N</var>, <var class="Arg">M</var>, <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If <span class="SimpleMath">L, M, N</span> are normal subgroups of a group <span class="SimpleMath">P</span>, and <span class="SimpleMath">[M,N] leqslant L leqslant M ∩ N</span>, then the four inclusions <span class="SimpleMath">L -> M,~ L -> N,~ M -> P,~ N -> P</span>, together with the actions of <span class="SimpleMath">P</span> on <span class="SimpleMath">M, N</span> and <span class="SimpleMath">L</span> given by conjugation, form a crossed square with crossed pairing</p>

<p class="pcenter">
\boxtimes \;:\; N \times M \to L, \quad 
(n,m) \mapsto [n,m] \,=\, n^{-1}m^{-1}nm \,=\,(m^{-1})^nm \,=\, n^{-1}n^m\,. 
</p>

<p>This construction is implemented as <code class="code">CrossedSquareByNormalSubgroups(L,M,N,P)</code> (note that the parent group comes last).</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">d20 := DihedralGroup( IsPermGroup, 20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gend20 := GeneratorsOfGroup( d20 ); </span>
[ (1,2,3,4,5,6,7,8,9,10), (2,10)(3,9)(4,8)(5,7) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">p1 := gend20[1];;  p2 := gend20[2];;  p12 := p1*p2; </span>
(1,10)(2,9)(3,8)(4,7)(5,6)
<span class="GAPprompt">gap></span> <span class="GAPinput">d10a := Subgroup( d20, [ p1^2, p2 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">d10b := Subgroup( d20, [ p1^2, p12 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c5d := Subgroup( d20, [ p1^2 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( d20, "d20" );  SetName( d10a, "d10a" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( d10b, "d10b" );  SetName( c5d, "c5d" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">XSconj := CrossedSquareByNormalSubgroups( c5d, d10a, d10b, d20 );</span>
[  c5d -> d10a ]
[   |      |   ]
[ d10b -> d20  ]
<span class="GAPprompt">gap></span> <span class="GAPinput">xpc := CrossedPairing( XSconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xpc( p12, p2 );</span>
(1,3,5,7,9)(2,4,6,8,10)

</pre></div>

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

<h5>8.2-4 CrossedSquareByNormalSubXMod</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByNormalSubXMod</code>( <var class="Arg">X0</var>, <var class="Arg">X1</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">‣ CrossedPairingBySingleXModAction</code>( <var class="Arg">X0</var>, <var class="Arg">X1</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If <span class="SimpleMath">calX_1 = (∂_1 : S_1 -> R_1)</span> is a normal sub-crossed module of <span class="SimpleMath">calX_0 = (∂_0 : S_0 -> R_0)</span> then the inclusion morphism gives a crossed square with crossed pairing</p>

<p class="pcenter">
\boxtimes \;:\; R_1 \times S_0 \to S_1, \quad 
(r_1,s_0) \mapsto (s_0^{-1})^{r_1} s_0. 
</p>

<p>The example constructs the same crossed square as in the previous subsection.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">X20 := XModByNormalSubgroup( d20, d10a );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">X10 := XModByNormalSubgroup( d10b, c5d );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ok := IsNormalSub2DimensionalDomain( X20, X10 ); </span>
true 
<span class="GAPprompt">gap></span> <span class="GAPinput">XS20 := CrossedSquareByNormalSubXMod( X20, X10 ); </span>
[  c5d -> d10a ]
[   |      |   ]
[ d10b -> d20  ]
<span class="GAPprompt">gap></span> <span class="GAPinput">xp20 := CrossedPairing( XS20 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xp20( p1^2, p2 );</span>
(1,7,3,9,5)(2,8,4,10,6)

</pre></div>

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

<h5>8.2-5 ActorCrossedSquare</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ActorCrossedSquare</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">‣ CrossedPairingByDerivations</code>( <var class="Arg">X0</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The actor <span class="SimpleMath">calA(calX_0)</span> of a crossed module <span class="SimpleMath">calX_0</span> has been described in Chapter 5 (see <code class="func">ActorXMod</code> (<a href="chap6.html#X790EBC7C7D320C03"><span class="RefLink">6.1-2</span></a>)). The crossed pairing is given by</p>

<p class="pcenter">
\boxtimes \;:\;  R \times W \,\to\, S, \quad (r,\chi) \,\mapsto\, \chi r~.
</p>

<p>This is implemented as <code class="code">ActorCrossedSquare(X0)</code>.</p>

<p>The example constructs <code class="code">XSact</code>, the actor crossed square of the crossed module <code class="code">X20</code>. This crossed square is converted to a cat<span class="SimpleMath">^2</span>-group <code class="code">C2act</code> in section <a href="chap8.html#X7D46CB517FCAA83B"><span class="RefLink">8.5-7</span></a>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">XSact := ActorCrossedSquare( X20 );</span>
crossed square with crossed modules:
      up = Whitehead[d10a->d20]
    left = [d10a->d20]
   right = Actor[d10a->d20]
    down = Norrie[d10a->d20]
<span class="GAPprompt">gap></span> <span class="GAPinput">W := Range( Up2DimensionalGroup( XSact ) );</span>
Group([ (2,5)(3,4), (2,3,5,4), (1,4,2,5,3) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( W );</span>
"C5 : C4"
<span class="GAPprompt">gap></span> <span class="GAPinput">xpa := CrossedPairing( XSact );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xpa( p1, (2,3,5,4) );</span>
(1,7,3,9,5)(2,8,4,10,6)

</pre></div>

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

<h5>8.2-6 CrossedSquareByAutomorphismGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByAutomorphismGroup</code>( <var class="Arg">G</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">‣ CrossedPairingByConjugators</code>( <var class="Arg">G</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For <span class="SimpleMath">G</span> a group let <span class="SimpleMath">Inn(G)</span> be its inner automorphism group and <span class="SimpleMath">Aut(G)</span> its full automorphism group. Then there is a crossed square with groups <span class="SimpleMath">[G,Inn(G),Inn(G),Aut(G)]</span> where the upper and left boundaries are the maps <span class="SimpleMath">g ↦ ι_g</span>, where <span class="SimpleMath">ι_g</span> is conjugation of <span class="SimpleMath">G</span> by <span class="SimpleMath">g</span>, and the right and down boundaries are inclusions. The crossed pairing is gived by <span class="SimpleMath">ι_g ⊠ ι_h = [g,h]</span>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">AXS20 := CrossedSquareByAutomorphismGroup( d20 );</span>
[      d20 -> Inn(d20) ]
[     |          |     ]
[ Inn(d20) -> Aut(d20) ]

<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( AXS20 );</span>
[ "D20", "D10", "D10", "C2 x (C5 : C4)" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">I20 := Range( Up2DimensionalGroup( AXS20 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">genI20 := GeneratorsOfGroup( I20 );           </span>
[ ^(1,2,3,4,5,6,7,8,9,10), ^(2,10)(3,9)(4,8)(5,7) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">xpi := CrossedPairing( AXS20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xpi( genI20[1], genI20[2] );</span>
(1,9,7,5,3)(2,10,8,6,4)

</pre></div>

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

<h5>8.2-7 CrossedSquareByPullback</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByPullback</code>( <var class="Arg">X1</var>, <var class="Arg">X2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If crossed modules <span class="SimpleMath">calX_1 = (ν : N -> P)</span> and <span class="SimpleMath">calX_2 = (μ : M -> P)</span> have a common range <span class="SimpleMath">P</span>, let <span class="SimpleMath">L</span> be the pullback of <span class="SimpleMath">{ν,μ}</span>. Then <span class="SimpleMath">N</span> acts on <span class="SimpleMath">L</span> by <span class="SimpleMath">(n,m)^n' = (n^n',m^ν n')</span>, and <span class="SimpleMath">M</span> acts on <span class="SimpleMath">L</span> by <span class="SimpleMath">(n,m)^m' = (n^μ m', m^m')</span>. So <span class="SimpleMath">(π_1 : L -> N)</span> and <span class="SimpleMath">(π_2 : L -> M)</span> are crossed modules, where <span class="SimpleMath">π_1,π_2</span> are the two projections. The crossed pairing is given by:</p>

<p class="pcenter">
\boxtimes \;:\; N \times M \to L, \quad 
(n,m) \mapsto (n^{-1}n^{\mu m}, (m^{-1})^{\nu n}m) . 
</p>

<p>The second example below uses the central extension crossed module <code class="code">X12=(D12->S3)</code> which was constructed in subsection (<code class="func">XModByCentralExtension</code> (<a href="chap2.html#X7D0F6FAA7AF69844"><span class="RefLink">2.1-5</span></a>)), with pullback group <code class="code">D12xC2</code>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">dn := Down2DimensionalGroup( XSconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rt := Right2DimensionalGroup( XSconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">XSP := CrossedSquareByPullback( dn, rt ); </span>
[ (d10b x_d20 d10a) -> d10a ]
[         |             |   ]
[              d10b -> d20  ]
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( XSP );                  </span>
[ "C5", "D10", "D10", "D20" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">XS12 := CrossedSquareByPullback( X12, X12 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( XS12 );                  </span>
[ "C2 x C2 x S3", "D12", "D12", "S3" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">xp12 := CrossedPairing( XS12 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xp12( (1,2,3,4,5,6), (2,6)(3,5) );</span>
(1,5,3)(2,6,4)(7,11,9)(8,12,10)

</pre></div>

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

<h5>8.2-8 CrossedSquareByXModSplitting</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareByXModSplitting</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">‣ CrossedPairingByPreImages</code>( <var class="Arg">X1</var>, <var class="Arg">X2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For <span class="SimpleMath">calX = (∂ : S -> R)</span> let <span class="SimpleMath">Q</span> be the image of <span class="SimpleMath">∂</span>. Then <span class="SimpleMath">∂ = ∂' ∘ ι</span> where <span class="SimpleMath">∂' : S -> Q</span> and <span class="SimpleMath">ι</span> is the inclusion of <span class="SimpleMath">Q</span> in <span class="SimpleMath">R</span>. The diagonal of the square is then the initial <span class="SimpleMath">calX</span>, and the crossed pairing is given by commutators of preimages.</p>

<p>A particular case is when <span class="SimpleMath">S</span> is an <span class="SimpleMath">R</span>-module <span class="SimpleMath">A</span> and <span class="SimpleMath">∂</span> is the zero map.</p>

<p class="pcenter">

\vcenter{\xymatrix{
       &   &  S \ar[rr]^{\partial'} \ar[dd]_{\partial'} \ar[rrdd]^{\partial}
              && Q \ar[dd]^{\iota} && 
              A \ar[rr]^0 \ar[dd]_0 \ar[rrdd]^0
              && 1 \ar[dd]^{\iota} &   \\
       &   &  &&  &   &&  \\
       &   &  Q \ar[rr]_{\iota}  
              && R &&  
              1 \ar[rr]_{\iota}  
              && R 
}}
</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">k4 := Group( (1,2), (3,4) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AX4 := XModByAutomorphismGroup( k4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">X4 := Image( IsomorphismPermObject( AX4 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">XSS4 := CrossedSquareByXModSplitting( X4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( XSS4 );</span>
[ "C2 x C2", "1", "1", "S3" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">XSS20 := CrossedSquareByXModSplitting( X20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">up20 := Up2DimensionalGroup( XSS20 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Range( up20 ) = d10a; </span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Range( up20 ), "d10a" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Name( XSS20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">XSS20;</span>
[d10a->d10a,d10a->d20]
<span class="GAPprompt">gap></span> <span class="GAPinput">xps := CrossedPairing( XSS20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xps( p1^2, p2 );</span>
(1,7,3,9,5)(2,8,4,10,6)

</pre></div>

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

<h5>8.2-9 CrossedSquare</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquare</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>The function <code class="code">CrossedSquare</code> may be used to call some of the constructions described in the previous subsections.</p>


<ul>
<li><p><code class="code">CrossedSquare(X0)</code> calls <code class="code">CrossedSquareByXModSplitting</code>.</p>

</li>
<li><p><code class="code">CrossedSquare(C0)</code> calls <code class="code">CrossedSquareOfCat2Group</code>.</p>

</li>
<li><p><code class="code">CrossedSquare(X0,X1)</code> calls <code class="code">CrossedSquareByPullback</code> when there is a common range.</p>

</li>
<li><p><code class="code">CrossedSquare(X0,X1)</code> calls <code class="code">CrossedSquareByNormalXMod</code> when <code class="code">X1</code> is normal in <code class="code">X0</code> .</p>

</li>
<li><p><code class="code">CrossedSquare(L,M,N,P)</code> calls <code class="code">CrossedSquareByNormalSubgroups</code>.</p>

</li>
</ul>

<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">diag := Diagonal2DimensionalGroup( AXS20 );</span>
[d20->Aut(d20)]
<span class="GAPprompt">gap></span> <span class="GAPinput">XSdiag := CrossedSquare( diag );;      </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( XSdiag );  </span>
[ "D20", "D10", "D10", "C2 x (C5 : C4)" ]

</pre></div>

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

<h5>8.2-10 Transpose3DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Transpose3DimensionalGroup</code>( <var class="Arg">S0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The <em>transpose</em> of a crossed square <span class="SimpleMath">calS</span> is the crossed square <span class="SimpleMath">tildecalS</span> obtained by interchanging <span class="SimpleMath">M</span> with <span class="SimpleMath">N</span>, <span class="SimpleMath">κ</span> with <span class="SimpleMath">λ</span>, and <span class="SimpleMath">ν</span> with <span class="SimpleMath">μ</span>. The crossed pairing is given by</p>

<p class="pcenter">
\tilde{\boxtimes} \;:\; M \times N \to L, \quad 
(m,n) \;\mapsto\; m\,\tilde{\boxtimes}\,n := (n \boxtimes m)^{-1}~.
</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">XStrans := Transpose3DimensionalGroup( XSconj ); </span>
[  c5d -> d10b ]
[   |      |   ]
[ d10a -> d20  ]


</pre></div>

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

<h5>8.2-11 CentralQuotient</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CentralQuotient</code>( <var class="Arg">X0</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The central quotient of a crossed module <span class="SimpleMath">calX = (∂ : S -> R)</span> is the crossed square where:</p>


<ul>
<li><p>the left crossed module is <span class="SimpleMath">calX</span>;</p>

</li>
<li><p>the right crossed module is the quotient <span class="SimpleMath">calX/Z(calX)</span> (see <code class="func">CentreXMod</code> (<a href="chap4.html#X7B57446086BA1BF0"><span class="RefLink">4.1-7</span></a>));</p>

</li>
<li><p>the up and down homomorphisms are the natural homomorphisms onto the quotient groups;</p>

</li>
<li><p>the crossed pairing <span class="SimpleMath">⊠ : (R × F) -> S</span>, where <span class="SimpleMath">F = Fix(calX,S,R)</span>, is the displacement element <span class="SimpleMath">⊠(r,Fs) = ⟨ r,s ⟩ = (s^-1)^rsquad</span> (see <code class="func">Displacement</code> (<a href="chap4.html#X7E20208279038BB8"><span class="RefLink">4.1-3</span></a>) and section <a href="chap4.html#X81338C977972AD83"><span class="RefLink">4.3</span></a>).</p>

</li>
</ul>
<p>This is the special case of an intended function <code class="code">CrossedSquareByCentralExtension</code> which has not yet been implemented. In the example <code class="code">Xn7</code> <span class="SimpleMath">⊴</span> <code class="code">X24</code>, constructed in section <a href="chap4.html#X7E373BF3836B3A9C"><span class="RefLink">4.1</span></a>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">pos7 := Position( ids, [ [12,2], [24,5] ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Xn7 := nsx[pos7];; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup( Xn7 );</span>
[ [ 12, 2 ], [ 24, 5 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup( CentreXMod( Xn7 ) );  </span>
[ [ 4, 1 ], [ 4, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">CQXn7 := CentralQuotient( Xn7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( CQXn7 );</span>
[ "C12", "C3", "C4 x S3", "S3" ]

</pre></div>

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

<h5>8.2-12 IsCrossedSquare</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCrossedSquare</code>( <var class="Arg">obj</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">‣ IsPreCrossedSquare</code>( <var class="Arg">obj</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">‣ Is3dObject</code>( <var class="Arg">obj</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">‣ IsPerm3dObject</code>( <var class="Arg">obj</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">‣ IsPc3dObject</code>( <var class="Arg">obj</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">‣ IsFp3dObject</code>( <var class="Arg">obj</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>These are the basic properties for 3d-groups, and crossed squares in particular.</p>

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

<h5>8.2-13 Up2DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Up2DimensionalGroup</code>( <var class="Arg">XS</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">‣ Left2DimensionalGroup</code>( <var class="Arg">XS</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">‣ Down2DimensionalGroup</code>( <var class="Arg">XS</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">‣ Right2DimensionalGroup</code>( <var class="Arg">XS</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">‣ CrossDiagonalActions</code>( <var class="Arg">XS</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">‣ Diagonal2DimensionalGroup</code>( <var class="Arg">XS</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">‣ Name</code>( <var class="Arg">S0</var> )</td><td class="tdright">( method )</td></tr></table></div>
<p>These are the basic attributes of a crossed square <span class="SimpleMath">calS</span>. The six objects used in the construction of <span class="SimpleMath">calS</span> are the four crossed modules (2d-groups) on the sides of the square (up; left; right and down); the diagonal action of <span class="SimpleMath">P</span> on <span class="SimpleMath">L</span>; and the crossed pairing <span class="SimpleMath">{M,N} -> L</span> (see the next subsection). The diagonal crossed module <span class="SimpleMath">(L -> P)</span> is an additional attribute.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">Up2DimensionalGroup( XSconj );</span>
[c5d->d10a]
<span class="GAPprompt">gap></span> <span class="GAPinput">Right2DimensionalGroup( XSact );</span>
Actor[d10a->d20]
<span class="GAPprompt">gap></span> <span class="GAPinput">Name( XSconj ); </span>
"[c5d->d10a,d10b->d20]"
<span class="GAPprompt">gap></span> <span class="GAPinput">cross1 := CrossDiagonalActions( XSconj )[1];; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gensa := GeneratorsOfGroup( d10a );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gensb := GeneratorsOfGroup( d10a );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">act1 := ImageElm( cross1, gensb[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gensa[2]; ImageElm( act1, gensa[2] );</span>
(2,10)(3,9)(4,8)(5,7)
(1,5)(2,4)(6,10)(7,9)

</pre></div>

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

<h5>8.2-14 IsSymmetric3DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSymmetric3DimensionalGroup</code>( <var class="Arg">obj</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">‣ IsAbelian3DimensionalGroup</code>( <var class="Arg">obj</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">‣ IsTrivialAction3DimensionalGroup</code>( <var class="Arg">obj</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">‣ IsNormalSub3DimensionalGroup</code>( <var class="Arg">obj</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">‣ IsCentralExtension3DimensionalGroup</code>( <var class="Arg">obj</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">‣ IsAutomorphismGroup3DimensionalGroup</code>( <var class="Arg">obj</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>These are further properties for 3d-groups, and crossed squares in particular. A 3d-group is <em>symmetric</em> if its <code class="code">Up2DimensionalGroup</code> is equal to its <code class="code">Left2DimensionalGroup</code>.</p>

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

<h5>8.2-15 Crossed Pairing</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Crossed Pairing</code>( <var class="Arg">XS</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Crossed pairings have been implemented as functions of two variables, <span class="SimpleMath">{M,N} -> L</span>. (Up until version 2.92 a more complicated two-variable mapping was used.)</p>

<p>The first example shows the crossed pairing in the crossed square <code class="code">XSconj</code>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">xp := CrossedPairing( XSconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xp( (1,6)(2,5)(3,4)(7,10)(8,9), (1,5)(2,4)(6,9)(7,8) );</span>
(1,7,8,5,3)(2,9,10,6,4)

</pre></div>

<p>The second example shows how to construct a crossed pairing.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup(1);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x := GeneratorsOfGroup(F)[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">z := GroupHomomorphismByImages( F, F, [x], [x^0] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">id := GroupHomomorphismByImages( F, F, [x], [x] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">h := function(n,m)</span>
<span class="GAPprompt">></span> <span class="GAPinput">            return x^(ExponentSumWord(n,x)*ExponentSumWord(m,x));</span>
<span class="GAPprompt">></span> <span class="GAPinput">        end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">h( x^3, x^4 );</span>
f1^12
<span class="GAPprompt">gap></span> <span class="GAPinput">A := AutomorphismGroup( F );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a := GeneratorsOfGroup(A)[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">act := GroupHomomorphismByImages( F, A, [x], [a^2] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">X0 := XModByBoundaryAndAction( z, act );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">X1 := XModByBoundaryAndAction( id, act );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">XSF := PreCrossedSquareByPreXMods( X0, X0, X1, X1, X0, h );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsCrossedSquare( XSF ); </span>
true

</pre></div>

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

<h4>8.3 <span class="Heading">Substructures of Crossed Squares</span></h4>

<p>To specify a sub-crossed square of <span class="SimpleMath">calS</span> we may specify four subgroups of the four groups in <span class="SimpleMath">calS</span>. If these define five sub-crossed modules, and these comc bine together satisfactorily, then a crossed square is produced.</p>

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

<h5>8.3-1 SubCrossedSquare</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubCrossedSquare</code>( <var class="Arg">XS</var>, <var class="Arg">ul</var>, <var class="Arg">ur</var>, <var class="Arg">dl</var>, <var class="Arg">dr</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">‣ IsSubCrossedSquare</code>( <var class="Arg">XS</var>, <var class="Arg">subXS</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">‣ SubPreCrossedSquare</code>( <var class="Arg">XS</var>, <var class="Arg">ul</var>, <var class="Arg">ur</var>, <var class="Arg">dl</var>, <var class="Arg">dr</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">‣ IsSubPreCrossedSquare</code>( <var class="Arg">XS</var>, <var class="Arg">subXS</var> )</td><td class="tdright">( operation )</td></tr></table></div>

<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">Display( XS20 ); </span>
[  c5d -> d10a ]
[   |      |   ]
[ d10b -> d20  ]
<span class="GAPprompt">gap></span> <span class="GAPinput">p5 := p1^5*p2;;  [p2,p12,p5];</span>
[ (2,10)(3,9)(4,8)(5,7), (1,10)(2,9)(3,8)(4,7)(5,6), 
  (1,6)(2,5)(3,4)(7,10)(8,9) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">L1 := TrivialSubgroup( c5d );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">M1 := Subgroup( d10a, [ p2 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N1 := Subgroup( d10b, [ p5 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P1 := Subgroup( d20, [ p2, p5 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sub20 := SubCrossedSquare( XS20, L1, M1, N1, P1 );</span>
crossed square with crossed modules:
      up = [Group( () ) -> Group( [ ( 2,10)( 3, 9)( 4, 8)( 5, 7) ] )]
    left = [Group( () ) -> Group( [ ( 1, 6)( 2, 5)( 3, 4)( 7,10)( 8, 9) ] )]
   right = [Group( [ ( 2,10)( 3, 9)( 4, 8)( 5, 7) ] ) -> Group( 
[ ( 2,10)( 3, 9)( 4, 8)( 5, 7), ( 1, 6)( 2, 5)( 3, 4)( 7,10)( 8, 9) ] )]
    down = [Group( [ ( 1, 6)( 2, 5)( 3, 4)( 7,10)( 8, 9) ] ) -> Group( 
[ ( 2,10)( 3, 9)( 4, 8)( 5, 7), ( 1, 6)( 2, 5)( 3, 4)( 7,10)( 8, 9) ] )]

<span class="GAPprompt">gap></span> <span class="GAPinput">sxp := CrossedPairing( sub20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sxp( p5, p2 );</span>
()

</pre></div>

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

<h5>8.3-2 TrivialSub3DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TrivialSub3DimensionalGroup</code>( <var class="Arg">3dgp</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">‣ TrivialSubCrossedSquare</code>( <var class="Arg">XS</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">‣ TrivialSubPreCrossedSquare</code>( <var class="Arg">XS</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>A special case of the previous operation is when all the subgroups are trivial.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">TC2ab := TrivialSubCat2Group( C2ab );</span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [Group( () ) => Group( () )]
2 : [Group( () ) => Group( () )]

</pre></div>

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

<h4>8.4 <span class="Heading">Morphisms of crossed squares</span></h4>

<p>This section describes an initial implementation of morphisms of (pre-)crossed squares.</p>

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

<h5>8.4-1 CrossedSquareMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CrossedSquareMorphism</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">‣ CrossedSquareMorphismByXModMorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">mors</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">‣ CrossedSquareMorphismByGroupHomomorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">homs</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">‣ PreCrossedSquareMorphismByPreXModMorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">mors</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">‣ PreCrossedSquareMorphismByGroupHomomorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">homs</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><a id="X7DE8173F80E07AB1" name="X7DE8173F80E07AB1"></a></p>

<h5>8.4-2 Source</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Source</code>( <var class="Arg">map</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">map</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">‣ Up2DimensionalMorphism</code>( <var class="Arg">map</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">‣ Left2DimensionalMorphism</code>( <var class="Arg">map</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">‣ Down2DimensionalMorphism</code>( <var class="Arg">map</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">‣ Right2DimensionalMorphism</code>( <var class="Arg">map</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Morphisms of <code class="code">3dObjects</code> are implemented as <code class="code">3dMappings</code>. These have a pair of 3d-groups as source and range, together with four 2d-morphisms mapping between the four pairs of crossed modules on the four sides of the squares. These functions return <code class="code">fail</code> when invalid data is supplied.</p>

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

<h5>8.4-3 IsCrossedSquareMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCrossedSquareMorphism</code>( <var class="Arg">map</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">‣ IsPreCrossedSquareMorphism</code>( <var class="Arg">map</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">‣ IsBijective</code>( <var class="Arg">mor</var> )</td><td class="tdright">( method )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEndomorphism3dObject</code>( <var class="Arg">mor</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">‣ IsAutomorphism3dObject</code>( <var class="Arg">mor</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>A morphism <code class="code">mor</code> between two pre-crossed squares <span class="SimpleMath">calS_1</span> and <span class="SimpleMath">calS_2</span> consists of four crossed module morphisms <code class="code">Up2DimensionalMorphism(mor)</code>, mapping the <code class="code">Up2DimensionalGroup</code> of <span class="SimpleMath">calS_1</span> to that of <span class="SimpleMath">calS_2</span>, <code class="code">Left2DimensionalMorphism(mor)</code>, <code class="code">Right2DimensionalMorphism(mor)</code> and <code class="code">Down2DimensionalMorphism(mor)</code>. These four morphisms are required to commute with the four boundary maps and to preserve the rest of the structure. The current version of <code class="code">IsCrossedSquareMorphism</code> does not perform all the required checks.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">ad20 := GroupHomomorphismByImages( d20, d20, [p1,p2], [p1,p2^p1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ad10a := GroupHomomorphismByImages( d10a, d10a, [p1^2,p2], [p1^2,p2^p1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ad10b := GroupHomomorphismByImages( d10b, d10b, [p1^2,p12], [p1^2,p12^p1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">idc5d := IdentityMapping( c5d );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">up := Up2DimensionalGroup( XSconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">lt := Left2DimensionalGroup( XSconj );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rt := Right2DimensionalGroup( XSconj );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">dn := Down2DimensionalGroup( XSconj );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mup := XModMorphismByGroupHomomorphisms( up, up, idc5d, ad10a );</span>
[[c5d->d10a] => [c5d->d10a]]
<span class="GAPprompt">gap></span> <span class="GAPinput">mlt := XModMorphismByGroupHomomorphisms( lt, lt, idc5d, ad10b );</span>
[[c5d->d10b] => [c5d->d10b]]
<span class="GAPprompt">gap></span> <span class="GAPinput">mrt := XModMorphismByGroupHomomorphisms( rt, rt, ad10a, ad20 );</span>
[[d10a->d20] => [d10a->d20]]
<span class="GAPprompt">gap></span> <span class="GAPinput">mdn := XModMorphismByGroupHomomorphisms( dn, dn, ad10b, ad20 );</span>
[[d10b->d20] => [d10b->d20]]
<span class="GAPprompt">gap></span> <span class="GAPinput">autoconj := CrossedSquareMorphism( XSconj, XSconj, [mup,mlt,mrt,mdn] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord := Order( autoconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( autoconj );</span>
Morphism of crossed squares :- 
: Source = [c5d->d10a,d10b->d20]
: Range = [c5d->d10a,d10b->d20]
:     order = 5
:    up-left: [ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10) ], 
  [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10) ] ]
:   up-right: 
[ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 2,10)( 3, 9)( 4, 8)( 5, 7) ], 
  [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1, 3)( 4,10)( 5, 9)( 6, 8) ] ]
:  down-left: 
[ [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1,10)( 2, 9)( 3, 8)( 4, 7)( 5, 6) ], 
  [ ( 1, 3, 5, 7, 9)( 2, 4, 6, 8,10), ( 1, 2)( 3,10)( 4, 9)( 5, 8)( 6, 7) ] ]
: down-right: 
[ [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10), ( 2,10)( 3, 9)( 4, 8)( 5, 7) ], 
  [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10), ( 1, 3)( 4,10)( 5, 9)( 6, 8) ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsAutomorphismHigherDimensionalDomain( autoconj );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">kpo := KnownPropertiesOfObject( autoconj );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( kpo );</span>
[ "CanEasilyCompareElements", "CanEasilySortElements", 
  "IsAutomorphismHigherDimensionalDomain", "IsCrossedSquareMorphism", 
  "IsEndomorphismHigherDimensionalDomain", "IsInjective", 
  "IsPreCrossedSquareMorphism", "IsSingleValued", "IsSurjective", "IsTotal" ]

</pre></div>

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

<h5>8.4-4 InclusionMorphismHigherDimensionalDomains</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InclusionMorphismHigherDimensionalDomains</code>( <var class="Arg">obj</var>, <var class="Arg">sub</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><a id="X86D5AA247B64ED51" name="X86D5AA247B64ED51"></a></p>

<h4>8.5 <span class="Heading">Definitions and constructions for cat<span class="SimpleMath">^2</span>-groups and their morphisms 
</span></h4>

<p>We give here three equivalent definitions of cat<span class="SimpleMath">^2</span>-groups. When we come to define cat<span class="SimpleMath">^n</span>-groups we shall give a similar set of definitions.</p>

<p>Firstly, we take the definition of a cat<span class="SimpleMath">^2</span>-group from Section 5 of Brown and Loday <a href="chapBib.html#biBbrow:lod">[BL87]</a>, suitably modified. A cat<span class="SimpleMath">^2</span>-group <span class="SimpleMath">calC = (C_[2],C_{2},C_{1},C_∅)</span> comprises four groups (one for each of the subsets of <span class="SimpleMath">[2]</span>) and <span class="SimpleMath">15</span> homomorphisms, as shown in the following diagram:</p>

<p class="pcenter">

\vcenter{\xymatrix{
--> --------------------

--> maximum size reached

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

[ zur Elbe Produktseite wechseln0.199Quellennavigators  ]