Quelle chap4_mj.html Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/help/doc/chap4_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 (HeLP) - Chapter 4: Extended examples</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="chap4" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <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="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="chap3_mj.html">[Previous Chapter]</a> <a href="chap5_mj.html">[Next Chapter]</a> </div>

<a href="chap4.html">[MathJax off]</a>
<a id="X7CDC63A27F7790AA" name="X7CDC63A27F7790AA"></a>
<div class="ChapSects"><a href="chap4_mj.html#X7CDC63A27F7790AA">4 Extended examples</a>
<div class="ContSect"> <a href="chap4_mj.html#X7DEAD03D7811F9FA">4.1 The Character Table Library</a>

</div>
<div class="ContSect"> <a href="chap4_mj.html#X84ED1F0D7A47B055">4.2 The behavior of the variable HeLP sol</a>

</div>
<div class="ContSect"> <a href="chap4_mj.html#X7E939D8483F1EE64">4.3 Saving time</a>

</div>
<div class="ContSect"> <a href="chap4_mj.html#X8242093A82FE41FA">4.4 Using InfoLevels</a>

</div>
<div class="ContSect"> <a href="chap4_mj.html#X818A647182CA20B3">4.5 Non-standard characters</a>

</div>
<div class="ContSect"> <a href="chap4_mj.html#X879DC8C287C41B09">4.6 A complete example: (PQ) for the MacLaughlin simple group</a>

</div>
</div>

<h3>4 Extended examples</h3>

We will give some more examples which are intended to give the user an idea of the behavior on different inputs and the variable HeLP_sol. We also give hints how to use the package more efficiently, to use characters not available in libraries and how InfoLevels can be helpful.

<a id="X7DEAD03D7811F9FA" name="X7DEAD03D7811F9FA"></a>

<h4>4.1 The Character Table Library</h4>

<div class="example"><pre>
gap> G := SL(2,7);
SL(2,7)
gap> HeLP_ZC(G);
#I The Brauer tables for the following primes are not available: [ 2, 3, 7 ].
#I (ZC) can't be solved, using the given data, for the orders: [ 8 ].
false
gap> C1 := CharacterTable(G);
CharacterTable( SL(2,7) )
gap> HeLP_ZC(C1);
#I The Brauer tables for the following primes are not available: [ 2, 3, 7 ].
#I (ZC) can't be solved, using the given data, for the orders: [ 8 ].
false
gap> C2 := CharacterTable("2.L2(7)");
CharacterTable( "2.L3(2)" )
gap> HeLP_ZC(C2);
true
</pre></div>

Note that the first and the second call of <code class="func">HeLP_ZC</code> (<a href="chap2_mj.html#X81AF79A587054306">2.1-1</a>) are equivalent -- the only difference being that in the first version the character table of the group is also calculated by the function, in the second version the calculations are performed with the given character table. For the third call of <code class="func">HeLP_ZC</code> (<a href="chap2_mj.html#X81AF79A587054306">2.1-1</a>) a character table for SL2(7) is used which comes from the character table library. The different result is due to the fact, that in the third version the Brauer tables are available (the Brauer table for the prime \(p = 7\) is needed to rule out some non-trivial partial augmentations for elements of order 8), whereas for the first and the second call no Brauer tables are available in GAP.

<a id="X84ED1F0D7A47B055" name="X84ED1F0D7A47B055"></a>

<h4>4.2 The behavior of the variable HeLP sol</h4>

This sections demonstrates when the global variable <code class="keyw">HeLP_sol</code> is reset. This is the case if calculations are performed using (the character table of) another group than before:

<div class="example"><pre>
gap> C := CharacterTable("A5");
CharacterTable( "A5" )
gap> HeLP_ZC(C);
true
gap> HeLP_sol;
[ [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ] ] ],,
 [ [ [ 0, 1 ] ], [ [ 1, 0 ] ] ], [ ],,,, [ ],,,,, [ ],,,,,,,,,,,,,,, [ ]
]
gap> C := CharacterTable("L3(7).2");
CharacterTable( "L3(7).2" )
gap> HeLP_WithGivenOrderAndPA(Irr(C){[3,7,9,10]},21,[[1],[3,9,-11]]);
#I Number of solutions for elements of order 21 with these partial augmentation
s for the powers: 1.
[ [ [ 1 ], [ 3, 9, -11 ], [ -6, 0, 3, 4 ] ] ]
gap> HeLP_sol;
[ [ [ [ 1 ] ] ] ]
</pre></div>

