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

SSL chap2_mj.html   Sprache: HTML

 
 products/Sources/formale Sprachen/GAP/pkg/difsets/doc/chap2_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 (DifSets) - Chapter 2: Package Contents</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="chap2"  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>  </div>

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

<p id="mathjaxlink" class="pcenter"><a href="chap2.html">[MathJax off]</a></p>
<p><a id="X7F5ED06E833C164E" name="X7F5ED06E833C164E"></a></p>
<div class="ChapSects"><a href="chap2_mj.html#X7F5ED06E833C164E">2 <span class="Heading">Package Contents</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X7D3DC4ED855DC13C">2.1 <span class="Heading">The Main Functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X83297D2B85F9E074">2.1-1 DifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7B5B1D8D86014468">2.1-2 DifferenceSums</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X80CEEB697EA8D462">2.2 <span class="Heading">Sizes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7DEB0B3B7E1FFF0B">2.2-1 PossibleDifferenceSetSizes</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7E7D360080D99FE7">2.2-2 DifferenceSetsOfSizeK</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7C01E15C83213BFB">2.2-3 DifferenceSumsOfSizeK</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X8735819681ED05EB">2.3 <span class="Heading">Refining</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X85A8B29085DC0CEB">2.3-1 RefiningSeries</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X78CDE421817B50EE">2.3-2 AllRefinedDifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X8527B7D687C04A1C">2.3-3 NrAllRefinedSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7E1012C07FB328B4">2.3-4 SomeRefinedDifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7ADBC8A6825A1FE4">2.3-5 NrSomeRefinedSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X80BF8487824FA6B1">2.3-6 AllRefinedDifferenceSums</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7D55D770828A6158">2.3-7 NrAllRefinedSums</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X866272667D6032BA">2.3-8 SomeRefinedDifferenceSums</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X82A9A80085A9F514">2.3-9 NrSomeRefinedSums</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X7DD5BE4E84C95B38">2.4 <span class="Heading">Equivalence</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7E4BCB8482E4AE34">2.4-1 EquivalentFreeListOfDifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X8380F5D37E2D411B">2.4-2 TranslateFreeListOfDifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X8639AB227B0CF9F3">2.4-3 EquivalentFreeListOfDifferenceSums</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7BF295758033DC3B">2.4-4 TranslateFreeListOfDifferenceSums</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X857A641A7C86EFA3">2.4-5 SmallestEquivalentDifferenceSet</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X8741BBF4811F942A">2.4-6 SmallestEquivalentFreeListOfDifferenceSets</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X7DE7E7187BE24368">2.5 <span class="Heading">Testing</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X8545AC1D7D42A84A">2.5-1 IsDifferenceSet</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X87AF37B47808830E">2.5-2 IsDifferenceSum</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7AE5A8607ADD2F1C">2.5-3 IsEquivalentDifferenceSet</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X780F33C98032EAA2">2.5-4 IsEquivalentDifferenceSum</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap2_mj.html#X83340C888396D9BF">2.6 <span class="Heading">Loading Results</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X7B41B3107A96949D">2.6-1 CanLoadDifferenceSets</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap2_mj.html#X848925877C3C891F">2.6-2 LoadDifferenceSets</a></span>
</div></div>
</div>

<h3>2 <span class="Heading">Package Contents</span></h3>

<p>The <strong class="pkg">DifSets</strong> Package consists of a collection of functions implementing the main algorithm, and some additional functions for experimentation and testing. Several functions not appearing in this documentation are used internally for certain subtasks. See the code itself for details.</p>

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

<h4>2.1 <span class="Heading">The Main Functions</span></h4>

<p>The purpose of this package is to provide a function that efficiently enumerates all difference sets up to equivalence in a given group. Similarly, we can also enumerate all difference sums up to equivalence. The following are these functions. Their components are described in further sections.</p>

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

