Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/GAP/pkg/patternclass/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 30.7.2024 mit Größe 25 kB image not shown  

Quelle  chap8.html   Sprache: HTML

 
 products/sources/formale Sprachen/GAP/pkg/patternclass/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 (PatternClass) - Chapter 8: Properties of Permutations </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="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="X87A0210C7BCFBA99" name="X87A0210C7BCFBA99"></a></p>
<div class="ChapSects"><a href="chap8.html#X87A0210C7BCFBA99">8 <span class="Heading">Properties of Permutations </span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X85B2BC647868C9C4">8.1 <span class="Heading"> Intervals in Permutations </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X78D28CDF87CF35E4">8.1-1 IsInterval</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X7B82346E7E2C330C">8.2 <span class="Heading"> Simplicity </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7ECAD3E4818C589D">8.2-1 IsSimplePerm</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X7A6836EC7E9CE3D8">8.3 <span class="Heading"> Point Deletion in Simple Permutations </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X877D962E7FBFB47E">8.3-1 OnePointDelete</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X787F62137E709A2C">8.3-2 TwoPointDelete</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X8696CBE580B27FE5">8.3-3 PointDeletion</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X87EB37927F40662B">8.4 <span class="Heading"> Block-Decomposition </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X8279728778F1F299">8.4-1 Inflation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7C07BE268055FEBD">8.4-2 BlockDecomposition</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X8278DD0F7F128656">8.5 <span class="Heading"> Plus-Decomposability </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X80CBC61C851B1D20">8.5-1 IsPlusDecomposable</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X801EF8FB79F18910">8.6 <span class="Heading"> Minus-Decomposability </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X87A6DF207B27C676">8.6-1 IsMinusDecomposable</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8.html#X7B7C59AA84E3425C">8.7 <span class="Heading"> Sums of Permutations </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7E0DD72F7F6E0440">8.7-1 PermDirectSum</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap8.html#X7CE8A32A78A4A6BB">8.7-2 PermSkewSum</a></span>
</div></div>
</div>

<h3>8 <span class="Heading">Properties of Permutations </span></h3>

<p>It has been of interest to the authors to compute different properties of permutations. Inspections include plus- and minus-decomposable permutations, block-decompositions of permutations, as well as the computation of the direct and skew sum of permutations. First a couple of definitions on which some of the properties are based on:</p>

<p>An interval of a permutation <span class="SimpleMath">σ</span> is a set of contiguous values which in <span class="SimpleMath">σ</span> have consecutive indices.</p>

<p>A permutation of length <span class="SimpleMath">n</span> is called simple if it only contains the intervals of length 0, 1 and <span class="SimpleMath">n</span>.</p>

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

<h4>8.1 <span class="Heading"> Intervals in Permutations </span></h4>

<p>As mentioned above, an interval of a permutation <span class="SimpleMath">σ</span> is a set of contiguous numbers which in <span class="SimpleMath">σ</span> have consecutive indices. For example in <span class="SimpleMath">σ = 4 6 8 7 1 5 2 3</span> the following is an interval <span class="SimpleMath">σ(2)σ(3)σ(4)=6 8 7</span> whereas <span class="SimpleMath">σ(4)σ(5)σ(6)=7 1 5</span> is not.</p>

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