The function <code class="func">HeLP_WithGivenOrderAndPA</code> (<a href="chap3_mj.html#X7CD0CEF283F13F7B">3.1-2</a>) does not write a result in <code class="keyw">HeLP_sol[k]</code> (as it does not calculate all possible solutions of order \(k\)). However <code class="keyw">HeLP_sol</code> is reset as a different character table is used. We continue the above example.

<div class="example"><pre>
gap> HeLP_WithGivenOrder(C,3);
#I Number of solutions for elements of order 3: 1; stored in HeLP_sol[3].
[ [ [ 1 ] ] ]
gap> HeLP_sol;
[ [ [ [ 1 ] ] ],, [ [ [ 1 ] ] ] ]
</pre></div>

If HeLP detects that the table used belongs to the same group, <code class="keyw">HeLP_sol</code> is not reset:

<div class="example"><pre>
gap> HeLP_WithGivenOrder(C mod 7, 19);
#I Number of solutions for elements of order 19: 3; stored in HeLP_sol[19].
[ [ [ 0, 0, 1 ] ], [ [ 0, 1, 0 ] ], [ [ 1, 0, 0 ] ] ]
gap> HeLP_sol;
[ [ [ [ 1 ] ] ],, [ [ [ 1 ] ] ],,,,,,,,,,,,,,,,
 [ [ [ 0, 0, 1 ] ], [ [ 0, 1, 0 ] ], [ [ 1, 0, 0 ] ] ] ]
# the previously calaculated result for order 3 is still there.
</pre></div>

HeLP can detect that the character tables belong to the same group, if they are identical objects in GAP or if both are tables of the same group from the ATLAS and their InfoText begins with "origin: ATLAS of finite groups" (which is usually the case for ATLAS tables). If the program can verify that the character table which is used at the current call of a function belongs to the same group as in the previous call of a function, the solutions stored in <code class="keyw">HeLP_sol</code> are kept. If the character table belongs to another group or it can not be made sure that the character table belongs to the same group, <code class="keyw">HeLP_sol</code> is reset to the initial value <code class="keyw">[ [ [1] ] ]</code> representing the trivial solution for units of order \(1\).

Not reseting <code class="keyw">HeLP_sol</code> can also be achieved using <code class="func">HeLP_ChangeCharKeepSols</code> (<a href="chap3_mj.html#X7BB9009482784E90">3.4-1</a>). However, caution should be exercised when using this command since it may manipulate <code class="keyw">HeLP_sol</code> into something meaningless.

<div class="example"><pre>
gap> G := PSL(2,7);
Group([ (3,7,5)(4,8,6), (1,2,6)(3,4,8) ])
gap> HeLP_ZC(G);
#I The Brauer tables for the following primes are not available: [ 2, 3, 7 ].
#I (ZC) can't be solved, using the given data, for the orders: [ 6 ].
false
gap> HeLP_sol;
[ [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ], [ 0, 1 ] ] ],,
 [ [ [ 1 ], [ 1 ], [ -2, 3 ] ] ], [ [ [ 0, 1 ] ], [ [ 1, 0 ] ] ],,,,, [ ],,
 [ ],,,,,,, [ ],,,,,,, [ ],,,,,,,,,,,,,, [ ],,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 ,,,,,,,,,,,,, [ ] ]