<h5>2.1-1 DifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DifferenceSets</code>( <var class="Arg">G</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sets up to equivalence in the group <var class="Arg">G</var>. Only the smaller of each complementary pair of difference sets is included, and one-element difference sets are ignored.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 9);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DifferenceSets(G);</span>
[ [ 1, 2, 3, 4, 7, 10 ], [ 1, 2, 3, 4, 8, 9 ] ]
</pre></div>

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

<h5>2.1-2 DifferenceSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DifferenceSums</code>( <var class="Arg">G</var>, <var class="Arg">N</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sums up to equivalence in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var>. Only the smaller of each complementary pair of difference sums is included, and difference sums of size 1 are ignored.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 8);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DifferenceSums(G, N);</span>
[ [ 3, 1, 1, 1 ], [ 2, 2, 2, 0 ] ]
</pre></div>

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

<h4>2.2 <span class="Heading">Sizes</span></h4>

<p>The first step of the algorithm is to determine what possible sizes of difference sets and sums the group can contain. Each size is then handled individually since different size sets or sums will never be equivalent.</p>

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

<h5>2.2-1 PossibleDifferenceSetSizes</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PossibleDifferenceSetSizes</code>( <var class="Arg">G</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of the possible sizes of difference sets in group <var class="Arg">G</var>. Only the smaller of any pair of complementary sizes is returned, and the trivial size 1 is never included. Current implementation simply returns all values of k such that lambda = k(k-1)/(v-1) is an integer, where v is the order of <var class="Arg">G</var>, and the resulting parameters v, k, lambda pass the Bruck-Ryser-Chowla test.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(31, 1);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PossibleDifferenceSetSizes(G);</span>
[ 6, 10, 15 ]
</pre></div>

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

<h5>2.2-2 DifferenceSetsOfSizeK</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DifferenceSetsOfSizeK</code>( <var class="Arg">G</var>, <var class="Arg">k</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sets up to equivalence in the group <var class="Arg">G</var> that have size <var class="Arg">k</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 9);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DifferenceSetsOfSizeK(G, 1);</span>
[ [ 1 ] ]
</pre></div>

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

<h5>2.2-3 DifferenceSumsOfSizeK</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DifferenceSumsOfSizeK</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">k</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sums up to equivalence in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var> that have size <var class="Arg">k</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 8);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DifferenceSumsOfSizeK(G, N, 1);</span>
[ [ 1, 0, 0, 0 ] ]
</pre></div>

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

<h4>2.3 <span class="Heading">Refining</span></h4>

<p>Refining refers to the process of enumerating the preimages of a difference sum and filtering out preimages that are not themselves difference sets or sums. For each size <span class="SimpleMath">\(k\)</span> we know that the only difference sum of size <span class="SimpleMath">\(k\)</span> in <span class="SimpleMath">\(G\)</span> mod <span class="SimpleMath">\(G\)</span> is <code class="code">[k]</code>. Starting with this difference sum, we successivly refine through a series of quotients of <span class="SimpleMath">\(G\)</span> to eventually reach the desired sums or sets. In the algorithm, we use <code class="func">SomeRefinedDifferenceSets</code> (<a href="chap2_mj.html#X7E1012C07FB328B4"><span class="RefLink">2.3-4</span></a>) and <code class="func">SomeRefinedDifferenceSums</code> (<a href="chap2_mj.html#X866272667D6032BA"><span class="RefLink">2.3-8</span></a>) rather than <code class="func">AllRefinedDifferenceSets</code> (<a href="chap2_mj.html#X78CDE421817B50EE"><span class="RefLink">2.3-2</span></a>) and <code class="func">AllRefinedDifferenceSums</code> (<a href="chap2_mj.html#X80BF8487824FA6B1"><span class="RefLink">2.3-6</span></a>) since the former are faster and we only need at least one representative of each equivalence class since additional equivalent sums or sets will just be removed anyway.</p>

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

<h5>2.3-1 RefiningSeries</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RefiningSeries</code>( <var class="Arg">G</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a normal series for group <var class="Arg">G</var>. Current implementation produces a chief series through a nontrivial normal subgroup of smallest possible size in <var class="Arg">G</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(8, 3);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List(RefiningSeries(G), N -> Size(N));</span>
[ 8, 4, 2, 1 ]
</pre></div>

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

<h5>2.3-2 AllRefinedDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllRefinedDifferenceSets</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sets that are preimages of difference sums contained in the list <var class="Arg">difsums</var> of difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var>. Difference sums in <var class="Arg">difsums</var> are all assumed to be the same size.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AllRefinedDifferenceSets(G, N, [[3,1,1,1], [2,2,2,0]]);</span>
[ [ 1, 3, 2, 8, 4, 15 ], [ 1, 3, 2, 8, 9, 11 ], [ 1, 3, 2, 13, 4, 11 ], 
  [ 1, 3, 2, 13, 9, 15 ], [ 1, 3, 6, 8, 4, 11 ], [ 1, 3, 6, 8, 9, 15 ], 
  [ 1, 3, 6, 13, 4, 15 ], [ 1, 3, 6, 13, 9, 11 ], [ 1, 5, 2, 6, 4, 15 ], 
  [ 1, 5, 2, 6, 9, 11 ], [ 1, 5, 2, 13, 4, 9 ], [ 1, 5, 2, 13, 11, 15 ], 
  [ 1, 5, 6, 8, 4, 9 ], [ 1, 5, 6, 8, 11, 15 ], [ 1, 5, 8, 13, 4, 15 ], 
  [ 1, 5, 8, 13, 9, 11 ], [ 1, 10, 2, 6, 4, 11 ], [ 1, 10, 2, 6, 9, 15 ], 
  [ 1, 10, 2, 8, 4, 9 ], [ 1, 10, 2, 8, 11, 15 ], [ 1, 10, 6, 13, 4, 9 ], 
  [ 1, 10, 6, 13, 11, 15 ], [ 1, 10, 8, 13, 4, 11 ], [ 1, 10, 8, 13, 9, 15 ], 
  [ 3, 5, 2, 6, 4, 11 ], [ 3, 5, 2, 6, 9, 15 ], [ 3, 5, 2, 8, 4, 9 ], 
  [ 3, 5, 2, 8, 11, 15 ], [ 3, 5, 6, 13, 4, 9 ], [ 3, 5, 6, 13, 11, 15 ], 
  [ 3, 5, 8, 13, 4, 11 ], [ 3, 5, 8, 13, 9, 15 ], [ 3, 10, 2, 6, 4, 15 ], 
  [ 3, 10, 2, 6, 9, 11 ], [ 3, 10, 2, 13, 4, 9 ], [ 3, 10, 2, 13, 11, 15 ], 
  [ 3, 10, 6, 8, 4, 9 ], [ 3, 10, 6, 8, 11, 15 ], [ 3, 10, 8, 13, 4, 15 ], 
  [ 3, 10, 8, 13, 9, 11 ], [ 5, 10, 2, 8, 4, 15 ], [ 5, 10, 2, 8, 9, 11 ], 
  [ 5, 10, 2, 13, 4, 11 ], [ 5, 10, 2, 13, 9, 15 ], [ 5, 10, 6, 8, 4, 11 ], 
  [ 5, 10, 6, 8, 9, 15 ], [ 5, 10, 6, 13, 4, 15 ], [ 5, 10, 6, 13, 9, 11 ] ]
</pre></div>

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

<h5>2.3-3 NrAllRefinedSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NrAllRefinedSets</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the number of preimages that will need to be checked during a call to <code class="func">AllRefinedDifferenceSets</code> (<a href="chap2_mj.html#X78CDE421817B50EE"><span class="RefLink">2.3-2</span></a>) with the same arguments. This can give a rough estimate of how long the call will take to complete.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrAllRefinedSets(G, N, [[3,1,1,1], [2,2,2,0]]);</span>
472
</pre></div>

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

<h5>2.3-4 SomeRefinedDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SomeRefinedDifferenceSets</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of some difference sets that are preimages of difference sums contained in the list <var class="Arg">difsums</var> of difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var>. At least one member of each equivalence class that would appear in the set of all preimages will be returned, but all preimage difference sets may not appear. Difference sums in <var class="Arg">difsums</var> are all assumed to be the same size. Current implementation forces the choice of an identity element when possible.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SomeRefinedDifferenceSets(G, N, [[3,1,1,1], [2,2,2,0]]);</span>
[ [ 1, 3, 2, 8, 4, 15 ], [ 1, 3, 2, 8, 9, 11 ], [ 1, 3, 2, 13, 4, 11 ], 
  [ 1, 3, 2, 13, 9, 15 ], [ 1, 3, 6, 8, 4, 11 ], [ 1, 3, 6, 8, 9, 15 ], 
  [ 1, 3, 6, 13, 4, 15 ], [ 1, 3, 6, 13, 9, 11 ], [ 1, 5, 2, 6, 4, 15 ], 
  [ 1, 5, 2, 6, 9, 11 ], [ 1, 5, 2, 13, 4, 9 ], [ 1, 5, 2, 13, 11, 15 ], 
  [ 1, 5, 6, 8, 4, 9 ], [ 1, 5, 6, 8, 11, 15 ], [ 1, 5, 8, 13, 4, 15 ], 
  [ 1, 5, 8, 13, 9, 11 ], [ 1, 10, 2, 6, 4, 11 ], [ 1, 10, 2, 6, 9, 15 ], 
  [ 1, 10, 2, 8, 4, 9 ], [ 1, 10, 2, 8, 11, 15 ], [ 1, 10, 6, 13, 4, 9 ], 
  [ 1, 10, 6, 13, 11, 15 ], [ 1, 10, 8, 13, 4, 11 ], [ 1, 10, 8, 13, 9, 15 ] ] 
</pre></div>

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

<h5>2.3-5 NrSomeRefinedSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NrSomeRefinedSets</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the number of preimages that will need to be checked during a call to <code class="func">SomeRefinedDifferenceSets</code> (<a href="chap2_mj.html#X7E1012C07FB328B4"><span class="RefLink">2.3-4</span></a>) with the same arguments. This can give a rough estimate of how long the call will take to complete.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrSomeRefinedSets(G, N, [[3,1,1,1], [2,2,2,0]]);</span>
300
</pre></div>

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

<h5>2.3-6 AllRefinedDifferenceSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AllRefinedDifferenceSums</code>( <var class="Arg">G</var>, <var class="Arg">N1</var>, <var class="Arg">N2</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of all difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N2</var> that are preimages of difference sums contained in the list <var class="Arg">difsums</var> of difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N1</var>. The subgroup <var class="Arg">N2</var> must be contained in <var class="Arg">N1</var>. Difference sums in <var class="Arg">difsums</var> are all assumed to be the same size.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N1 := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N2 := Subgroup(G, [G.2]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AllRefinedDifferenceSums(G, N1, N2, [[3,1,1,1], [2,2,2,0]]);</span>
[ [ 1, 1, 0, 1, 0, 1, 2, 0 ], [ 1, 1, 2, 1, 0, 1, 0, 0 ], 
  [ 1, 0, 1, 1, 0, 2, 1, 0 ], [ 1, 2, 1, 1, 0, 0, 1, 0 ], 
  [ 0, 1, 1, 2, 0, 1, 1, 0 ], [ 2, 1, 1, 0, 0, 1, 1, 0 ] ]
</pre></div>

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

<h5>2.3-7 NrAllRefinedSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NrAllRefinedSums</code>( <var class="Arg">G</var>, <var class="Arg">N1</var>, <var class="Arg">N2</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the number of preimages that will need to be checked during a call to <code class="func">AllRefinedDifferenceSums</code> (<a href="chap2_mj.html#X80BF8487824FA6B1"><span class="RefLink">2.3-6</span></a>) with the same arguments. This can give a rough estimate of how long the call will take to complete.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N1 := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N2 := Subgroup(G, [G.2]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrAllRefinedSums(G, N1, N2, [[3,1,1,1], [2,2,2,0]]);</span>
22
</pre></div>

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

<h5>2.3-8 SomeRefinedDifferenceSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SomeRefinedDifferenceSums</code>( <var class="Arg">G</var>, <var class="Arg">N1</var>, <var class="Arg">N2</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of some difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N2</var> that are preimages of difference sums contained in the list <var class="Arg">difsums</var> of difference sums in group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N1</var>. At least one member of each equivalence class that would appear in the set of all preimages will be returned, but all preimage difference sums may not appear. The subgroup <var class="Arg">N2</var> must be contained in <var class="Arg">N1</var> and difference sums in <var class="Arg">difsums</var> are all assumed to be the same size. Current implementation forces a choice of nonzero identity coefficient when possible.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N1 := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N2 := Subgroup(G, [G.2]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SomeRefinedDifferenceSums(G, N1, N2, [[3,1,1,1], [2,2,2,0]]);</span>
[ [ 1, 1, 0, 1, 0, 1, 2, 0 ], [ 1, 1, 2, 1, 0, 1, 0, 0 ], 
  [ 1, 0, 1, 1, 0, 2, 1, 0 ], [ 1, 2, 1, 1, 0, 0, 1, 0 ], 
  [ 2, 1, 1, 0, 0, 1, 1, 0 ] ]
</pre></div>

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

<h5>2.3-9 NrSomeRefinedSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NrSomeRefinedSums</code>( <var class="Arg">G</var>, <var class="Arg">N1</var>, <var class="Arg">N2</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the number of preimages that will need to be checked during a call to <code class="func">SomeRefinedDifferenceSums</code> (<a href="chap2_mj.html#X866272667D6032BA"><span class="RefLink">2.3-8</span></a>) with the same arguments. This can give a rough estimate of how long the call will take to complete.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 5);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N1 := Subgroup(G, [G.2, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N2 := Subgroup(G, [G.2]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrSomeRefinedSums(G, N1, N2, [[3,1,1,1], [2,2,2,0]]);</span>
21
</pre></div>

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

<h4>2.4 <span class="Heading">Equivalence</span></h4>

<p>Since we are searching for all difference sets or sums up to equivalence, at each stage we remove excess equivalent sums or sets from our collection. This can be done with <code class="func">EquivalentFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X7E4BCB8482E4AE34"><span class="RefLink">2.4-1</span></a>) and <code class="func">EquivalentFreeListOfDifferenceSums</code> (<a href="chap2_mj.html#X8639AB227B0CF9F3"><span class="RefLink">2.4-3</span></a>). The additional functions <code class="func">TranslateFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X8380F5D37E2D411B"><span class="RefLink">2.4-2</span></a>) and <code class="func">TranslateFreeListOfDifferenceSums</code> (<a href="chap2_mj.html#X7BF295758033DC3B"><span class="RefLink">2.4-4</span></a>) can be used to eliminate translate equivalent sums or sets, but they are not used in the main algorithm. Alternatively, <code class="func">SmallestEquivalentDifferenceSet</code> (<a href="chap2_mj.html#X857A641A7C86EFA3"><span class="RefLink">2.4-5</span></a>) uses the <code class="code">SmallestImageSet</code> function from the <strong class="pkg">GRAPE</strong> package to produce the lexicographically minimal difference set equivalent to a given set. Eliminating equivalent sets can then be done by mapping each set to its minimal representative and then simply eliminating duplicates. This is done automatically by <code class="func">SmallestEquivalentFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X8741BBF4811F942A"><span class="RefLink">2.4-6</span></a>), which is used in the last stage of the main algorithm instead of <code class="func">EquivalentFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X7E4BCB8482E4AE34"><span class="RefLink">2.4-1</span></a>). While the full algorithm with <code class="func">SmallestEquivalentFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X8741BBF4811F942A"><span class="RefLink">2.4-6</span></a>) is roughly 20% slower on average (and is almost 4x as slow on a few groups of order 64), this function is used since it is much faster on large automorphism groups (such as the automorphism group of <code class="code">SmallGroup(64, 267)</code>, which is impossible with <code class="func">EquivalentFreeListOfDifferenceSets</code> (<a href="chap2_mj.html#X7E4BCB8482E4AE34"><span class="RefLink">2.4-1</span></a>)) and provides a unique minimal result at the end of the algorithm.</p>

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

<h5>2.4-1 EquivalentFreeListOfDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EquivalentFreeListOfDifferenceSets</code>( <var class="Arg">G</var>, <var class="Arg">difsets</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of inequivalent difference sets in the group <var class="Arg">G</var> that consists of one representative from each equivalence class found in the list <var class="Arg">difsets</var> of arbitrary difference sets in <var class="Arg">G</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sets := [[8,9,12,13,14,15], [7,8,9,13,15,16], [1,7,10,11,14,15]];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">EquivalentFreeListOfDifferenceSets(G, sets);</span>
[ [ 8, 9, 12, 13, 14, 15 ] ]
</pre></div>

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

<h5>2.4-2 TranslateFreeListOfDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TranslateFreeListOfDifferenceSets</code>( <var class="Arg">G</var>, <var class="Arg">difsets</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of translationally inequivalent difference sets in the group <var class="Arg">G</var> that consists of one representative from each translational equivalence class found in the list <var class="Arg">difsets</var> of arbitrary difference sets in <var class="Arg">G</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sets := [[8,9,12,13,14,15], [7,8,9,13,15,16], [1,7,10,11,14,15]];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">TranslateFreeListOfDifferenceSets(G, sets);</span>
[ [ 8, 9, 12, 13, 14, 15 ], [ 7, 8, 9, 13, 15, 16 ] ]
</pre></div>

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

<h5>2.4-3 EquivalentFreeListOfDifferenceSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EquivalentFreeListOfDifferenceSums</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of inequivalent difference sums in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var> that consists of one representative from each equivalence class found in the list <var class="Arg">difsums</var> of arbitrary difference sums in <var class="Arg">G</var> mod <var class="Arg">N</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.1 * G.2 * G.3, G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">EquivalentFreeListOfDifferenceSums(G, N, [[4,2], [2,4]]);</span>
[ [ 4, 2 ] ]
</pre></div>

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

<h5>2.4-4 TranslateFreeListOfDifferenceSums</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TranslateFreeListOfDifferenceSums</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">difsums</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list of translationally inequivalent difference sums in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var> that consists of one representative from each translational equivalence class found in the list <var class="Arg">difsums</var> of arbitrary difference sums in <var class="Arg">G</var> mod <var class="Arg">N</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.1 * G.2 * G.3, G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">TranslateFreeListOfDifferenceSums(G, N, [[4,2], [2,4]]);</span>
[ [ 4, 2 ] ]
</pre></div>

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

<h5>2.4-5 SmallestEquivalentDifferenceSet</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SmallestEquivalentDifferenceSet</code>( <var class="Arg">G</var>, <var class="Arg">D</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the set that is lexicographically smallest among all sets that are equivalent to the difference set <var class="Arg">D</var> in the group <var class="Arg">G</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SmallestEquivalentDifferenceSet(G, [8,9,12,13,14,15]);</span>
[ 1, 2, 3, 4, 8, 15 ]
</pre></div>

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

<h5>2.4-6 SmallestEquivalentFreeListOfDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SmallestEquivalentFreeListOfDifferenceSets</code>( <var class="Arg">G</var>, <var class="Arg">difsets</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns a list containing the lexicographically smallest set for each set in the list of difference sets <var class="Arg">difsets</var> in the group <var class="Arg">G</var>. Duplicates are removed, so the returned list contains exactly one representative from each equivalence class found in <var class="Arg">difsets</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sets := [[8,9,12,13,14,15], [7,8,9,13,15,16], [1,7,10,11,14,15]];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SmallestEquivalentFreeListOfDifferenceSets(G, sets);</span>
[ [ 1, 2, 3, 4, 8, 15 ] ]
</pre></div>

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

<h4>2.5 <span class="Heading">Testing</span></h4>

<p>These additional functions are provided to check work and perform other experimentation. They are inefficient when used repeatedly. For example, when testing a large number of difference sets in a single group, it is better to precompute the needed group operations and store them in a table for lookup, but <code class="func">IsDifferenceSet</code> (<a href="chap2_mj.html#X8545AC1D7D42A84A"><span class="RefLink">2.5-1</span></a>) simply does the multiplication directly since it is only testing one set.</p>

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

<h5>2.5-1 IsDifferenceSet</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsDifferenceSet</code>( <var class="Arg">G</var>, <var class="Arg">D</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns true if the set <var class="Arg">D</var> is a difference set in the group <var class="Arg">G</var>, and false otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSet(G, [1, 2, 3, 4, 5, 6]);</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSet(G, [1, 2, 8, 10, 11, 15]);</span>
true
</pre></div>

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

<h5>2.5-2 IsDifferenceSum</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsDifferenceSum</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">S</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns true if the sum <var class="Arg">S</var> is a difference sum in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var>, and false otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.1 * G.2 * G.3, G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSum(G, N, [2, 4]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSum(G, N, [1, 1]);</span>
false
</pre></div>

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

<h5>2.5-3 IsEquivalentDifferenceSet</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEquivalentDifferenceSet</code>( <var class="Arg">G</var>, <var class="Arg">D1</var>, <var class="Arg">D2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns true if sets <var class="Arg">D1</var> and <var class="Arg">D2</var> are equivalent in the group <var class="Arg">G</var>, and false otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsEquivalentDifferenceSet(G, [1,5,8,9,10,14], [1,5,7,8,10,15]);</span>
false
</pre></div>

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

<h5>2.5-4 IsEquivalentDifferenceSum</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsEquivalentDifferenceSum</code>( <var class="Arg">G</var>, <var class="Arg">N</var>, <var class="Arg">S1</var>, <var class="Arg">S2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns true if sums <var class="Arg">S1</var> and <var class="Arg">S2</var> are equivalent in the group <var class="Arg">G</var> mod its normal subgroup <var class="Arg">N</var>, and false otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(16, 4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Subgroup(G, [G.1 * G.2 * G.3, G.3, G.4]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsEquivalentDifferenceSum(G, N, [2,4], [4,2]);</span>
true
</pre></div>

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

<h4>2.6 <span class="Heading">Loading Results</span></h4>

<p>The <code class="code">data</code> directory of the <strong class="pkg">DifSets</strong> Package contains precomputed results for 1006 of the 1032 groups of order less than 100. The following two functions are the easiest way to access these precomputed lists of difference sets up to equivalence.</p>

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

<h5>2.6-1 CanLoadDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CanLoadDifferenceSets</code>( <var class="Arg">v</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns true if a precomputed list of all difference sets up to equivalence can be loaded from the package library for the group <code class="code">SmallGroup(<var class="Arg">v</var>, <var class="Arg">n</var>)</code>, and false otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">CanLoadDifferenceSets(36, 9);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">CanLoadDifferenceSets(79, 1);</span>
false
</pre></div>

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

<h5>2.6-2 LoadDifferenceSets</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LoadDifferenceSets</code>( <var class="Arg">v</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns the precomputed list of all difference sets up to equivalence for the group <code class="code">SmallGroup(<var class="Arg">v</var>, <var class="Arg">n</var>)</code> stored in the package library. An error is thrown if no precomputed list is available. Note that the listed difference sets are specific to <code class="code">SmallGroup(<var class="Arg">v</var>, <var class="Arg">n</var>)</code>, as <strong class="pkg">GAP</strong> may label entries of other isomorphic versions of the same group differently.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">LoadDifferenceSets(15, 1);</span>
[ [ 1, 2, 3, 4, 8, 11, 12 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(15, 1);; H := AbelianGroup([15]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup(G) = IdGroup(H);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSet(G, [1, 2, 3, 4, 8, 11, 12]);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDifferenceSet(H, [1, 2, 3, 4, 8, 11, 12]);</span>
false
</pre></div>


<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap1_mj.html">[Previous Chapter]</a>    <a href="chap3_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>  </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.56 Sekunden  ¤

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