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 111 kB image not shown  

Quelle  chap8.html   Sprache: HTML

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


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

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

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (XMod) - Chapter 8: Crossed squares and Cat^2-groups</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap8"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

<p class="pcenter">

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

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


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

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

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

<p>and the diagonal</p>

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

<h5>8.2-1 CrossedSquareByXMods</h5>

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-2 Size3d</h5>

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-3 CrossedSquareByNormalSubgroups</h5>

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-4 CrossedSquareByNormalSubXMod</h5>

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-5 ActorCrossedSquare</h5>

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

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-6 CrossedSquareByAutomorphismGroup</h5>

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


<div class="example"><pre>

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

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

</pre></div>

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

<h5>8.2-7 CrossedSquareByPullback</h5>

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-8 CrossedSquareByXModSplitting</h5>

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

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

<p class="pcenter">

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-9 CrossedSquare</h5>

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


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

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

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

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

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

</li>
</ul>

<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-10 Transpose3DimensionalGroup</h5>

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

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


<div class="example"><pre>

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


</pre></div>

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

<h5>8.2-11 CentralQuotient</h5>

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


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

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

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

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

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-12 IsCrossedSquare</h5>

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

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

<h5>8.2-13 Up2DimensionalGroup</h5>

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.2-14 IsSymmetric3DimensionalGroup</h5>

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

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

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

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

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


<div class="example"><pre>

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

</pre></div>

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


<div class="example"><pre>

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

</pre></div>

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

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

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

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

<h5>8.3-1 SubCrossedSquare</h5>

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

<div class="example"><pre>

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

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

</pre></div>

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

<h5>8.3-2 TrivialSub3DimensionalGroup</h5>

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


<div class="example"><pre>

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

</pre></div>

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

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

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

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

<h5>8.4-1 CrossedSquareMorphism</h5>

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

<h5>8.4-2 Source</h5>

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

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

<h5>8.4-3 IsCrossedSquareMorphism</h5>

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


<div class="example"><pre>

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

</pre></div>

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

<h5>8.4-4 InclusionMorphismHigherDimensionalDomains</h5>

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

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

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

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

<p class="pcenter">

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

--> maximum size reached

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

¤ Dauer der Verarbeitung: 0.27 Sekunden  (vorverarbeitet)  ¤

*© 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 ist noch experimentell.