<h5>8.1-1 IsInterval</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsInterval</code>( <var class="Arg">list</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code>, if <code class="code">list</code> is an interval.</p>

<p>IsInterval takes in any list with unique elements, which can be ordered lexicographically and checkes whether it is an interval.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsInterval([3,6,9,2]);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsInterval([2,6,5,3,4]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput"> </span></pre></div>

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

<h4>8.2 <span class="Heading"> Simplicity </span></h4>

<p>As mentioned above a permutation is said to be simple if it only contains intervals of length 0, 1 or the length of the permutation.</p>

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

<h5>8.2-1 IsSimplePerm</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSimplePerm</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> if <code class="code">perm</code> is simple.</p>

<p>To check whether <code class="code">perm</code> (length of <code class="code">perm</code> = <span class="SimpleMath">n</span>) is a simple permutation <code class="code">IsSimplePerm</code> uses the basic algorithm proposed by Uno and Yagiura in <a href="chapBib.html#biBFAlgsEnumAllCommIntsof2Perms">[UY00]</a> to compare the <code class="code">perm</code> against the identity permutation of the same length.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSimplePerm([2,3,4,5,1,1,1,1]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSimplePerm([2,4,6,8,1,3,5,7]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSimplePerm([3,2,8,6,7,1,5,4]);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h4>8.3 <span class="Heading"> Point Deletion in Simple Permutations </span></h4>

<p>In <a href="chapBib.html#biBSimpPermsPoset">[PR12]</a> it is shown how one can get chains of permutations by starting with a simple permutation and then removing either a single point or two points and the resulting permutation would still be simple. We have applied this theory to create functions such that the set of simple permutations of shorter length, by one deletion, can be found.</p>

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

<h5>8.3-1 OnePointDelete</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ OnePointDelete</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A list of simple permutations with one point less than <code class="code">perm</code>.</p>

<p><code class="code">OnePointDelete</code> removes single points in the simple permutation and returns a list of the resulting simple permutations, in their rank encoding.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">OnePointDelete([5,2,3,1,2,1]);</span>
[ [ 2, 3, 1, 2, 1 ], [ 4, 1, 2, 2, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">OnePointDelete([5,2,4,1,6,3]);</span>
[ [ 2, 3, 1, 2, 1 ], [ 4, 1, 2, 2, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h5>8.3-2 TwoPointDelete</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TwoPointDelete</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: The exceptional permutation with two point less than <code class="code">perm</code>.</p>

<p><code class="code">TwoPointDelete</code> removes two points of the input exceptional permutation and returns the list of the unique resulting permutation, in its rank encoding.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">TwoPointDelete([2,4,6,8,1,3,5,7]);</span>
[ [ 2, 3, 4, 1, 1, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">TwoPointDelete([2,3,4,5,1,1,1,1]);</span>
[ [ 2, 3, 4, 1, 1, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h5>8.3-3 PointDeletion</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PointDeletion</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A list of simple permutations with of shorter length than <code class="code">perm</code>.</p>

<p><code class="code">PointDeletion</code> takes any simple permutation does not matter whether exceptional or not and removes the right number of points.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">PointDeletion([5,2,3,1,2,1]);</span>
[ [ 2, 3, 1, 2, 1 ], [ 4, 1, 2, 2, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PointDeletion([5,2,4,1,6,3]);</span>
[ [ 2, 3, 1, 2, 1 ], [ 4, 1, 2, 2, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PointDeletion([2,4,6,8,1,3,5,7]);</span>
[ [ 2, 3, 4, 1, 1, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PointDeletion([2,3,4,5,1,1,1,1]);</span>
[ [ 2, 3, 4, 1, 1, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h4>8.4 <span class="Heading"> Block-Decomposition </span></h4>

<p>Given a permutation <span class="SimpleMath">π</span> of length <span class="SimpleMath">m</span> and nonempty permutations <span class="SimpleMath">α_1,...,α_m</span> the inflation of <span class="SimpleMath">π</span> by <span class="SimpleMath">α_1,...,α_m</span>, written as <span class="SimpleMath">π[α_1,...,α_m]</span>, is the permutation obtained by replacing each entry <span class="SimpleMath">π(i)</span> by an interval that is order isomorphic to <span class="SimpleMath">α_i</span> <a href="chapBib.html#biBSimpSurv">[Bri08]</a>. Conversely a block-decomposition of <span class="SimpleMath">σ</span> is any expression of <span class="SimpleMath">σ</span> as an inflation <span class="SimpleMath">σ=π[α_1,...,α_m]</span>. The block decomposition of a permutation is unique if and only if <span class="SimpleMath">σ,π,α_1,...,α_n</span> all are in the same pattern class and <span class="SimpleMath">π</span> is simple and <span class="SimpleMath">π≠ 1 2, 2 1</span> <a href="chapBib.html#biBSimpAndPRestrPerms">[AA05]</a>.</p>

<p>For example the inflation of <span class="SimpleMath">25413[21,1,1,1,2413]=3 2 8 9 1 5 7 4 6</span>, written in <strong class="pkg">GAP</strong> this is <code class="code">[[2,5,4,1,3],[2,1],[1],[1],[1],[2,4,1,3]]</code>. This decomposition of <span class="SimpleMath">3 2 8 9 1 5 7 4 6</span> is not unique. The unique block-decomposition, as described above, for <span class="SimpleMath">3 2 8 9 1 5 7 4 6=2413[21,12,1,2413]</span> or in <strong class="pkg">GAP</strong> notation <code class="code">[3,2,8,9,1,5,7,4,6]=[[2,4,1,3],[2,1],[1,2],[1],[2,4,1,3]]</code>.</p>

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

<h5>8.4-1 Inflation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Inflation</code>( <var class="Arg">list_of_perms</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A permutation that represents the inflation of the list of permutations, taking the first permutation to be <span class="SimpleMath">π</span>, as described in the definition of inflation.</p>

<p>Inflation takes the list of permutations that stand for a box decomposition of a permutation, and calculates that permutation by replacing each entry <span class="SimpleMath">i</span> in the first permutation by an interval order isomorphic to the permutation in index <span class="SimpleMath">i+1</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Inflation([[3,2,1],[1],[1,2],[1,2,3]]);</span>
[ 6, 4, 5, 1, 2, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Inflation([[1,2],[1],[4,2,1,3]]);</span>
[ 1, 5, 3, 2, 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Inflation([[2,4,1,3],[2,1],[3,1,2],[1],[2,4,1,3]]);</span>
[ 3, 2, 10, 8, 9, 1, 5, 7, 4, 6 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h5>8.4-2 BlockDecomposition</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BlockDecomposition</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A list of permutations, representing the block-decomposition of <code class="code">perm</code>. In the list the first permutation is <span class="SimpleMath">π</span>, as described in the definiton of block-decomposition above.</p>

<p><code class="code">BlockDecomposition</code> takes a plus- and minus-indecomposable permutation and decomposes it into its maximal maximal intervals, which are preceded by the simple permutation that represents the positions of the intervals. If a plus- or minus-decomposable permutation is input, then the decomposition will not be the unique decomposition, by the definition of plus- or minus- decomposable permutations, see below.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">BlockDecomposition([3,2,10,8,9,1,5,7,4,6]);</span>
[ [ 2, 4, 1, 3 ], [ 2, 1 ], [ 3, 1, 2 ], [ 1 ], [ 2, 4, 1, 3 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">BlockDecomposition([1,2,3,4,5]);                      </span>
[ [ 1, 2 ], [ 1, 2, 3, 4 ], [ 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">BlockDecomposition([5,4,3,2,1]);</span>
[ [ 2, 1 ], [ 4, 3, 2, 1 ], [ 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"> </span></pre></div>

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

<h4>8.5 <span class="Heading"> Plus-Decomposability </span></h4>

<p>A permutation <span class="SimpleMath">σ</span> is said to be plus-decomposable if it can be written uniquely in the following form,</p>

<p class="pcenter">σ = 12 [α_1,α_2]</p>

<p>where <span class="SimpleMath">α_1</span> is not plus-decomposable.</p>

<p>The subset of a rational class, containing all permutations that are plus-decomposable and in the class, has been found to be also rational under the rank encoding.</p>

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

<h5>8.5-1 IsPlusDecomposable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPlusDecomposable</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> if <code class="code">perm</code> is plus-decomposable.</p>

<p>To check whether <code class="code">perm</code> is a plus-decomposable permutation <code class="code">IsPlusDecomposable</code> uses the fact that there has to be an interval <span class="SimpleMath">1..x</span> where <span class="SimpleMath">x <n</span> (<span class="SimpleMath">n</span> = length of the <code class="code">perm</code>) in the rank encoded permutation that is a valid rank encoding.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPlusDecomposable([3,3,2,3,2,2,1,1]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPlusDecomposable([3,4,2,6,5,7,1,8]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPlusDecomposable([3,2,8,6,7,1,5,4]);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h4>8.6 <span class="Heading"> Minus-Decomposability </span></h4>

<p>Minus-decomposability is essentially the same as plus-decomposability, the difference is that if a permutation <span class="SimpleMath">σ</span> is minus-decomposable, it can be written uniquely in the following form,</p>

<p class="pcenter">σ = 21 [α_1,α_2]</p>

<p>where <span class="SimpleMath">α_1</span> is not minus-decomposable.</p>

<p>Here also, the subset of a rational class, containing all permutations that are minus-decomposable and in the class, has been found to be rational under the rank encoding.</p>

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

<h5>8.6-1 IsMinusDecomposable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsMinusDecomposable</code>( <var class="Arg">perm</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: <code class="code">true</code> if <code class="code">perm</code> is minus-decomposable.</p>

<p>To check whether <code class="code">perm</code> (length of <code class="code">perm</code> = <span class="SimpleMath">n</span>) is a minus-decomposable permutation <code class="code">IsMinusDecomposable</code> uses the fact that the first <span class="SimpleMath">n-x</span>, where <span class="SimpleMath">x<n</span>, letters in the rank encoding of <code class="code">perm</code> have to be <span class="SimpleMath">>x</span> and that the letters from position <span class="SimpleMath">x+1</span> until the last one have to be <span class="SimpleMath">≤ x</span>.</p>


<div class="example"><pre> 
<span class="GAPprompt">gap></span> <span class="GAPinput">IsMinusDecomposable([3,3,3,3,3,3,2,1]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsMinusDecomposable([3,4,5,6,7,8,2,1]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsMinusDecomposable([3,2,8,6,7,1,5,4]);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h4>8.7 <span class="Heading"> Sums of Permutations </span></h4>

<p>The direct sum of two permutations <span class="SimpleMath">σ=σ_1 ... σ_k</span> and <span class="SimpleMath">τ=τ_1...τ_l</span> is defined as,</p>

<p class="pcenter">σ ⊕ τ = σ_1 σ_2...σ_k τ_1+k τ_2+k...τ_l+k .</p>

<p>In a similar fashion the skew sum of <span class="SimpleMath">σ, τ</span> is</p>

<p class="pcenter">σ ⊖ τ = σ_1+l σ_2+l...σ_k+l τ_1 τ_2...τ_l .</p>

<p>The calculation of the direct and skew sums of permutations using the rank encoding is also straight forward and is used in the functions described below. The direct sum of two permutations <span class="SimpleMath">σ,τ</span> represented as their rank encoded sequences is the permutation which has the rank encoding that is the concatention of the rank encoding of <span class="SimpleMath">σ</span> and <span class="SimpleMath">τ</span>. The skew sum of two permutations <span class="SimpleMath">σ,τ</span> encoded by the rank encoding is the concatenation of the rank encodings of <span class="SimpleMath">σ</span> and <span class="SimpleMath">τ</span> where in the sequence corresponding to <span class="SimpleMath">σ</span> under the rank encoding each element has been increased by <span class="SimpleMath">l</span>, with <span class="SimpleMath">l</span> being the length of <span class="SimpleMath">τ</span>.</p>

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

<h5>8.7-1 PermDirectSum</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PermDirectSum</code>( <var class="Arg">perm1</var>, <var class="Arg">perm2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A permutation resulting from <code class="code">perm1</code> <span class="SimpleMath">⊕</span> <code class="code">perm2</code>.</p>

<p><code class="code">PermDirectSum</code> returns the permutation corresponding to <code class="code">perm1</code> <span class="SimpleMath">⊕</span> <code class="code">perm2</code> if <code class="code">perm1</code> and <code class="code">perm2</code> are both not rank encoded. If both <code class="code">perm1</code> and <code class="code">perm2</code> are rank encoded, then <code class="code">PermDirectSum</code> returns a rank encoded sequence.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermDirectSum([2,4,1,3],[2,5,4,1,3]);</span>
[ 2, 4, 1, 3, 6, 9, 8, 5, 7 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermDirectSum([2,3,1,1],[2,4,3,1,1]);</span>
[ 2, 3, 1, 1, 2, 4, 3, 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>

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

<h5>8.7-2 PermSkewSum</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PermSkewSum</code>( <var class="Arg">perm1</var>, <var class="Arg">perm2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: A permutation resulting from <code class="code">perm1</code> <span class="SimpleMath">⊖</span> <code class="code">perm2</code>.</p>

<p><code class="code">PermSkewSum</code> returns the permutation corresponding to <code class="code">perm1</code> <span class="SimpleMath">⊖</span> <code class="code">perm2</code> if <code class="code">perm1</code> and <code class="code">perm2</code> are both not rank encoded. If both <code class="code">perm1</code> and <code class="code">perm2</code> are rank encoded, then <code class="code">PermSkewSum</code> returns a rank encoded sequence.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermSkewSum([2,4,1,3],[2,5,4,1,3]);</span>
[ 7, 9, 6, 8, 2, 5, 4, 1, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermSkewSum([2,3,1,1],[2,4,3,1,1]);</span>
[ 7, 8, 6, 6, 2, 4, 3, 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"></span></pre></div>


<div class="chlinkprevnextbot"> <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>


<div class="chlinkbot"><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="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

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

100%


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