gap> C := CharacterTable("L2(7)") mod 7;
BrauerTable( "L3(2)", 7 )
gap> HeLP_ChangeCharKeepSols(C); #This table belongs to the same group.
gap> HeLP_WithGivenOrder(C,6);
#I Number of solutions for elements of order 6: 0; stored in HeLP_sol[6].
[ ]
gap> HeLP_sol;
[ [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ], [ 0, 1 ] ] ],,
 [ ], [ [ [ 0, 1 ] ], [ [ 1, 0 ] ] ],,,,, [ ],, [ ],,,,,,, [ ],,,,,,,
 [ ],,,,,,,,,,,,,, [ ],,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [ ] ]
gap> C := CharacterTable("L3(7).2") mod 7;
BrauerTable( "L3(7).2", 7 )
gap> HeLP_ChangeCharKeepSols(C); #This table is from a different group
gap> HeLP_WithGivenOrder(C,19);
#I Number of solutions for elements of order 19: 3; stored in HeLP_sol[19].
[ [ [ 0, 0, 1 ] ], [ [ 0, 1, 0 ] ], [ [ 1, 0, 0 ] ] ]
gap> HeLP_sol;
[ [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ] ] ], [ [ [ 1 ], [ 0, 1 ] ] ],,
 [ ], [ [ [ 0, 1 ] ], [ [ 1, 0 ] ] ],,,,, [ ],, [ ],,,,,
 [ [ [ 0, 0, 1 ] ], [ [ 0, 1, 0 ] ], [ [ 1, 0, 0 ] ] ],, [ ],,,,,,, [ ],,,,
 ,,,,,,,,,, [ ],,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [ ] ]
# The content of HeLP_sol does not have a mathematical value anymore.
</pre></div>

The following functions manipulate the variable <code class="keyw">HeLP_sol</code>: <code class="func">HeLP_ZC</code> (<a href="chap2_mj.html#X81AF79A587054306">2.1-1</a>), <code class="func">HeLP_PQ</code> (<a href="chap2_mj.html#X813A10398218E9EE">2.2-1</a>), <code class="func">HeLP_WithGivenOrder</code> (<a href="chap3_mj.html#X7F8F6E3D80A23C1D">3.1-1</a>), <code class="func">HeLP_WithGivenOrderSConstant</code> (<a href="chap3_mj.html#X7CAC647C7D1E95B0">3.2-1</a>) (for elements of order \(t\) and if the existence of elements of order \(st\) can be excluded also for this order), <code class="func">HeLP_AllOrders</code> (<a href="chap3_mj.html#X8727639883F787C5">3.3-1</a>), <code class="func">HeLP_AllOrdersPQ</code> (<a href="chap3_mj.html#X7C00E1567BFF1757">3.3-2</a>), <code class="func">HeLP_VerifySolution</code> (<a href="chap3_mj.html#X7DAA7EF785621D9E">3.6-1</a>) (if existing solutions were checked), <code class="func">HeLP_FindAndVerifySolution</code> (<a href="chap3_mj.html#X8452B7F58641E7F5">3.6-2</a>). Note that the functions only will write results in <code class="keyw">HeLP_sol[k]</code> if \(k\) is a divisor of the exponent of the group as this information is enough to decide whether (ZC) and (PQ) are valid for the group in consideration. In all other cases an empty list will be returned but no value will be written in <code class="keyw">HeLP_sol[k]</code>.

<a id="X7E939D8483F1EE64" name="X7E939D8483F1EE64"></a>

<h4>4.3 Saving time</h4>

The most time consuming operation when using the functions of this package is solving the system of inequalities given by the HeLP method, see Section <a href="chap5_mj.html#X8663389F87B9CE62">5.3</a>. This package uses the programs 4ti2 and/or normaliz to do this and it is not completely clear to the authors of this package which input is solved faster by these programs. In any case it is helpful to reduce the number of variables, using e.g. \(p\)-constant characters, and in many situations it is useful to reduce the number of inequalities, i.e. of used characters.

To measure the time a function needs we use <code class="keyw">IO_gettimeofday</code> from the IO-package rather than functions like <code class="keyw">time</code> or <code class="keyw">Runtime</code>, since these measure only the GAP time, but do not return the time the functions spend using 4ti2 or normaliz. We used the following function (which is essentially due to Olexandr Konovalov) to meassure the time used for the computation:

