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

Quelle  chap8_mj.html

  Sprache: HTML
 

 products/Sources/formale Sprachen/GAP/pkg/xmod/doc/chap8_mj.html


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

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

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<script type="text/javascript"
  src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (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_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chap8_mj.html">8</a>  <a href="chap9_mj.html">9</a>  <a href="chap10_mj.html">10</a>  <a href="chap11_mj.html">11</a>  <a href="chap12_mj.html">12</a>  <a href="chap13_mj.html">13</a>  <a href="chap14_mj.html">14</a>  <a href="chap15_mj.html">15</a>  <a href="chapBib_mj.html">Bib</a>  <a href="chapInd_mj.html">Ind</a>  </div>

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

<p id="mathjaxlink" class="pcenter"><a href="chap8.html">[MathJax off]</a></p>
<p><a id="X780368C083C76EDC" name="X780368C083C76EDC"></a></p>
<div class="ChapSects"><a href="chap8_mj.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_mj.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_mj.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_mj.html#X866A7FAC7FCB62C2">8.2-1 CrossedSquareByXMods</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7FA98BD47FF9B044">8.2-2 Size3d</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7896DAF786F46234">8.2-3 CrossedSquareByNormalSubgroups</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7FA367977B1895A7">8.2-4 CrossedSquareByNormalSubXMod</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X833362FE87ED3C48">8.2-5 ActorCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X82E4EA93824F7B26">8.2-6 CrossedSquareByAutomorphismGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X839E065783795CB8">8.2-7 CrossedSquareByPullback</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7F5554907AF73190">8.2-8 CrossedSquareByXModSplitting</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X87FBE3CE87DC8CD5">8.2-9 CrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7F94830681EA19BE">8.2-10 Transpose3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7C2647CB82DDD065">8.2-11 CentralQuotient</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X8645AA3686F126D5">8.2-12 IsCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X828CFC5A83097189">8.2-13 Up2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7F81DA90820F4405">8.2-14 IsSymmetric3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7AE671C7798F99FD">8.2-15 Crossed Pairing</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.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_mj.html#X83F16E94857407F3">8.3-1 SubCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7D0D7F787D438D9A">8.3-2 TrivialSub3DimensionalGroup</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.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_mj.html#X83E733547A14FD61">8.4-1 CrossedSquareMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7DE8173F80E07AB1">8.4-2 Source</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X8284240C7B9BB783">8.4-3 IsCrossedSquareMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X8614E38E7A67690E">8.4-4 InclusionMorphismHigherDimensionalDomains</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.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_mj.html#X849D845586F92444">8.5-1 Cat2Group</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X81BD4011837BCC2E">8.5-2 Up2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X861BA02C7902A4F4">8.5-3 DirectProduct</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X85713B1C7C34324E">8.5-4 DisplayLeadMaps</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X864B346686AAA522">8.5-5 Transpose3DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X83616C237F4745FB">8.5-6 Cat2GroupMorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7D46CB517FCAA83B">8.5-7 Cat2GroupOfCrossedSquare</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X82F896C7851294B7">8.5-8 Subdiagonal2DimensionalGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X7DB082D282C52855">8.5-9 SubCat2Group</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X838423B47FEE09B2">8.5-10 TrivialSubCat2Group</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.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_mj.html#X7D421DE57B44F37A">8.6-1 AllCat2GroupsWithImagesIterator</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X783F7FEB7B79B062">8.6-2 AllCat2GroupsWithFixedUp</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.html#X84636E047CDF2DF3">8.6-3 AllCat2GroupsMatrix</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8_mj.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 itime 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_mj.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,\ldots,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_mj.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 \subseteq [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_{\emptyset}\)</span>);</p>

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

<p class="center">\[
  \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">\(\kappa = \ddot{\partial}_1,~ \lambda = \ddot{\partial}_2,~ \mu = \dot{\partial}_2\)</span> and <span class="SimpleMath">\(\nu = \dot{\partial}_1\)</span>);</p>

</li>
<li><p>actions of <span class="SimpleMath">\(S_{\emptyset}\)</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{\partial}_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{\partial}_2\;\)</span>;</p>

</li>
<li><p>a function <span class="SimpleMath">\(\boxtimes : S_{\{1\}} \times S_{\{2\}} \to S_{[2]}\)</span>.</p>

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

<p class="center">\[

\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 \in L,\; m,m_1,m_2 \in M,\; n,n_1,n_2 \in N,\; p \in P\)</span>.</p>


<ul>
<li><p>The homomorphisms <span class="SimpleMath">\(\kappa, \lambda\)</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="center">\[
 \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="center">\[
\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">\(\boxtimes\)</span> is a <em>crossed pairing</em>:</p>


<ul>
<li><p><span class="SimpleMath">\((n_1n_2 \boxtimes m)\;=\; {(n_1 \boxtimes m)}^{n_2}\;(n_2 \boxtimes m)\)</span>,</p>

</li>
<li><p><span class="SimpleMath">\((n \boxtimes m_1m_2) \;=\; (n \boxtimes m_2)\;{(n \boxtimes m_1)}^{m_2}\)</span>,</p>

</li>
<li><p><span class="SimpleMath">\((n \boxtimes m)^{p} \;=\; (n^p \boxtimes m^p)\)</span>.</p>

</li>
</ul>
</li>
<li><p><span class="SimpleMath">\(\kappa(n \boxtimes m) \;=\; (m^{-1})^{n}\;m \quad \mbox{and} \quad \lambda(n \boxtimes m) \;=\; n^{-1}\;n^{m}\)</span>.</p>

</li>
<li><p><span class="SimpleMath">\((n \boxtimes \kappa l) \;=\; (l^{-1})^{n}\;l \quad \mbox{and} \quad (\lambda l \boxtimes 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="center">\[
{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">\((\kappa,\nu)\)</span> and <span class="SimpleMath">\((\lambda,\mu)\)</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 \subseteq [n]\)</span>;</p>

</li>
<li><p>a commutative diagram of group homomorphisms <span class="SimpleMath">\(\partial_i : S_A \to S_{A \setminus \{i\}},\; i \in [n]\)</span>; with composites <span class="SimpleMath">\(\partial_B : S_A \to S_{A \setminus B},\; B \subseteq [n]\)</span>;</p>

</li>
<li><p>actions of <span class="SimpleMath">\(S_{\emptyset}\)</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">\(\partial_B\)</span> for each <span class="SimpleMath">\(B \subseteq [n]\)</span>;</p>

</li>
<li><p>functions <span class="SimpleMath">\(\boxtimes_{A,B} : S_A \times S_B \to S_{A \cup B}, (A,B \subseteq [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 \cap N\)</span>, then the four inclusions <span class="SimpleMath">\(L \to M,~ L \to N,~ M \to P,~ N \to 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="center">\[
\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 = (\partial_1 : S_1 \to R_1)\)</span> is a normal sub-crossed module of <span class="SimpleMath">\(\calX_0 = (\partial_0 : S_0 \to R_0)\)</span> then the inclusion morphism gives a crossed square with crossed pairing</p>

<p class="center">\[
\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_mj.html#X790EBC7C7D320C03"><span class="RefLink">6.1-2</span></a>)). The crossed pairing is given by</p>

<p class="center">\[
\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_mj.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 \mapsto \iota_g\)</span>, where <span class="SimpleMath">\(\iota_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">\(\iota_g \boxtimes \iota_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 = (\nu : N \to P)\)</span> and <span class="SimpleMath">\(\calX_2 = (\mu : M \to P)\)</span> have a common range <span class="SimpleMath">\(P\)</span>, let <span class="SimpleMath">\(L\)</span> be the pullback of <span class="SimpleMath">\(\{\nu,\mu\}\)</span>. Then <span class="SimpleMath">\(N\)</span> acts on <span class="SimpleMath">\(L\)</span> by <span class="SimpleMath">\((n,m)^{n'} = (n^{n'},m^{\nu n'})\)</span>, and <span class="SimpleMath">\(M\)</span> acts on <span class="SimpleMath">\(L\)</span> by <span class="SimpleMath">\((n,m)^{m'} = (n^{\mu m'}, m^{m'})\)</span>. So <span class="SimpleMath">\((\pi_1 : L \to N)\)</span> and <span class="SimpleMath">\((\pi_2 : L \to M)\)</span> are crossed modules, where <span class="SimpleMath">\(\pi_1,\pi_2\)</span> are the two projections. The crossed pairing is given by:</p>

<p class="center">\[
\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_mj.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( dnrt ); </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 = (\partial : S \to R)\)</span> let <span class="SimpleMath">\(Q\)</span> be the image of <span class="SimpleMath">\(\partial\)</span>. Then <span class="SimpleMath">\(\partial = \partial' \circ \iota\)</span> where <span class="SimpleMath">\(\partial' : S \to Q\)</span> and <span class="SimpleMath">\(\iota\)</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">\(\partial\)</span> is the zero map.</p>

<p class="center">\[

\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">\(\tilde{\calS}\)</span> obtained by interchanging <span class="SimpleMath">\(M\)</span> with <span class="SimpleMath">\(N\)</span>, <span class="SimpleMath">\(\kappa\)</span> with <span class="SimpleMath">\(\lambda\)</span>, and <span class="SimpleMath">\(\nu\)</span> with <span class="SimpleMath">\(\mu\)</span>. The crossed pairing is given by</p>

<p class="center">\[
\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 = (\partial : S \to 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_mj.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">\(\boxtimes : (R \times F) \to S\)</span>, where <span class="SimpleMath">\(F = \Fix(\calX,S,R)\)</span>, is the displacement element <span class="SimpleMath">\(\boxtimes(r,Fs) = \langle r,s \rangle = (s^{-1})^rs\quad\)</span> (see <code class="func">Displacement</code> (<a href="chap4_mj.html#X7E20208279038BB8"><span class="RefLink">4.1-3</span></a>) and section <a href="chap4_mj.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">\(\unlhd\)</span> <code class="code">X24</code>, constructed in section <a href="chap4_mj.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\} \to L\)</span> (see the next subsection). The diagonal crossed module <span class="SimpleMath">\((L \to 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\} \to 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( rtrt, 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_mj.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_{\emptyset})\)</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="center">\[

\vcenter{\xymatrix{
 & C_{[2]} \ar[ddd] <-1.2ex>  \ar[ddd] <-2.0ex>_{\ddot{t}_2,\ddot{h}_2}
     \ar[rrr] <+1.2ex>  \ar[rrr] <+2.0ex>^{\ddot{t}_1,\ddot{h}_1}
     \ar[dddrrr] <-0.2ex>  \ar[dddrrr] <-1.0ex>_(0.55){t_{[2]},h_{[2]}}
    &&&  C_{\{2\}}  \ar[lll]^{\ddot{e}_1}
            \ar[ddd]<+1.2ex>  \ar[ddd] <+2.0ex>^{\dot{t}_2,\dot{h}_2}  \\
\calC \quad = \quad
 &  &&&   \\
 &  &&&   \\
 & C_{\{1\}} \ar[uuu]_{\ddot{e}_2}
     \ar[rrr] <-1.2ex>  \ar[rrr] <-2.0ex>_{\dot{t}_1,\dot{h}_1} 
    &&&  C_{\emptyset} \ar[uuu]^{\dot{e}_2}   \ar[lll]_{\dot{e}_1} 
           \ar[uuulll] <-1.0ex>_{e_{[2]}}
 \\
}}
\]</p>

<p>The following axioms are satisfied by these homomorphisms:</p>


<ul>
<li><p>the four sides of the square (up, left, right, down) are cat<span class="SimpleMath">\(^1\)</span>-groups, denoted <span class="SimpleMath">\(\ddot{\calC}_1, \ddot{\calC}_2, \dot{\calC}_1, \dot{\calC}_2\)</span>;</p>

</li>
<li><p><span class="SimpleMath">\( \dot{t}_1\circ\ddot{h}_2 = \dot{h}_2\circ\ddot{t}_1, ~ \dot{t}_2\circ\ddot{h}_1 = \dot{h}_1\circ\ddot{t}_2, ~ \dot{e}_1\circ\dot{t}_2 = \ddot{t}_2\circ\ddot{e}_1, ~ \dot{e}_2\circ\dot{t}_1 = \ddot{t}_1\circ\ddot{e}_2, ~ \dot{e}_1\circ\dot{h}_2 = \ddot{h}_2\circ\ddot{e}_1, ~ \dot{e}_2\circ\dot{h}_1 = \ddot{h}_1\circ\ddot{e}_2; \)</span></p>

</li>
<li><p><span class="SimpleMath">\( \dot{t}_1\circ\ddot{t}_2 = \dot{t}_2\circ\ddot{t}_1 = t_{[2]}, ~ \dot{h}_1\circ\ddot{h}_2 = \dot{h}_2\circ\ddot{h}_1 = h_{[2]}, ~ \dot{e}_1\circ\ddot{e}_2 = \dot{e}_2\circ\ddot{e}_1 = e_{[2]}, \)</span> making the diagonal a pre-cat<span class="SimpleMath">\(^1\)</span>-group <span class="SimpleMath">\((e_{[2]}; t_{[2]}, h_{[2]} : C_{[2]} \to C_{\emptyset})\)</span>.</p>

</li>
</ul>
<p>It follows from these identities that <span class="SimpleMath">\((\ddot{t}_1,\dot{t}_1),\,(\ddot{h}_1,\dot{h}_1)\)</span> and <span class="SimpleMath">\((\ddot{e}_1,\dot{e}_1)\)</span> are morphisms of cat<span class="SimpleMath">\(^1\)</span>-groups, and similarly in the vertical direction.</p>

<p>Secondly, we give the simplest of the three definitions, adapted from Ellis-Steiner <a href="chapBib_mj.html#biBell:st">[ES87]</a>. A cat<span class="SimpleMath">\(^2\)</span>-group <span class="SimpleMath">\(\calC\)</span> consists of groups <span class="SimpleMath">\(G, R_1,R_2\)</span> and six homomorphisms <span class="SimpleMath">\(t_1,h_1 : G \to R_2,~ e_1 : R_2 \to G,~ t_2,h_2 : G \to R_1,~ e_2 : R_1 \to G\)</span>, satisfying the following axioms for all <span class="SimpleMath">\(1 \leqslant i \leqslant 2\)</span>,</p>


<ul>
<li><p><span class="SimpleMath">\( (t_i \circ e_i)r = r,~ (h_i \circ e_i)r = r,~ \forall r \in R_{[2] \setminus \{i\}}, \quad [\ker t_i, \ker h_i] = 1, \)</span></p>

</li>
<li><p><span class="SimpleMath">\( (e_1 \circ t_1) \circ (e_2 \circ t_2) = (e_2 \circ t_2) \circ (e_1 \circ t_1), \quad (e_1 \circ h_1) \circ (e_2 \circ h_2) = (e_2 \circ h_2) \circ (e_1 \circ h_1), \)</span></p>

</li>
<li><p><span class="SimpleMath">\( (e_1 \circ t_1) \circ (e_2 \circ h_2) = (e_2 \circ h_2) \circ (e_1 \circ t_1), \quad (e_2 \circ t_2) \circ (e_1 \circ h_1) = (e_1 \circ h_1) \circ (e_2 \circ t_2). \)</span></p>

</li>
</ul>
<p>Our third definition defines a cat<span class="SimpleMath">\(^2\)</span>-group as a "cat<span class="SimpleMath">\(^1\)</span>-group of cat<span class="SimpleMath">\(^1\)</span>-groups". A cat<span class="SimpleMath">\(^2\)</span>-group <span class="SimpleMath">\(\calC\)</span> consists of two cat<span class="SimpleMath">\(^1\)</span>-groups <span class="SimpleMath">\(\calC_1 = (e_1;t_1,h_1 : G_1 \to R_1)\)</span> and <span class="SimpleMath">\(\calC_2 = (e_2;t_2,h_2 : G_2 \to R_2)\)</span> and cat<span class="SimpleMath">\(^1\)</span>-morphisms <span class="SimpleMath">\(t = (\ddot{t},\dot{t}),\; h = (\ddot{h},\dot{h}) : \calC_1 \to \calC_2,\; e = (\ddot{e},\dot{e}) : \calC_2 \to \calC_1\)</span>, subject to the following conditions:</p>

<p class="center">\[
(t \circ e) ~\mbox{and}~ (h \circ e)
~\mbox{are the identity mapping on}~ \calC_2, 
\qquad  
[\ker t, \ker h] = \{ 1_{\calC_1} \},
\]</p>

<p>where <span class="SimpleMath">\(\ker t = (\ker \ddot{t},\ \ker \dot{t})\)</span>, and similarly for <span class="SimpleMath">\(\ker h\)</span>.</p>

<p>In a recent paper <em>Computing 3-Dimensional Groups : Crossed Squares and Cat2-Groups</em>, by Arvasi, Odabas and Wensley <a href="chapBib_mj.html#biBAOW">[AOW23]</a>, there are tables listing the numbers of isomorphism classes of cat<span class="SimpleMath">\(^2\)</span>-groups on groups of order at most <span class="SimpleMath">\(30\)</span> – a total of <span class="SimpleMath">\(1007\)</span> cat<span class="SimpleMath">\(^2\)</span>-groups.</p>

<p>As with cat<span class="SimpleMath">\(^1\)</span>-groups, there is no requirement for the various tail and head maps to be endomorphisms, but most of the cat<span class="SimpleMath">\(^2\)</span>-groups constructed by this package are of this type, so that groups <span class="SimpleMath">\(C_{\{2\}},C_{\{1\}}\)</span> and <span class="SimpleMath">\(C_{\emptyset}\)</span> are all subgroups of <span class="SimpleMath">\(C_{[2]}\)</span>.</p>

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

<h5>8.5-1 Cat2Group</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Cat2Group</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">‣ PreCat2Group</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">‣ IsCat2Group</code>( <var class="Arg">C</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">‣ PreCat2GroupByPreCat1Groups</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Following the second definition above, the global functions <code class="code">Cat2Group</code> and <code class="code">PreCat2Group</code> are normally called with two arguments - the generating up and left cat<span class="SimpleMath">\(^1\)</span>-groups <span class="SimpleMath">\(\calC_1\)</span> and <span class="SimpleMath">\(\calC_2\)</span>. In this case the groups <span class="SimpleMath">\(C_{[2]}, C_{\{2\}}, C_{\{1\}}\)</span> are the common source and the ranges of <span class="SimpleMath">\(\calC_1,\calC_2\)</span>, while <span class="SimpleMath">\(C_{\emptyset}\)</span> is the range of <span class="SimpleMath">\((e_1 \circ t_1) \circ (e_2 \circ t_2) = (e_2 \circ t_2) \circ (e_1 \circ t_1)\)</span>.</p>

<p>Alternatively, they may be called with a single argument which is a crossed square.</p>

<p>The operation <code class="code">PreCat2GroupByPreCat1Groups</code> has five arguments - the up, left, right, down and diagonal cat<span class="SimpleMath">\(^1\)</span>-groups.</p>

<p>The two cat<span class="SimpleMath">\(^2\)</span>-groups <code class="code">C2a, C2b</code> constructed in the following example are isomorphic. They differ in the down-right group <code class="code">P</code>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">a := (1,2,3,4,5,6);;  b := (2,6)(3,5);; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := Group( a, b );;  SetName( G, "d12" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t1 := GroupHomomorphismByImages( G, G, [a,b], [a^3,b] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">up := PreCat1GroupByEndomorphisms( t1, t1 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t2 := GroupHomomorphismByImages( G, G, [a,b], [a^4,b] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">left := PreCat1GroupByEndomorphisms( t2, t2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C2a := Cat2Group( up, left );</span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsCat2Group( C2a );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">genR := [ (1,4)(2,5)(3,6), (2,6)(3,5) ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Subgroup( G, genR );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">genQ := [ (1,3,5)(2,4,6), (2,6)(3,5) ];; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Q := Subgroup( G, genQ );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Pa := Group( b );;  SetName( Pa, "c2a" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Pb := Group( (7,8) );;  SetName( Pb, "c2b" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t3 := GroupHomomorphismByImages( R, P, genR, [(),(7,8)] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">e3 := GroupHomomorphismByImages( P, R, [(7,8)], [(2,6)(3,5)] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">right := PreCat1GroupByTailHeadEmbedding( t3, t3, e3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t4 := GroupHomomorphismByImages( Q, P, genQ, [(),(7,8)] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">e4 := GroupHomomorphismByImages( P, Q, [(7,8)], [(2,6)(3,5)] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">down := PreCat1GroupByTailHeadEmbedding( t4, t4, e4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t0 := t1 * t3;; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">e0 := GroupHomomorphismByImages( P, G, [(7,8)], [(2,6)(3,5)] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">diag := PreCat1GroupByTailHeadEmbedding( t0, t0, e0 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C2b := PreCat2GroupByPreCat1Groups( up, left, right, down, diag ); </span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )]
<span class="GAPprompt">gap></span> <span class="GAPinput">C2a = C2b;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">GroupsOfHigherDimensionalGroup( C2a )[4];</span>
Group([ (), (2,6)(3,5) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">GroupsOfHigherDimensionalGroup( C2b )[4];</span>
Group([ (7,8) ])

</pre></div>

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

<h5>8.5-2 Up2DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Up2DimensionalGroup</code>( <var class="Arg">C2G</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">C2G</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">C2G</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">C2G</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">C2G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>These six attributes were defined for crossed squares but apply equally to cat<span class="SimpleMath">\(^2\)</span>-groups.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">Diagonal2DimensionalGroup( C2a );</span>
[d12 => Group( [ (), (2,6)(3,5) ] )]
<span class="GAPprompt">gap></span> <span class="GAPinput">Diagonal2DimensionalGroup( C2b );</span>
[d12 => Group( [ (7,8) ] )]

</pre></div>

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

<h5>8.5-3 DirectProduct</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DirectProduct</code>( <var class="Arg">C2a</var>, <var class="Arg">C2b</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The direct product <span class="SimpleMath">\(\calC_{1} \times \calC_{2}\)</span> has as its four up, left, right and down cat<span class="SimpleMath">\(^1\)</span>-groups the direct products of those in <span class="SimpleMath">\(\calC_{1}\)</span> and <span class="SimpleMath">\(\calC_{2}\)</span>. 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">\(\calC_{1}\)</span> and <span class="SimpleMath">\(\calC_{2}\)</span>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">C2ab := DirectProductOp( [ C2a, C2b ], C2a ); </span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [Group( [ (1,2,3,4,5,6), (2,6)(3,5), ( 7, 8, 9,10,11,12), ( 8,12)( 9,11) 
 ] ) => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5), ( 7,10)( 8,11)( 9,12), 
  ( 8,12)( 9,11) ] )]
2 : [Group( [ (1,2,3,4,5,6), (2,6)(3,5), ( 7, 8, 9,10,11,12), ( 8,12)( 9,11) 
 ] ) => Group( [ (1,5,3)(2,6,4), (2,6)(3,5), ( 7, 9,11)( 8,10,12), 
  ( 8,12)( 9,11) ] )]
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( C2ab );  </span>
"C2 x C2 x S3 x S3""C2 x C2 x C2 x C2""S3 x S3""C2 x C2" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( C2ab, "C2ab" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Embedding( C2ab, 1 );   </span>
<mapping: (pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] -> C2ab >
<span class="GAPprompt">gap></span> <span class="GAPinput">Projection( C2ab, 2 );</span>
<mapping: C2ab -> (pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] >

</pre></div>

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

<h5>8.5-4 DisplayLeadMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DisplayLeadMaps</code>( <var class="Arg">C0</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation provides an alternative to <code class="code">Display</code> giving a shorter output. Generators of the up-left group are output, together with their images under the up and left tail and head maps.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">DisplayLeadMaps( C2b );</span>
(pre-)cat2-group with up-left group: [ (1,2,3,4,5,6), (2,6)(3,5) ]
   up tail=head images: [ (1,4)(2,5)(3,6), (2,6)(3,5) ]
 left tail=head images: [ (1,5,3)(2,6,4), (2,6)(3,5) ]

</pre></div>

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

<h5>8.5-5 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 cat<span class="SimpleMath">\(^2\)</span>-group <span class="SimpleMath">\(\calC\)</span> with groups <span class="SimpleMath">\([G,R,Q,P]\)</span> is the cat<span class="SimpleMath">\(^2\)</span>-group <span class="SimpleMath">\(\tilde{\calC}\)</span> with groups <span class="SimpleMath">\([G,Q,R,P]\)</span>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">TC2a := Transpose3DimensionalGroup( C2a );</span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]

</pre></div>

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

<h5>8.5-6 Cat2GroupMorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Cat2GroupMorphism</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">‣ Cat2GroupMorphismByCat1GroupMorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">upmor</var>, <var class="Arg">ltmor</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">‣ Cat2GroupMorphismByGroupHomomorphisms</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">‣ PreCat2GroupMorphism</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">‣ PreCat2GroupMorphismByPreCat1GroupMorphisms</code>( <var class="Arg">src</var>, <var class="Arg">rng</var>, <var class="Arg">upmor</var>, <var class="Arg">ltmor</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">‣ PreCat2GroupMorphismByGroupHomomorphisms</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 (pre-)cat<span class="SimpleMath">\(^2\)</span>-group morphism <span class="SimpleMath">\(\mu : \calC = (G,R,Q,P) \to \calC' = (G',R',Q',P')\)</span> is a list of four group homomorphisms <span class="SimpleMath">\(\gamma : G \to G',~ \rho : R \to R',~ \xi : Q \to Q'\)</span> and <span class="SimpleMath">\(\pi : P \to P'\)</span> which commute with all the tail, head and embedding maps so that <span class="SimpleMath">\((\gamma,\rho), (\gamma,\xi), (\rho,\pi)\)</span> and <span class="SimpleMath">\((\xi,\pi)\)</span> are all (pre-)cat<span class="SimpleMath">\(^1\)</span>-group morphisms.</p>

<p>For the operations <code class="code">(Pre)Cat2GroupMorphismByPreCat1GroupMorphisms</code> the third and fourth parameters <code class="code">upmor, ltmor</code> are two cat<span class="SimpleMath">\(^1\)</span>-group morphisms with source the up and left cat<span class="SimpleMath">\(^1\)</span>-groups in <span class="SimpleMath">\(\calC\)</span>.</p>

<p>For the operations <code class="code">(Pre)Cat2GroupMorphismByGroupHomomorphisms</codethe third parameter <code class="code">mors</code> is the list <span class="SimpleMath">\([\gamma,\rho,\xi,\pi]\)</span>.</p>

<p>The example constructs an automorphism of <code class="code">c2a</code> is two ways, using the two methods described above, an d verifies that the result is the same in each case.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">gamma := GroupHomomorphismByImages( G, G, [a,b], [a^-1,b] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rho := IdentityMapping( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">xi := GroupHomomorphismByImages( Q, Q, [a^2,b], [a^-2,b] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi := IdentityMapping( Pa );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">homs := [ gamma, rho, xi, pi ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mor1 := Cat2GroupMorphismByGroupHomomorphisms( C2a, C2a, homs );   </span>
<mapping: (pre-)cat2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] -> (pre-)cat
2-group with generating (pre-)cat1-groups:
1 : [d12 => Group( [ (1,4)(2,5)(3,6), (2,6)(3,5) ] )]
2 : [d12 => Group( [ (1,5,3)(2,6,4), (2,6)(3,5) ] )] >
<span class="GAPprompt">gap></span> <span class="GAPinput">upmor := Cat1GroupMorphism( up, up, gamma, rho );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ltmor := Cat1GroupMorphism( left, left, gamma, xi );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mor2 := Cat2GroupMorphismByCat1GroupMorphisms( C2a, C2a, upmor, ltmor );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mor1 = mor2; </span>
true

</pre></div>

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

<h5>8.5-7 Cat2GroupOfCrossedSquare</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Cat2GroupOfCrossedSquare</code>( <var class="Arg">xsq</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">‣ CrossedSquareOfCat2Group</code>( <var class="Arg">CC</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>These functions provide for conversion between crossed squares and cat<span class="SimpleMath">\(^2\)</span>-groups. (They are the 3-dimensional equivalents of <code class="func">Cat1GroupOfXMod</code> (<a href="chap2_mj.html#X82F10A59867C765D"><span class="RefLink">2.5-3</span></a>) and <code class="func">XModOfCat1Group</code> (<a href="chap2_mj.html#X82F10A59867C765D"><span class="RefLink">2.5-3</span></a>).) The actor crossed square <code class="code">XSact</code> was constructed in section <code class="func">ActorCrossedSquare</code> (<a href="chap8_mj.html#X833362FE87ED3C48"><span class="RefLink">8.2-5</span></a>).</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">xsC2a := CrossedSquareOfCat2Group( C2a );</span>
crossed square with crossed modules:
      up = [Group( () ) -> Group( [ (1,4)(2,5)(3,6) ] )]
    left = [Group( () ) -> Group( [ (1,3,5)(2,4,6) ] )]
   right = [Group( [ (1,4)(2,5)(3,6) ] ) -> Group( [ (2,6)(3,5) ] )]
    down = [Group( [ (1,3,5)(2,4,6) ] ) -> Group( [ (2,6)(3,5) ] )]

<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup( xsC2a );</span>
[ [ 1, 1 ], [ 2, 1 ], [ 3, 1 ], [ 2, 1 ] ]

<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Source( Right2DimensionalGroup( XSact ) ), "c5:c4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Range( Right2DimensionalGroup( XSact ) ), "c5:c4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Name( XSact );</span>
"[d10a->c5:c4,d20->c5:c4]"

<span class="GAPprompt">gap></span> <span class="GAPinput">C2act := Cat2GroupOfCrossedSquare( XSact );             </span>
(pre-)cat2-group with generating (pre-)cat1-groups:
1 : [((c5:c4 |X c5:c4) |X (d20 |X d10a))=>(c5:c4 |X c5:c4)]
2 : [((c5:c4 |X c5:c4) |X (d20 |X d10a))=>(c5:c4 |X d20)]
<span class="GAPprompt">gap></span> <span class="GAPinput">Size3d( C2act );</span>
[ 80000, 400, 400, 20 ]

</pre></div>

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

<h5>8.5-8 Subdiagonal2DimensionalGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Subdiagonal2DimensionalGroup</code>( <var class="Arg">obj</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The diagonal of a crossed square is always a crossed module, but the diagonal of a cat<span class="SimpleMath">\(^2\)</span>-group need only be a pre-cat<span class="SimpleMath">\(^1\)</span>-group. There is, however, a sub-cat<span class="SimpleMath">\(^1\)</span>-group of this diagonal which, in the case of a cat<span class="SimpleMath">\(^2\)</span>-group constructed from a crossed square, is <span class="SimpleMath">\((P \ltimes L => P)\)</span>. (The name of this operation is very provisional.)</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">G24 := SmallGroup( 24, 10 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">w := G24.1;; x := G24.2;; y := G24.3;; z := G24.4;; o := One(G24);; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Subgroup( G24, [x,y] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">txy := GroupHomomorphismByImages( G24, R, [w,x,y,z], [o,x,y,o] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">exy := GroupHomomorphismByImages( R, G24, [x,y], [x,y] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C1xy := PreCat1GroupByTailHeadEmbedding( txy, txy, exy );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Q := Subgroup( G24, [w,y] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">twy := GroupHomomorphismByImages( G24, Q, [w,x,y,z], [w,o,y,o] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ewy := GroupHomomorphismByImages( Q, G24, [w,y], [w,y] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C1wy := PreCat1GroupByTailHeadEmbedding( twy, twy, ewy );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C2wxy := PreCat2Group( C1xy, C1xy );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">dg := Diagonal2DimensionalGroup( C2wxy );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">C1sub := Subdiagonal2DimensionalGroup( C2wxy );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">[ IsCat1Group(dg), IsCat1Group(C1sub), IsSub2DimensionalGroup(dg,C1sub) ];</span>
[ false, true, true ]

</pre></div>

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

<h5>8.5-9 SubCat2Group</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubCat2Group</code>( <var class="Arg">C2G</var>, <var class="Arg">ul</var>, <var class="Arg">ur</var>, <var class="Arg">dl</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">‣ IsSubCat2Group</code>( <var class="Arg">C2G</var>, <var class="Arg">subC2G</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">‣ SubPreCat2Group</code>( <var class="Arg">C2G</var>, <var class="Arg">ul</var>, <var class="Arg">ur</var>, <var class="Arg">dl</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">‣ IsSubPreCat2Group</code>( <var class="Arg">C2G</var>, <var class="Arg">subC2G</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>As with crossed squares, we may construct sub-structures of cat<span class="SimpleMath">\(^2\)</span>-groups. In this case we need only prescribe three subgroups, rather than four, so that the up and left sub-cat<span class="SimpleMath">\(^1\)</span>-groups can be specified. The remaining sub-cat<span class="SimpleMath">\(^1\)</span>-groups are then calculated automatically.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">gps := GroupsOfHigherDimensionalGroup( C2ab );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c6c2 := Subgroup( gps[1], [ (1,2,3,4,5,6), (8,12)(9,11) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c2c2 := Subgroup( gps[2], [ (1,4)(2,5)(3,6), (8,12)(9,11) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c3c2 := Subgroup( gps[3], [ (1,5,3)(2,6,4), (8,12)(9,11) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SC2ab := SubCat2Group( C2ab, c6c2, c2c2, c3c2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( SC2ab );              </span>
(pre-)cat2-group with groups: [ Group( [ (1,2,3,4,5,6), ( 8,12)( 9,11) ] ), 
  Group( [ (1,4)(2,5)(3,6), ( 8,12)( 9,11) ] ), 
  Group( [ (1,5,3)(2,6,4), ( 8,12)( 9,11) ] ), 
  Group( [ (), ( 8,12)( 9,11) ] ) ]
   up tail=head: [ [ (1,2,3,4,5,6), ( 8,12)( 9,11) ], 
  [ (1,4)(2,5)(3,6), ( 8,12)( 9,11) ] ]
 left tail=head: [ [ (1,2,3,4,5,6), ( 8,12)( 9,11) ], 
  [ (1,5,3)(2,6,4), ( 8,12)( 9,11) ] ]
right tail=head: [ [ (1,4)(2,5)(3,6), ( 8,12)( 9,11) ], 
  [ (), ( 8,12)( 9,11) ] ]
 down tail=head: [ [ (1,5,3)(2,6,4), ( 8,12)( 9,11) ], [ (), ( 8,12)( 9,11) ] 
 ]

</pre></div>

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

<h5>8.5-10 TrivialSubCat2Group</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TrivialSubCat2Group</code>( <var class="Arg">C2G</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">‣ TrivialSubPreCat2Group</code>( <var class="Arg">C2G</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 := TrivialSubCrossedSquare( C2ab );</span>
crossed square with crossed modules:
      up = [Group( () ) -> Group( () )]
    left = [Group( () ) -> Group( () )]
   right = [Group( () ) -> Group( () )]
    down = [Group( () ) -> Group( () )]

</pre></div>

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

<h4>8.6 <span class="Heading">Enumerating cat<span class="SimpleMath">\(^2\)</span>-groups with a given source</span></h4>

<p>This section mirrors that for cat<span class="SimpleMath">\(^1\)</span>-groups (<a href="chap2_mj.html#X80D6CB4080417BFA"><span class="RefLink">2.6</span></a>). As the size of a group <span class="SimpleMath">\(G\)</span> increases, the number of cat<span class="SimpleMath">\(^2\)</span>-groups with source <span class="SimpleMath">\(G\)</span> increases rapidly. However, one is usually only interested in the isomorphism classes of cat<span class="SimpleMath">\(^2\)</span>-groups with source <span class="SimpleMath">\(G\)</span>. An iterator <code class="code">AllCat2GroupsIterator</code> is provided, which runs through the various cat<span class="SimpleMath">\(^2\)</span>-groups. This iterator finds, for each unordered pair of subgroups <span class="SimpleMath">\(R,Q\)</span> of <span class="SimpleMath">\(G\)</span>, the cat<span class="SimpleMath">\(^2\)</span>-groups whose <code class="code">Up2DimensionalGroup</code> has range <span class="SimpleMath">\(R\)</span>, and whose <code class="code">Left2DimensionalGroup</codehas range <span class="SimpleMath">\(Q\)</span>. It does this by running through <code class="code">UnoderedPairsIterator(AllSubgroupsIterator(G))</code> provided by the <strong class="pkg">Utils</strong> package, and then using the iterator <code class="code">AllCat2GroupsWithImagesIterator(G,R,Q)</code>.</p>

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

<h5>8.6-1 AllCat2GroupsWithImagesIterator</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllCat2GroupsWithImagesIterator</code>( <var class="Arg">G</var>, <var class="Arg">R</var>, <var class="Arg">Q</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">‣ AllCat2GroupsWithImagesNumber</code>( <var class="Arg">G</var>, <var class="Arg">R</var>, <var class="Arg">Q</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">‣ AllCat2GroupsWithImages</code>( <var class="Arg">G</var>, <var class="Arg">R</var>, <var class="Arg">Q</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">‣ AllCat2GroupsWithImagesUpToIsomorphism</code>( <var class="Arg">G</var>, <var class="Arg">R</var>, <var class="Arg">Q</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The iterator <code class="code">AllCat2GroupsWithImagesIterator(G)</code> iterates through all the cat<span class="SimpleMath">\(^2\)</span>-groups with source <code class="code">G</code> and generating cat<span class="SimpleMath">\(^1\)</span>-groups <code class="code">(G=>R)</code> and <code class="code">(G=>Q)</code>. The attribute <code class="code">AllCat2GroupsWithImagesNumber(G)</code> runs through this iterator to determine the number <span class="SimpleMath">\(n\)</span> of these cat<span class="SimpleMath">\(^2\)</span>-groups. The operation <code class="code">AllCat2GroupsWithImages(G)</code> returns a list containing these <span class="SimpleMath">\(n\)</span> cat<span class="SimpleMath">\(^2\)</span>-groups. Since these lists can get very long, this operation should only be used for simple cases. The operation <code class="code">AllCat2GroupsWithImagesUpToIsomorphism(G)</code> returns representatives of the isomorphism classes of these cat<span class="SimpleMath">\(^2\)</span>-groups.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">G8 := Group( (1,2), (3,4), (5,6) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">A := Subgroup( G8, [ (1,2) ] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">B := Subgroup( G8, [ (3,4) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsWithImagesNumber( G8, A, A );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">all := AllCat2GroupsWithImages( G8, A, A );;     </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for C2 in all do DisplayLeadMaps( C2 ); od;</span>
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (1,2), () ]
 left tail=head images: [ (1,2), (1,2), () ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail=head images: [ (1,2), (), () ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), (1,2) ]
 left tail=head images: [ (1,2), (), (1,2) ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (1,2), (1,2) ]
 left tail=head images: [ (1,2), (1,2), (1,2) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsWithImagesNumber( G8, A, B );</span>
16
<span class="GAPprompt">gap></span> <span class="GAPinput">iso := AllCat2GroupsWithImagesUpToIsomorphism( G8, A, B );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for C2 in iso do DisplayLeadMaps( C2 ); od;</span>
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail=head images: [ (), (3,4), () ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail/head images: [ (1,2), (), () ], [ (1,2), (), (1,2) ]
 left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ]

</pre></div>

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

<h5>8.6-2 AllCat2GroupsWithFixedUp</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllCat2GroupsWithFixedUp</code>( <var class="Arg">C</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">‣ AllCat2GroupsWithFixedUpAndLeftRange</code>( <var class="Arg">C</var>, <var class="Arg">R</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The operation <code class="code">AllCat2GroupsWithFixedUp(C)</code> constructs all the cat<span class="SimpleMath">\(^2\)</span>-groups with a fixed <code class="code">Up2DimensionalGroup</code> <span class="SimpleMath">\(C\)</span>. In the second operation the user may also specify the range of the <code class="code">Left2DimensionalGroup</code>.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">up := Up2DimensionalGroup( iso[1] );                </span>
[Group( [ (1,2), (3,4), (5,6) ] )=>Group( [ (1,2), (), () ] )]
<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsWithFixedUp( up );;                    </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length(last);                                       </span>
28
<span class="GAPprompt">gap></span> <span class="GAPinput">L := AllCat2GroupsWithFixedUpAndLeftRange( up, B );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for C in L do DisplayLeadMaps( C ); od;             </span>
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail=head images: [ (), (3,4), () ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail/head images: [ (), (3,4), () ], [ (), (3,4), (3,4) ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail/head images: [ (), (3,4), (3,4) ], [ (), (3,4), () ]
(pre-)cat2-group with up-left group: [ (1,2), (3,4), (5,6) ]
   up tail=head images: [ (1,2), (), () ]
 left tail=head images: [ (), (3,4), (3,4) ]

</pre></div>

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

<h5>8.6-3 AllCat2GroupsMatrix</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllCat2GroupsMatrix</code>( <var class="Arg">G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The operation <code class="code">AllCat2GroupsMatrix(G)</code> constructs a symmetric matrix <span class="SimpleMath">\(M\)</span> with rows and columns labelled by the cat<span class="SimpleMath">\(^1\)</span>-groups <span class="SimpleMath">\(C_i\)</span> on <span class="SimpleMath">\(G\)</span>, where <span class="SimpleMath">\(M_{ij}\)</span> is <span class="SimpleMath">\(1\)</span> if <span class="SimpleMath">\(C_i,C_j\)</span> combine to form a cat<span class="SimpleMath">\(^2\)</span>-group, and <span class="SimpleMath">\(0\)</span> otherwise. The matrix is automatically printed out with dots in place of zeroes.</p>

<p>In the example we see that the dihedral group <span class="SimpleMath">\(D_{12}\)</span> has <span class="SimpleMath">\(12\)</span> cat<span class="SimpleMath">\(^1\)</span>-groups and <span class="SimpleMath">\(41\)</span> cat<span class="SimpleMath">\(^2\)</span>-groups, <span class="SimpleMath">\(12\)</span> of which are symmetric. This operation is intended to be used to illustrate how cat<span class="SimpleMath">\(^2\)</span>-groups are formed, and should only be used with groups of low order.</p>

<p>The attribute <code class="code">AllCat2GroupsNumber(G)</code> returns the number <span class="SimpleMath">\(n\)</span> of these cat<span class="SimpleMath">\(^2\)</span>-groups.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsMatrix(d12);;                </span>
number of cat2-groups found = 41
1.....1..1.1
.1.....1.1.1
..1.....11.1
...1....1.11
....1.1...11
.....1.1..11
1...1.1..111
.1...1.1.111
..11....1111
111...1111.1
...111111.11
111111111111
<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsNumber(d12); </span>
41

</pre></div>

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

<h5>8.6-4 AllCat2GroupsIterator</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllCat2GroupsIterator</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">‣ AllCat2Groups</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">‣ AllCat2GroupsUpToIsomorphism</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">‣ AllCat2GroupFamilies</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">‣ CatnGroupNumbers</code>( <var class="Arg">G</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">‣ CatnGroupLists</code>( <var class="Arg">G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The iterator <code class="code">AllCat2GroupsIterator(G)</code> iterates through all the cat<span class="SimpleMath">\(^2\)</span>-groups with source <code class="code">G</code>. The operation <code class="code">AllCat2Groups(G)</code> returns a list containing these <span class="SimpleMath">\(n\)</span> cat<span class="SimpleMath">\(^2\)</span>-groups. Since these lists can get very long, this operation should only be used for simple cases. The operation <code class="code">AllCat2GroupsUpToIsomorphism(G)</code> returns representatives of the isomorphism classes of these subgroups. The operation <code class="code">AllCat2GroupFamilies(G)</code> returns a list of lists. The <span class="SimpleMath">\(k\)</span>-th list contains the positions of the cat<span class="SimpleMath">\(^2\)</span>-groups in <code class="code">AllCat2Groups(G)</code> which are isomorphic to the <span class="SimpleMath">\(k\)</span>-th representative. So, for <code class="code">d12</code>, the <span class="SimpleMath">\(41\)</span> cat<span class="SimpleMath">\(^2\)</span>-groups form <span class="SimpleMath">\(10\)</span> classes, and the sizes of these classes are <code class="code">[6,6,6,6,3,6,3,2,2,1]</code>. Four of these classes contain symmetric cat<span class="SimpleMath">\(^2\)</span>-groups.</p>

<p>The field <code class="code">CatnGroupNumbers(G).cat2</code> is the number of cat<span class="SimpleMath">\(^2\)</span>-groups on <span class="SimpleMath">\(G\)</span>, while <code class="code">CatnGroupNumbers(G).iso2</code> is the number of isomorphism classes of these cat<span class="SimpleMath">\(^2\)</span>-groups. Also <code class="code">CatnGroupNumbers(G).symm</code> is the number of cat<span class="SimpleMath">\(^2\)</span>-groups whose <code class="code">Up2DimensionalGroup</code> is the same as the <code class="code">Left2DimensionalGroup</code>, while <code class="code">CatnGroupNumbers(G).siso</code> is the number of isomorphism classes of these symmetric cat<span class="SimpleMath">\(^2\)</span>-groups.</p>

<p>Provided that <code class="code">CatnGroupLists(G).omit</code> is not set to <code class="code">true</code>, <em>sorted</em> lists of generating pairs, and of the classes they belong to, are added to the record <code class="code">CatnGroupLists</code>. For example <code class="code">[5,7]</code> in these lists for <code class="code">d12</code> indicates that there is a cat<span class="SimpleMath">\(^2\)</span>-group generated by the fifth and seventh cat<span class="SimpleMath">\(^1\)</span>-groups and that this is in the second class whose representative is <code class="code">[1,7]</code>. Classes <code class="code">[1,5,8,10]</code> contain symmetric cat<span class="SimpleMath">\(^2\)</span>-groups.</p>


<div class="example"><pre>

<span class="GAPprompt">gap></span> <span class="GAPinput">AllCat2GroupsNumber( d12 );</span>
41
<span class="GAPprompt">gap></span> <span class="GAPinput">reps2 := AllCat2GroupsUpToIsomorphism( d12 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( reps2 );</span>
10
<span class="GAPprompt">gap></span> <span class="GAPinput">List( reps2, C -> StructureDescription( C ) );</span>
[ [ "D12""C2""C2""C2" ], [ "D12""C2""C2 x C2""C2" ], 
  [ "D12""C2""S3""C2" ], [ "D12""C2""D12""C2" ], 
  [ "D12""C2 x C2""C2 x C2""C2 x C2" ], [ "D12""C2 x C2""S3""C2" ]
    , [ "D12""C2 x C2""D12""C2 x C2" ], [ "D12""S3""S3""S3" ], 
  [ "D12""S3""D12""S3" ], [ "D12""D12""D12""D12" ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fams := AllCat2GroupFamilies( d12 );</span>
[ [ 1, 2, 3, 4, 5, 6 ], [ 7, 8, 10, 11, 13, 14 ], [ 16, 17, 18, 23, 24, 25 ], 
  [ 30, 31, 32, 33, 34, 35 ], [ 9, 12, 15 ], [ 19, 20, 21, 26, 27, 28 ], 
  [ 36, 37, 38 ], [ 22, 29 ], [ 39, 40 ], [ 41 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">CatnGroupNumbers( d12 );</span>
rec( cat1 := 12, cat2 := 41, idem := 21, iso1 := 4, iso2 := 10, 
  isopredg := 0, predg := 0, siso := 4, symm := 12 )
<span class="GAPprompt">gap></span> <span class="GAPinput">CatnGroupLists( d12 );</span>
rec( allcat2pos := [ 1, 7, 9, 16, 19, 22, 30, 36, 39, 41 ],
  cat2classes := 
    [ [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ], [ 5, 5 ], [ 6, 6 ] ], 
      [ [ 1, 7 ], [ 5, 7 ], [ 2, 8 ], [ 6, 8 ], [ 3, 9 ], [ 4, 9 ] ], 
      [ [ 1, 10 ], [ 2, 10 ], [ 3, 10 ], [ 4, 11 ], [ 5, 11 ], [ 6, 11 ] ], 
      [ [ 1, 12 ], [ 2, 12 ], [ 3, 12 ], [ 4, 12 ], [ 5, 12 ], [ 6, 12 ] ], 
      [ [ 7, 7 ], [ 8, 8 ], [ 9, 9 ] ], 
      [ [ 7, 10 ], [ 8, 10 ], [ 9, 10 ], [ 7, 11 ], [ 8, 11 ], [ 9, 11 ] ], 
      [ [ 7, 12 ], [ 8, 12 ], [ 9, 12 ] ], [ [ 10, 10 ], [ 11, 11 ] ], 
      [ [ 10, 12 ], [ 11, 12 ] ], [ [ 12, 12 ] ] ], 
  cat2pairs := [ [ 1, 1 ], [ 1, 7 ], [ 1, 10 ], [ 1, 12 ], [ 2, 2 ], 
      [ 2, 8 ], [ 2, 10 ], [ 2, 12 ], [ 3, 3 ], [ 3, 9 ], [ 3, 10 ], 
      [ 3, 12 ], [ 4, 4 ], [ 4, 9 ], [ 4, 11 ], [ 4, 12 ], [ 5, 5 ], 
      [ 5, 7 ], [ 5, 11 ], [ 5, 12 ], [ 6, 6 ], [ 6, 8 ], [ 6, 11 ], 
      [ 6, 12 ], [ 7, 7 ], [ 7, 10 ], [ 7, 11 ], [ 7, 12 ], [ 8, 8 ], 
      [ 8, 10 ], [ 8, 11 ], [ 8, 12 ], [ 9, 9 ], [ 9, 10 ], [ 9, 11 ], 
      [ 9, 12 ], [ 10, 10 ], [ 10, 12 ], [ 11, 11 ], [ 11, 12 ], [ 12, 12 ] ],
  omit := false, pisopos := [  ], sisopos := [ 1, 5, 8, 10 ] )

</pre></div>


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


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chap8_mj.html">8</a>  <a href="chap9_mj.html">9</a>  <a href="chap10_mj.html">10</a>  <a href="chap11_mj.html">11</a>  <a href="chap12_mj.html">12</a>  <a href="chap13_mj.html">13</a>  <a href="chap14_mj.html">14</a>  <a href="chap15_mj.html">15</a>  <a href="chapBib_mj.html">Bib</a>  <a href="chapInd_mj.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.34 Sekunden  (vorverarbeitet am  2026-04-28) ¤

*© 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.