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

Quelle  chap3_mj.html   Sprache: HTML

 
 products/Sources/formale Sprachen/GAP/pkg/permut/doc/chap3_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://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (PERMUT) - Chapter 3: Permutability of Subgroups in Finite 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="chap3"  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="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="chap2_mj.html">[Previous Chapter]</a>    <a href="chap4_mj.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap3.html">[MathJax off]</a></p>
<p><a id="X7B87CECD83EA77DF" name="X7B87CECD83EA77DF"></a></p>
<div class="ChapSects"><a href="chap3_mj.html#X7B87CECD83EA77DF">3 <span class="Heading">Permutability of Subgroups in Finite Groups</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3_mj.html#X834D77E17960C0B7">3.1 <span class="Heading">Permutability functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X862727A87C26B10B">3.1-1 ArePermutableSubgroups</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3_mj.html#X875BEB9B7D0DBC9A">3.2 <span class="Heading">Embedding properties related to permutability</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X85CFBEBB83245E3A">3.2-1 PermutMaxTries</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X80C15D427EC11A5F">3.2-2 IsPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X8244918D7D1C2703">3.2-3 OneSubgroupNotPermutingWith</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X865C7F81823FFA10">3.2-4 IsFPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X826D28757824F83E">3.2-5 OneFSubgroupNotPermutingWith</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X7BA6690983912C09">3.2-6 IsSPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X83E103AF7C3DC9B7">3.2-7 OneSylowSubgroupNotPermutingWith</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X86A62A52831BE00E">3.2-8 IsSNPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X83D1BF5778D6790A">3.2-9 OneSystemNormaliserNotPermutingWith</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X7B2E052E7F9C4251">3.2-10 IsConjugatePermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X809E1C8E8384ADE8">3.2-11 OneConjugateSubgroupNotPermutingWith</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X7AC58CFF87770C6C">3.2-12 IsWeaklySPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X870923B4798E5097">3.2-13 OneElementShowingNotWeaklySPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X85E85FBF78DAB08E">3.2-14 IsWeaklyPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X8427C8DD78732D56">3.2-15 OneElementShowingNotWeaklyPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X84BE89EF8140D2C0">3.2-16 IsWeaklyNormal</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X82C8AE027E578ACF">3.2-17 OneElementShowingNotWeaklyNormal</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X872EA72A7CEC3E65">3.2-18 IsWithSubnormalizerCondition</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X7FBEC9DD7C8AED52">3.2-19 OneSubgroupInWhichSubnormalNotNormal</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X87CA542C7E1FEEF3">3.2-20 IsWithSubpermutizerCondition</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X79648B4F8758E187">3.2-21 OneSubgroupInWhichSubnormalNotPermutable</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X831F5B8787BB111F">3.2-22 IsWithSSubpermutizerCondition</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3_mj.html#X7AC9002B7D5AB2DA">3.2-23 OneSubgroupInWhichSubnormalNotSPermutable</a></span>
</div></div>
</div>

<h3>3 <span class="Heading">Permutability of Subgroups in Finite Groups</span></h3>

<p>This chapter describes functions to check permutability of subgroups in a given group. First we present a function to check whether a subgroup permutes with another one, then we present functions to test whether a subgroup permutes with the members of a given family of subgroups, and finally we introduce some other subgroup embedding properties related to permutability.</p>

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

<h4>3.1 <span class="Heading">Permutability functions</span></h4>

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