<div class="example"><pre>
TimeFunction := function(f, args)
# input: the function of which the computing time should be measured
# and the list of arguments for this function
# output: time needed for the calculations in seconds
local start;
start := IO_gettimeofday();
CallFuncList(f,args);
return IO_gettimeofday().tv_sec - start.tv_sec;
end;
</pre></div>

All times will be given in seconds. The computations were perfomed on an a machine with four 2,6 GHz kernels.

A lot of time might be saved by testing only a few characters instead of a whole character table:

<div class="example"><pre>
gap> C := CharacterTable("L2(49)");;
gap> HeLP_Solver("normaliz");
'normaliz' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [C,35]); 
#I Number of solutions for elements of order 35: 0; stored in HeLP_sol[35].
6 # I.e.: The computation took 6 seconds.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[2]}, 35]);
#I Number of solutions for elements of order 35: 0; stored in HeLP_sol[35].
0
gap> HeLP_Solver("4ti2"); 
'4ti2' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [C,35]); 
#I Number of solutions for elements of order 35: 0; stored in HeLP_sol[35].
6
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[2]}, 35]);
#I Number of solutions for elements of order 35: 0; stored in HeLP_sol[35].
1
</pre></div>

I.e.: Using only one character instead of all of them is about six times faster in this situation and this is also quickly found by <code class="keyw">HeLP_FindAndVerifySolution</code>.

Using only a few characters might even be a life saver:

<div class="example"><pre>
gap> C := CharacterTable("L4(3).2^2");;
gap> HeLP_WithGivenOrder(C, 3);;
#I Number of solutions for elements of order 3: 63; stored in HeLP_sol[3].
gap> HeLP_WithGivenOrder(C, 13);;
#I Number of solutions for elements of order 13: 198; stored in HeLP_sol[13].
gap> SetInfoLevel(HeLP_Info,4);
gap> HeLP_Solver("4ti2");
'4ti2' will be used from now on.
gap> HeLP_UseRedund(true);
'redund' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[5,11,16]}, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
438
gap> HeLP_UseRedund(false);
The calculations will be performed without using 'redund' from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[5,11,16]}, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
430
gap> HeLP_Solver("normaliz");
'normaliz' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[5,11,16]}, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
340
gap> HeLP_UseRedund(true); 
'redund' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C){[5,11,16]}, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
419
gap> HeLP_UseRedund(false);
The calculations will be performed without using 'redund' from now on.
gap> HeLP_Solver("normaliz");
'normaliz' will be used from now on.
gap> TimeFunction(HeLP_WithGivenOrder, [Irr(C), 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
6234
</pre></div>

Sometimes it is helpful to look at groups containing the group of interest:

<div class="example"><pre>
gap> C := CharacterTable("2F4(2)'");;
gap> HeLP_WithGivenOrder(C, 13);;
#I Number of solutions for elements of order 13: 316; stored in HeLP_sol[13].
gap> HeLP_WithGivenOrder(C, 3);;
#I Number of solutions for elements of order 3: 1; stored in HeLP_sol[3].
gap> TimeFunction(HeLP_WithGivenOrder, [C, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
80
gap> C:=CharacterTable("2F4(2)'.2");
CharacterTable( "2F4(2)'.2" )
gap> TimeFunction(HeLP_WithGivenOrder, [C, 39]);
#I Number of solutions for elements of order 39: 0; stored in HeLP_sol[39].
1
</pre></div>

This is also a good example to use \(p\)-constant characters:

<div class="example"><pre>
gap> C:=CharacterTable("2F4(2)'");
CharacterTable( "2F4(2)'" )
gap> TimeFunction(HeLP_WithGivenOrderSConstant, [C, 13, 3]);
#I Number of non-trivial 13-constant characters in the list: 19.
0
</pre></div>

If using 4ti2, for some groups switching redund on and off gives major improvements.

<div class="example"><pre>
gap> HeLP_Solver("4ti2");
'4ti2' will be used from now on.
gap> HeLP_UseRedund(true);
'redund' will be used from now on.
gap> C := CharacterTable(SmallGroup(160,91));;
gap> TimeFunction(HeLP_ZC, [C]);
26
gap> HeLP_Solver("normaliz");
'normaliz' will be used from now on.
gap> TimeFunction(HeLP_ZC, [C]);
12
</pre></div>

Using 4ti2 but not redund <code class="keyw">HeLP_ZC(C)</code> ran for over 400 hours without a result.

<div class="example"><pre>
gap> C := CharacterTable(SmallGroup(96,12));;
gap> HeLP_UseRedund(false);
The calculations will be performed without using 'redund' from now on.
gap> HeLP_Solver("4ti2");;
gap> TimeFunction(HeLP_ZC, [C]);
2
</pre></div>

Running this example using redund the computations does not proceed for elements of order 12.

<a id="X8242093A82FE41FA" name="X8242093A82FE41FA"></a>

<h4>4.4 Using InfoLevels</h4>

HeLP provides different InfoLevels for different situations. The variable controlling the InfoLevel is <code class="keyw">HeLP_Info</code> and it might be changed using <code class="keyw">SetInfoLevel(HeLP_Info, n)</code> to set the InfoLevel to n. The maximal <code class="keyw">HeLP_Info</code> entry is 5, the default InfoLevel is 1. The examples below give some idea, how one can use <code class="keyw">HeLP_Info</code>, but do not give complete information on all possibilities.

If one is only interested whether (ZC) or (PQ) can be solved using the HeLP method, one can set <code class="keyw">HeLP_Info</code> to 0:

<div class="example"><pre>
gap> C := CharacterTable("M11");
CharacterTable( "M11" )
gap> HeLP_ZC(C);
#I ZC can't be solved, using the given data, for the orders: [ 4, 6, 8 ].
false
gap> SetInfoLevel(HeLP_Info, 0);
gap> HeLP_ZC(C);
false
</pre></div>

If the InfoLevel is set to 2, the functions <code class="func">HeLP_ZC</code> (<a href="chap2_mj.html#X81AF79A587054306">2.1-1</a>) and <code class="func">HeLP_PQ</code> (<a href="chap2_mj.html#X813A10398218E9EE">2.2-1</a>) print information which order of torsion units is currently considered, so that the user can keep track of the progress. This may be used for bigger groups to see, if the calculations might finish at some point. Continuing the above example:

<div class="example"><pre>
gap> SetInfoLevel(HeLP_Info, 2);
gap> HeLP_PQ(C);
#I Checking order 2.
#I Checking order 3.
#I Checking order 5.
#I Checking order 10.
#I Checking order 11.
#I Checking order 15.
#I Checking order 22.
#I Checking order 33.
#I Checking order 55.
true
</pre></div>

<code class="keyw">HeLP_Info</code> at InfoLevel 3 provides also some information about the used ordinary character table or Brauer tables:

<div class="example"><pre>
gap> SetInfoLevel(HeLP_Info, 3);
gap> HeLP_PQ(C);
#I Checking order 2.
#I Using table BrauerTable( "M11", 3 ).
#I Checking order 3.
#I Using table BrauerTable( "M11", 3 ).
#I Using table BrauerTable( "M11", 11 ).
#I Checking order 5.
#I Using table BrauerTable( "M11", 3 ).
#I Checking order 10.
#I Using table BrauerTable( "M11", 3 ).
#I Checking order 11.
#I Using table BrauerTable( "M11", 3 ).
#I Checking order 15.
#I Using table BrauerTable( "M11", 3 ).
#I Using table BrauerTable( "M11", 11 ).
#I Checking order 22.
#I Using table BrauerTable( "M11", 3 ).
#I Checking order 33.
#I Using table BrauerTable( "M11", 3 ).
#I Using table BrauerTable( "M11", 11 ).
#I Using table BrauerTable( "M11", 2 ).
#I Checking order 55.
#I Using table BrauerTable( "M11", 3 ).
true
</pre></div>

Setting <code class="keyw">HeLP_Info</code> to 4 is useful when there are many possibilities for the partial augmentations of the powers of some unit. A good example is the example on "L4(3).2^2" in the section on Time Saving <a href="chap4_mj.html#X7E939D8483F1EE64">4.3</a>, see above: If you see quickly that almost nothing is happening, you might want to change your strategy.

<code class="keyw">HeLP_Info</code> at level 5 informs the user on all changes of the used character table. Using it makes sense, if you work with the command <code class="func">HeLP_ChangeCharKeepSols</code> (<a href="chap3_mj.html#X7BB9009482784E90">3.4-1</a>).

<a id="X818A647182CA20B3" name="X818A647182CA20B3"></a>

<h4>4.5 Non-standard characters</h4>

The package also allows using characters even if the whole character table is not available. E.g. induced characters:

<div class="example"><pre>
gap> C := CharacterTable("U3(8)");
CharacterTable( "U3(8)" )
gap> G := PSU(3,8); 
<permutation group of size 5515776 with 2 generators>
gap> A := AutomorphismGroup(G);
<group of size 99283968 with 4 generators>
gap> AllCharacterTableNames(Size,Size(A));
[ "3.U3(8).6", "3.U3(8).S3" ]
</pre></div>

This means: The character table of the automorphism group A of PSU(3,8) is not available in GAP. However one can use induced characters:

<div class="example"><pre>
gap> NN := NormalSubgroups(A);
[ <trivial group>, <group of size 5515776 with 2 generators>,
 <group with 3 generators>, <group of size 16547328 with 3 generators>,
 <group of size 49641984 with 4 generators>,
 <group of size 33094656 with 4 generators>,
 <group of size 99283968 with 4 generators> ]
gap> H := NN[2]; #Subgroup of A isomorphic to G 
<group of size 5515776 with 2 generators>
gap> CharacterTableWithStoredGroup(H,C); 
CharacterTable( <group of size 5515776 with 2 generators> )
gap> D := CharacterTable(H); 
CharacterTable( <group of size 5515776 with 2 generators> )
gap> chi := InducedClassFunction(Irr(D)[2],A);
Character( CharacterTable( <group of size 99283968 with 4 generators> ),
[ 1008, -144, -126, 18, 0, 0, 0, 0, 36, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -18, 0, 0,
 0, 0 ] )
gap> HeLP_WithGivenOrder([chi],7*19);
#I Number of solutions for elements of order 133: 0; stored in HeLP_sol[133].
[ ]
</pre></div>

One can also use characters, which are not available in GAP, but are entered manually:

<div class="example"><pre>
gap> C := CharacterTable("L2(49)");
CharacterTable( "L2(49)" )
gap> HeLP_WithGivenOrder(C,15);;
#I Number of solutions for elements of order 15: 56; stored in HeLP_sol[15].
gap> C7 := C mod 7;
fail
</pre></div>

The Brauer characters for the prime 7 are well known, see e.g. <a href="chapBib_mj.html#biBSrinivasanPSL">[Sri64]</a> , but are not yet available in GAP.

<div class="example"><pre>
gap> OrdersClassRepresentatives(C);
[ 1, 2, 3, 4, 5, 5, 6, 7, 7, 8, 8, 12, 12, 24, 24, 24, 24, 25, 25, 25, 25,
 25, 25, 25, 25, 25, 25 ]
gap> chi := ClassFunction(C, [ 3, 0, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4, 0, 
> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]);
ClassFunction( CharacterTable( "L2(49)" ),
[ 3, 0, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] )
gap> HeLP_WithGivenOrder([chi],15);
#I Number of solutions for elements of order 15: 0; stored in HeLP_sol[15].
[ ]
</pre></div>

The class function <code class="keyw">chi</code> above is of course not a proper character of the group, but the values coincide with the values of a 7-Brauer character of the group on the conjugacy classes of order 1, 3 and 5, i.e. the one needed to use HeLP for order 15. All functions of the HeLP-package only access values of class functions on conjugacy classes of elements with an order dividing the order of the unit in question. That is why this class function <code class="keyw">chi</code> can be used in this setting.

<a id="X879DC8C287C41B09" name="X879DC8C287C41B09"></a>

<h4>4.6 A complete example: (PQ) for the MacLaughlin simple group</h4>

This section gives a demonstration of many functions of the package. The goal is to verify the Prime Graph Question for the McLaughlin simple group, which was proved in <a href="chapBib_mj.html#biBKonovalovMcL">[BK07b]</a>

<div class="example"><pre>
gap> C := CharacterTable("McL");
CharacterTable( "McL" )
gap> SetInfoLevel(HeLP_Info,4);
</pre></div>

The function <code class="keyw">HeLP_PQ(C)</code> would take really long. Instead one can use <code class="keyw">HeLP_AllOrdersPQ(C)</code> several times on a high InfoLevel. Any time you see the function needs long, just try some manual calculations. Compute first the partial augmentations of elements of prime order:

<div class="example"><pre>
gap> HeLP_WithGivenOrder(C,2);;
#I Number of solutions for elements of order 2: 1; stored in HeLP_sol[2].
gap> HeLP_WithGivenOrder(C mod 2,3);;
#I Number of solutions for elements of order 3: 4; stored in HeLP_sol[3].
gap> HeLP_WithGivenOrder(C mod 3,5);;
#I Number of solutions for elements of order 5: 6; stored in HeLP_sol[5].
gap> HeLP_WithGivenOrder(C mod 3,7);;
#I Number of solutions for elements of order 7: 174; stored in HeLP_sol[7].
gap> HeLP_WithGivenOrder(C mod 3,11);;
#I Number of solutions for elements of order 11: 20; stored in HeLP_sol[11].
</pre></div>

For mixed order in most situations \(p\)-constant characters are interesting. Check the tables for such characters of small degree.

<div class="example"><pre>
gap> HeLP_WithGivenOrderSConstant(Irr(C){[2,3,4,5]},7,3);
#I Number of non-trivial 7-constant characters in the list: 4.
[ ]
gap> HeLP_WithGivenOrderSConstant(Irr(C){[2,3,4,5]},11,2);
#I Number of non-trivial 11-constant characters in the list: 4.
[ ]
gap> HeLP_WithGivenOrderSConstant(Irr(C){[2,3,4,5]},11,3);
#I Number of non-trivial 11-constant characters in the list: 4.
[ ]
gap> HeLP_WithGivenOrderSConstant(Irr(C mod 3){[2,3,4,5]},7,5);
#I Number of non-trivial 7-constant characters in the list: 4.
[ ]
gap> HeLP_WithGivenOrderSConstant(Irr(C mod 3){[2,3,4,5]},7,11);
#I Number of non-trivial 7-constant characters in the list: 4.
[ ]
gap> HeLP_WithGivenOrderSConstant(Irr(C mod 3){[2,3,4,5]},11,5);
#I Number of non-trivial 11-constant characters in the list: 2.
[ ]
</pre></div>

These calculations are enough to obtain an affirmative answer to the Prime Graph Question:

<div class="example"><pre>
gap> HeLP_AllOrdersPQ(C);
#I Checking order 2.
#I Using the known solutions for elements of order 2.
#I Checking order 3.
#I Using the known solutions for elements of order 3.
#I Checking order 5.
#I Using the known solutions for elements of order 5.
#I Checking order 7.
#I Using the known solutions for elements of order 7.
#I Checking order 11.
#I Using the known solutions for elements of order 11.
#I Checking order 21.
#I Using the known solutions for elements of order 21.
#I Checking order 22.
#I Using the known solutions for elements of order 22.
#I Checking order 33.
#I Using the known solutions for elements of order 33.
#I Checking order 35.
#I Using the known solutions for elements of order 35.
#I Checking order 55.
#I Using the known solutions for elements of order 55.
#I Checking order 77.
#I Using the known solutions for elements of order 77.
true
</pre></div>

Checking these computations takes a few minutes.

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

<div class="chlinkbot">Goto Chapter: <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="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>

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

quality100%

¤ Dauer der Verarbeitung: 0.21 Sekunden ¤

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.