<h5>3.1-1 ArePermutableSubgroups</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ArePermutableSubgroups</code>( [<var class="Arg">G</var>, ]<var class="Arg">U</var>, <var class="Arg">V</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>This function returns <code class="keyw">true</code> if <var class="Arg">U</var> and <var class="Arg">V</var> permute in <var class="Arg">G</var>. The groups <var class="Arg">U</var> and <var class="Arg">V</var> must be subgroups of <var class="Arg">G</var>. The subgroups <span class="SimpleMath">\(U\)</span> and <span class="SimpleMath">\(V\)</span> <em>permute</em> when <span class="SimpleMath">\(UV = VU\)</span>. This is equivalent to affirming that <span class="SimpleMath">\(UV\)</span> is a subgroup of <span class="SimpleMath">\(G\)</span>.</p>

<p>This is done by checking that the order of <span class="SimpleMath">\(\langle U, V \rangle\)</span> is the order of their Frobenius product <span class="SimpleMath">\(UV\)</span>, that is, <span class="SimpleMath">\(|U||V|/|U \cap V|\)</span>. Hence the performance of this function depends strongly on the existence of good algorithms to compute the intersection of two subgroups and, of course, the order of a subgroup. Shorthands are provided for the cases in which one of <var class="Arg">U</var> and <var class="Arg">V</var> is a subgroup of the other one or <var class="Arg">U</var> or <var class="Arg">V</var> are permutable in a common supergroup.</p>

<p>In the version with two arguments, <var class="Arg">U</var> and <var class="Arg">V</var> must have a common parent or <code class="code">ClosureGroup( U, V )</code> (see <code class="func">ClosureGroup</code> (<a href="../../../doc/ref/chap39_mj.html#X7D13FC1F8576FFD8"><span class="RefLink">Reference: ClosureGroup</span></a>)) is called to construct a common supergroup for <var class="Arg">U</var> and <var class="Arg">V</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SymmetricGroup(4);</span>
Sym( [ 1 .. 4 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2)(3,4)]);</span>
Group([ (1,2)(3,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">b:=Subgroup(g,[(1,2,3)]);</span>
Group([ (1,2,3) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">c:=Subgroup(g,[(1,2)]);</span>
Group([ (1,2) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">ArePermutableSubgroups(g,a,b);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">ArePermutableSubgroups(g,a,c);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">ArePermutableSubgroups(g,b,c);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">ArePermutableSubgroups(b,c);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">ArePermutableSubgroups(b,a);</span>
false
</pre></div>

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

<h4>3.2 <span class="Heading">Embedding properties related to permutability</span></h4>

<p>In the following we describe some functions which allow us to test whether a subgroup permutes with the members of some families of subgroups. We pay special attention to the families of all subgroups and all Sylow subgroups of the group. In some cases, we have introduced some "One" functions, which give an element or a subgroup in the relevant family of subgroups of the group which shows that the given property fails, or <code class="keyw">fail</code> otherwise.</p>

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

<h5>3.2-1 PermutMaxTries</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PermutMaxTries</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p>This variable contains the maximum number of random attempts of permutability checks before trying general deterministic methods in the functions <code class="func">IsPermutable</code> (<a href="chap3_mj.html#X80C15D427EC11A5F"><span class="RefLink">3.2-2</span></a>) and <code class="func">IsIwasawaSylow</code> (<a href="chap5_mj.html#X8121A92F7EABEA0C"><span class="RefLink">5.3-5</span></a>). Its default value is <span class="SimpleMath">\(10\)</span>.</p>

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

<h5>3.2-2 IsPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This property returns <code class="keyw">true</code> if the subgroup <var class="Arg">H</var> is permutable in <var class="Arg">G</var>, otherwise it returns <code class="keyw">false</code>. We say that a subgroup <span class="SimpleMath">\(H\)</span> of a group <span class="SimpleMath">\(G\)</span> is <em>permutable</em> in <span class="SimpleMath">\(G\)</span> if <span class="SimpleMath">\(H\)</span> permutes with all subgroups of <span class="SimpleMath">\(G\)</span>.</p>

<p>If the attribute <code class="func">OneSubgroupNotPermutingWithInParent</code> (<a href="chap3_mj.html#X8244918D7D1C2703"><span class="RefLink">3.2-3</span></a>) has been set, it is used if possible. Otherwise, the algorithm checks looks for a cyclic subgroup not permuting with <var class="Arg">H</var>. The number of such cyclic subgroups is controlled by the variable <code class="func">PermutMaxTries</code> (<a href="chap3_mj.html#X85CFBEBB83245E3A"><span class="RefLink">3.2-1</span></a>), by default, <span class="SimpleMath">\(10\)</span>. If <var class="Arg">H</var> permutes with all these subgroups, then the algorithm checks whether <var class="Arg">H</var> is hypercentrally embedded in <var class="Arg">G</var> and that the Sylow <span class="SimpleMath">\(p\)</span>-subgroups of <span class="SimpleMath">\(H/H_G\)</span> permute with all cyclic <span class="SimpleMath">\(p\)</span>-subgroups of <span class="SimpleMath">\(G/H_G\)</span> for each prime <span class="SimpleMath">\(p\)</span> dividing the order of <span class="SimpleMath">\(G/H_G\)</span>. This is a sufficient condition for permutability.</p>

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

<h5>3.2-3 OneSubgroupNotPermutingWith</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSubgroupNotPermutingWith</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSubgroupNotPermutingWithInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This attribute finds a cyclic subgroup of <var class="Arg">G</var> which does not permute with <var class="Arg">H</var>, that is, a subgroup which shows that <var class="Arg">H</var> is not permutable in <var class="Arg">G</var>. Recall that a subgroup <span class="SimpleMath">\(H\)</span> of a group <span class="SimpleMath">\(G\)</span> is <em>permutable</em> in <span class="SimpleMath">\(G\)</span> if <span class="SimpleMath">\(H\)</span> permutes with all subgroups of <span class="SimpleMath">\(G\)</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SymmetricGroup(4);</span>
Sym( [ 1 .. 4 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2)(3,4)]);</span>
Group([ (1,2)(3,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">b:=Subgroup(g,[(1,2,3)]);</span>
Group([ (1,2,3) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">c:=Subgroup(g,[(1,2)]);</span>
Group([ (1,2) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,b);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,c);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">OneSubgroupNotPermutingWith(g,b);</span>
Group([ (1,3,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">v:=Subgroup(g,[(1,2)(3,4),(1,3)(2,4)]);</span>
Group([ (1,2)(3,4), (1,3)(2,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">OneSubgroupNotPermutingWith(g,v);</span>
fail
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,b);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,v);</span>
true
</pre></div>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SmallGroup(16,6);</span>
<pc group of size 16 with 4 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">h:=Subgroup(g,[g.2]);</span>
Group([ f2 ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsNormal(g,h);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,h);</span>
true
</pre></div>

<p>Sometimes one does not require a subgroup to permute with all subgroups of the group, but only with a selected family of subgroups of the group. The general case is the following.</p>

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

<h5>3.2-4 IsFPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</var>, <var class="Arg">f</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>In this function, <var class="Arg">H</var> is a subgroup of <var class="Arg">G</var> and <var class="Arg">f</var> must be a list of subgroups of <var class="Arg">G</var>. It returns <code class="keyw">true</code> if <var class="Arg">H</var> permutes with all members of <var class="Arg">f</var> and <code class="keyw">false</code> otherwise.</p>

<p>This function uses the function <code class="func">OneFSubgroupNotPermutingWith</code> (<a href="chap3_mj.html#X826D28757824F83E"><span class="RefLink">3.2-5</span></a>). Hence it tries to use the values of <code class="func">IsPermutableInParent</code> (<a href="chap3_mj.html#X80C15D427EC11A5F"><span class="RefLink">3.2-2</span></a>) and <code class="func">OneSubgroupNotPermutingWithInParent</code> (<a href="chap3_mj.html#X8244918D7D1C2703"><span class="RefLink">3.2-3</span></a>) if one of them is set, and if it returns <code class="keyw">false</code> it tries to set the values of <code class="func">IsPermutableInParent</code> (<a href="chap3_mj.html#X80C15D427EC11A5F"><span class="RefLink">3.2-2</span></a>) and <code class="func">OneSubgroupNotPermutingWithInParent</code> (<a href="chap3_mj.html#X8244918D7D1C2703"><span class="RefLink">3.2-3</span></a>).</p>

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

<h5>3.2-5 OneFSubgroupNotPermutingWith</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneFSubgroupNotPermutingWith</code>( <var class="Arg">G</var>, <var class="Arg">H</var>, <var class="Arg">f</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>In this operation, <var class="Arg">H</var> is a subgroup of <var class="Arg">G</var> and <var class="Arg">f</var> must be a list of subgroups of <var class="Arg">G</var>. It returns a subgroup in <var class="Arg">f</var> not permuting with <var class="Arg">H</var> if such a subgroup exists, and <code class="keyw">fail</code> otherwise.</p>

<p>This function tries to use the values of <code class="func">IsPermutableInParent</code> (<a href="chap3_mj.html#X80C15D427EC11A5F"><span class="RefLink">3.2-2</span></a>) and <code class="func">OneSubgroupNotPermutingWithInParent</code> (<a href="chap3_mj.html#X8244918D7D1C2703"><span class="RefLink">3.2-3</span></a>) if one of them is set. If it returns <code class="keyw">fail</code>, then it tries to set the value of <code class="func">IsPermutableInParent</code> (<a href="chap3_mj.html#X80C15D427EC11A5F"><span class="RefLink">3.2-2</span></a>) and <code class="func">OneSubgroupNotPermutingWithInParent</code> (<a href="chap3_mj.html#X8244918D7D1C2703"><span class="RefLink">3.2-3</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SymmetricGroup(4);</span>
Sym( [ 1 .. 4 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2,3,4),(1,3)]);</span>
Group([ (1,2,3,4), (1,3) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">Size(a);</span>
8
<span class="GAPprompt">gap></span> <span class="GAPinput">OneFSubgroupNotPermutingWith(g,a,MaximalSubgroups(g));</span>
Group([ (1,2), (3,4), (1,3)(2,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsFPermutable(g,a,MaximalSubgroups(g));</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">HasIsPermutableInParent(a);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutableInParent(a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">HasOneSubgroupNotPermutingWithInParent(a);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">OneSubgroupNotPermutingWithInParent(a);</span>
Group([ (1,2), (3,4), (1,3)(2,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsFPermutable(g,a,AllSubnormalSubgroups(g));</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">OneFSubgroupNotPermutingWith(g,a,AllSubnormalSubgroups(g));</span>
fail
<span class="GAPprompt">gap></span> <span class="GAPinput">sylows:=g->Union(List(SylowSubgroups(g),</span>
<span class="GAPprompt">></span> <span class="GAPinput">          t->ConjugacyClassSubgroups(g,t)));</span>
function( g ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">OneFSubgroupNotPermutingWith(g,a,sylows(g));</span>
Group([ (3,4), (1,4)(2,3), (1,3)(2,4) ])
</pre></div>

<p>The following functions can be considered as particular cases of the previous function for some subgroup embedding functors. However, they can be stored as "in parent" attributes or properties and in some cases we have tried to give more efficient code.</p>

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

<h5>3.2-6 IsSPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsSPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if a subgroup <var class="Arg">H</var> of <var class="Arg">G</var> is S-permutable in <var class="Arg">G</var>, that is, <var class="Arg">H</var> permutes with all Sylow subgroups of <var class="Arg">G</var>, and returns <code class="keyw">false</code> otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SmallGroup(8,3);</span>
<pc group of size 8 with 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSPermutable(g,Subgroup(g,[g.1]));</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,Subgroup(g,[g.1]));</span>
false
</pre></div>

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

<h5>3.2-7 OneSylowSubgroupNotPermutingWith</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSylowSubgroupNotPermutingWith</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSylowSubgroupNotPermutingWithInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The argument <var class="Arg">H</var> must be a subgroup of <var class="Arg">G</var>. If <var class="Arg">H</var> is S-permutable in <var class="Arg">G</var>, then it returns <code class="keyw">fail</code>. Otherwise, it returns a Sylow subgroup of <var class="Arg">G</var> which does not permute with <var class="Arg">H</var>. We say that a subgroup <span class="SimpleMath">\(H\)</span> of a group <span class="SimpleMath">\(G\)</span> is S-permutable in <span class="SimpleMath">\(G\)</span> if <span class="SimpleMath">\(H\)</span> permutes with all Sylow subgroups of <span class="SimpleMath">\(G\)</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SymmetricGroup(4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2)(3,4)]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">OneSylowSubgroupNotPermutingWith(g,a);</span>
Group([ (2,4,3) ])
</pre></div>

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

<h5>3.2-8 IsSNPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSNPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsSNPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if <var class="Arg">H</var> permutes with all system normalisers of <var class="Arg">G</var>, and <code class="keyw">false</code> otherwise. Here <var class="Arg">G</var> must be a soluble group and <var class="Arg">H</var> must be a subgroup of <var class="Arg">G</var>. If the function is applied to an insoluble group, it gives an error.</p>

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

<h5>3.2-9 OneSystemNormaliserNotPermutingWith</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSystemNormaliserNotPermutingWith</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSystemNormaliserNotPermutingWithInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Here <var class="Arg">G</var> must be a soluble group and <var class="Arg">H</var> must be a subgroup of <var class="Arg">G</var>. If <var class="Arg">H</var> permutes with all system normalisers of <var class="Arg">G</var>, then this operation returns <code class="keyw">fail</code>. Otherwise, it returns a system normaliser <span class="SimpleMath">\(D\)</span> of <span class="SimpleMath">\(G\)</span> such that <span class="SimpleMath">\(H\)</span> does not permute with <span class="SimpleMath">\(D\)</span>. If the group <var class="Arg">G</var> is not soluble, then it gives an error.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=Group((1,2,3),(4,5,6),(1,2));</span>
Group([ (1,2,3), (4,5,6), (1,2) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2,3)(4,5,6)]);</span>
Group([ (1,2,3)(4,5,6) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSNPermutable(g,a);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSPermutable(g,a);</span>
false
</pre></div>

<p>The next functions are not particular cases of <code class="func">IsFPermutable</code> (<a href="chap3_mj.html#X865C7F81823FFA10"><span class="RefLink">3.2-4</span></a>) or <code class="func">OneFSubgroupNotPermutingWith</code> (<a href="chap3_mj.html#X826D28757824F83E"><span class="RefLink">3.2-5</span></a>), but we include them in the package because every subgroup permuting with all its conjugates is subnormal (see <a href="chapBib_mj.html#biBFoguel97">[Fog97]</a>).</p>

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

<h5>3.2-10 IsConjugatePermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsConjugatePermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsConjugatePermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation takes the value <code class="keyw">true</code> if <var class="Arg">H</var> permutes with all its conjugates, and the value <code class="keyw">false</code> otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SymmetricGroup(4);</span>
Sym( [ 1 .. 4 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[(1,2)(3,4)]);</span>
Group([ (1,2)(3,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPermutable(g,a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsConjugatePermutable(g,a);</span>
true
</pre></div>

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

<h5>3.2-11 OneConjugateSubgroupNotPermutingWith</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneConjugateSubgroupNotPermutingWith</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneConjugateSubgroupNotPermutingWithInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This operation finds a conjugate subgroup of <var class="Arg">H</var> which does not permute with <var class="Arg">H</var> if such a subgroup exists. If <var class="Arg">H</var> permutes with all its conjugates, then this operation returns <code class="keyw">fail</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SmallGroup(16,7);</span>
<pc group of size 16 with 4 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">h:=Subgroup(g,[g.1*g.4]);</span>
Group([ f1*f4 ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsConjugatePermutable(g,h);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">OneConjugateSubgroupNotPermutingWith(g,h);</span>
Group([ f1*f3 ])
</pre></div>

<p>Next we introduce some subgroup embedding functions related to permutability which have proved to be useful in some characterisations of soluble T-groups, PT-groups, and PST-groups. The "One" functions return a value which proves that the corresponding subgroup embedding property is false.</p>

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

<h5>3.2-12 IsWeaklySPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWeaklySPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWeaklySPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>The value returned by this operation is <code class="keyw">true</code> when <var class="Arg">H</var> is a <em>weakly S-permutable</em> subgroup of <var class="Arg">G</var>, that is, <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span> implies that <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>, and <code class="keyw">false</code> otherwise.</p>

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

<h5>3.2-13 OneElementShowingNotWeaklySPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneElementShowingNotWeaklySPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneElementShowingNotWeaklySPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>If <var class="Arg">H</var> is a weakly S-permutable subgroup of <var class="Arg">G</var>, then this operation returns <code class="keyw">fail</code>. Otherwise, the value returned by this operation is an element <span class="SimpleMath">\(g \in G\)</span> such that <var class="Arg">H</var> is S-permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span>, but <span class="SimpleMath">\(H\)</span> is not S-permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>. A subgroup <span class="SimpleMath">\(H\)</span> of a group <span class="SimpleMath">\(G\)</span> is said to be weakly S-permutable if <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span> implies that <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>.</p>

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

<h5>3.2-14 IsWeaklyPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWeaklyPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWeaklyPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if <var class="Arg">H</var> is weakly permutable in <var class="Arg">G</var>, and <code class="keyw">false</code> otherwise. A subgroup <span class="SimpleMath">\(H\)</span> of <span class="SimpleMath">\(G\)</span> is <em>weakly permutable</em> if the fact that <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span>, implies that <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>.</p>

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

<h5>3.2-15 OneElementShowingNotWeaklyPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneElementShowingNotWeaklyPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneElementShowingNotWeaklyPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>If <var class="Arg">H</var> is a weakly permutable subgroup of <var class="Arg">G</var>, then this operation returns <code class="keyw">fail</code>. Otherwise, the value returned by this operation is an element <span class="SimpleMath">\(g \in G\)</span> such that <var class="Arg">H</var> is permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span>, but <span class="SimpleMath">\(H\)</span> is not permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>. A subgroup <span class="SimpleMath">\(H\)</span> of a group <span class="SimpleMath">\(G\)</span> is said to be <em>weakly permutable</em> if the fact that <span class="SimpleMath">\(H\)</span> is permutable in <span class="SimpleMath">\(\langle H, H^g \rangle\)</span> implies that <span class="SimpleMath">\(H\)</span> is permutable in <span class="SimpleMath">\(\langle H, g \rangle\)</span>.</p>

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

<h5>3.2-16 IsWeaklyNormal</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWeaklyNormal</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWeaklyNormalInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if <var class="Arg">H</var> is weakly normal in <var class="Arg">G</var>, and <code class="keyw">false</code> otherwise. A subgroup <span class="SimpleMath">\(H\)</span> of <span class="SimpleMath">\(G\)</span> is <em>weakly normal</em> whenever if <span class="SimpleMath">\(H^g \leq {\rm N}_G(H)\)</span>, then <span class="SimpleMath">\(g \in {\rm N}_G(H)\)</span>.</p>

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

<h5>3.2-17 OneElementShowingNotWeaklyNormal</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneElementShowingNotWeaklyNormal</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneElementShowingNotWeaklyNormalInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>If <var class="Arg">H</var> is a weakly normal subgroup of <var class="Arg">G</var>, then this function returns <code class="keyw">fail</code>. Otherwise, the value returned by this operation is an element <span class="SimpleMath">\(g\)</span> such that <span class="SimpleMath">\(H^g\leq {\rm N}_G(H)\)</span> is a subgroup of <span class="SimpleMath">\({\rm N}_G(H)\)</span> but <span class="SimpleMath">\(g \notin{\rm N}_G(H)\)</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=DihedralGroup(8);</span>
<pc group of size 8 with 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[g.1]);</span>
Group([ f1 ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsWeaklySPermutable(g,a);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsWeaklyPermutable(g,a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">x:=OneElementShowingNotWeaklyPermutable(g,a);</span>
f2
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSubgroup(Normalizer(g,a),ConjugateSubgroup(a,x));</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">x in Normalizer(g,a);</span>
false
</pre></div>

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

<h5>3.2-18 IsWithSubnormalizerCondition</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWithSubnormalizerCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSubnormalizerConditionInParent</code>( <var class="Arg">H</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">‣ IsWithSubnormaliserCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSubnormaliserConditionInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if the subgroup <span class="SimpleMath">\(H\)</span> satisfies the subnormaliser condition in <span class="SimpleMath">\(G\)</span>, and <code class="keyw">false</code> otherwise.</p>

<p>A subgroup <span class="SimpleMath">\(H\)</span> is said to <em>satisfy the subnormaliser condition</em> in <span class="SimpleMath">\(G\)</span> if the condition that <span class="SimpleMath">\(H\)</span> is subnormal in a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> implies that <span class="SimpleMath">\(H\)</span> is normal in <span class="SimpleMath">\(K\)</span>.</p>

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

<h5>3.2-19 OneSubgroupInWhichSubnormalNotNormal</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSubgroupInWhichSubnormalNotNormal</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSubgroupInWhichSubnormalNotNormalInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This function returns a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> such that <span class="SimpleMath">\(H\)</span> is subnormal in <span class="SimpleMath">\(K\)</span> and <span class="SimpleMath">\(H\)</span> is not normal in <span class="SimpleMath">\(K\)</span>, if this subgroup exists; otherwise, it returns <code class="keyw">fail</code>.</p>

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

<h5>3.2-20 IsWithSubpermutizerCondition</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWithSubpermutizerCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSubpermutizerConditionInParent</code>( <var class="Arg">H</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">‣ IsWithSubpermutiserCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSubpermutiserConditionInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if the subgroup <span class="SimpleMath">\(H\)</span> satisfies the subpermutiser condition in <span class="SimpleMath">\(G\)</span>, and <code class="keyw">false</code> otherwise.</p>

<p>A subgroup <span class="SimpleMath">\(H\)</span> is said to <em>satisfy the subpermutiser condition</em> in <span class="SimpleMath">\(G\)</span> if the condition that <span class="SimpleMath">\(H\)</span> is subnormal in a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> implies that <span class="SimpleMath">\(H\)</span> is permutable in <span class="SimpleMath">\(K\)</span>.</p>

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

<h5>3.2-21 OneSubgroupInWhichSubnormalNotPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSubgroupInWhichSubnormalNotPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSubgroupInWhichSubnormalNotPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This function returns a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> such that <span class="SimpleMath">\(H\)</span> is subnormal in <span class="SimpleMath">\(K\)</span> and <span class="SimpleMath">\(H\)</span> is not permutable in <span class="SimpleMath">\(K\)</span> if this subgroup exists; otherwise it returns <code class="keyw">fail</code>.</p>

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

<h5>3.2-22 IsWithSSubpermutizerCondition</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWithSSubpermutizerCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSSubpermutizerConditionInParent</code>( <var class="Arg">H</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">‣ IsWithSSubpermutiserCondition</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ IsWithSSubpermutiserConditionInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>This operation returns <code class="keyw">true</code> if the subgroup <span class="SimpleMath">\(H\)</span> satisfies the S-subpermutiser condition in <span class="SimpleMath">\(G\)</span>, and <code class="keyw">false</code> otherwise.</p>

<p>A subgroup <span class="SimpleMath">\(H\)</span> is said to <em>satisfy the S-subpermutiser condition</em> in <span class="SimpleMath">\(G\)</span> if the condition that <span class="SimpleMath">\(H\)</span> is subnormal in a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> implies that <span class="SimpleMath">\(H\)</span> is S-permutable in <span class="SimpleMath">\(K\)</span>.</p>

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

<h5>3.2-23 OneSubgroupInWhichSubnormalNotSPermutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OneSubgroupInWhichSubnormalNotSPermutable</code>( <var class="Arg">G</var>, <var class="Arg">H</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">‣ OneSubgroupInWhichSubnormalNotSPermutableInParent</code>( <var class="Arg">H</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This function returns a subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(G\)</span> such that <span class="SimpleMath">\(H\)</span> is subnormal in <span class="SimpleMath">\(K\)</span> and <span class="SimpleMath">\(H\)</span> is not S-permutable in <span class="SimpleMath">\(K\)</span> if such a subgroup exists; otherwise it returns <code class="keyw">fail</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:=SmallGroup(324,160);</span>
<pc group of size 324 with 6 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:=Subgroup(g,[g.3,g.5]);</span>
Group([ f3, f5 ])
<span class="GAPprompt">gap></span> <span class="GAPinput">IsWithSubnormalizerCondition(g,a);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsWeaklyNormal(g,a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsWeaklySPermutable(g,a);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">x:=OneElementShowingNotWeaklyNormal(g,a);</span>
f1
<span class="GAPprompt">gap></span> <span class="GAPinput">ConjugateSubgroup(a,x)=a;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSubset(Normalizer(g,a),ConjugateSubgroup(a,x));</span>
true
</pre></div>


<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap2_mj.html">[Previous Chapter]</a>    <a href="chap4_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="chapBib_mj.html">Bib</a>  <a href="chapInd_mj.html">Ind</a>  </div>

<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>

100%


¤ Dauer der Verarbeitung: 0.25 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.