Quelle chap72.html Sprache: HTML

products/sources/formale Sprachen/GAP/doc/ref/chap72.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 (ref) - Chapter 72: Class Functions</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="chap72" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chap11.html">11</a> <a href="chap12.html">12</a> <a href="chap13.html">13</a> <a href="chap14.html">14</a> <a href="chap15.html">15</a> <a href="chap16.html">16</a> <a href="chap17.html">17</a> <a href="chap18.html">18</a> <a href="chap19.html">19</a> <a href="chap20.html">20</a> <a href="chap21.html">21</a> <a href="chap22.html">22</a> <a href="chap23.html">23</a> <a href="chap24.html">24</a> <a href="chap25.html">25</a> <a href="chap26.html">26</a> <a href="chap27.html">27</a> <a href="chap28.html">28</a> <a href="chap29.html">29</a> <a href="chap30.html">30</a> <a href="chap31.html">31</a> <a href="chap32.html">32</a> <a href="chap33.html">33</a> <a href="chap34.html">34</a> <a href="chap35.html">35</a> <a href="chap36.html">36</a> <a href="chap37.html">37</a> <a href="chap38.html">38</a> <a href="chap39.html">39</a> <a href="chap40.html">40</a> <a href="chap41.html">41</a> <a href="chap42.html">42</a> <a href="chap43.html">43</a> <a href="chap44.html">44</a> <a href="chap45.html">45</a> <a href="chap46.html">46</a> <a href="chap47.html">47</a> <a href="chap48.html">48</a> <a href="chap49.html">49</a> <a href="chap50.html">50</a> <a href="chap51.html">51</a> <a href="chap52.html">52</a> <a href="chap53.html">53</a> <a href="chap54.html">54</a> <a href="chap55.html">55</a> <a href="chap56.html">56</a> <a href="chap57.html">57</a> <a href="chap58.html">58</a> <a href="chap59.html">59</a> <a href="chap60.html">60</a> <a href="chap61.html">61</a> <a href="chap62.html">62</a> <a href="chap63.html">63</a> <a href="chap64.html">64</a> <a href="chap65.html">65</a> <a href="chap66.html">66</a> <a href="chap67.html">67</a> <a href="chap68.html">68</a> <a href="chap69.html">69</a> <a href="chap70.html">70</a> <a href="chap71.html">71</a> <a href="chap72.html">72</a> <a href="chap73.html">73</a> <a href="chap74.html">74</a> <a href="chap75.html">75</a> <a href="chap76.html">76</a> <a href="chap77.html">77</a> <a href="chap78.html">78</a> <a href="chap79.html">79</a> <a href="chap80.html">80</a> <a href="chap81.html">81</a> <a href="chap82.html">82</a> <a href="chap83.html">83</a> <a href="chap84.html">84</a> <a href="chap85.html">85</a> <a href="chap86.html">86</a> <a href="chap87.html">87</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="chap71.html">[Previous Chapter]</a> <a href="chap73.html">[Next Chapter]</a> </div>

<a href="chap72_mj.html">[MathJax on]</a>
<a id="X7C91D0D17850E564" name="X7C91D0D17850E564"></a>
<div class="ChapSects"><a href="chap72.html#X7C91D0D17850E564">72 Class Functions</a>
<div class="ContSect"> <a href="chap72.html#X823319217E4B6852">72.1 Why Class Functions?</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7E75A70F7BF00A0D">72.1-1 IsClassFunction</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X8192EDDB84ADD46E">72.2 Basic Operations for Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X81B55C067D123B76">72.2-1 UnderlyingCharacterTable</a>
 <a href="chap72.html#X7FE14712843C6486">72.2-2 ValuesOfClassFunction</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X829EFBF57FCB1A94">72.3 Comparison of Class Functions</a>

</div>
<div class="ContSect"> <a href="chap72.html#X83B9F0C5871A5F7F">72.4 Arithmetic Operations for Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X83AAD5527BBAFA03">72.4-1 Characteristic</a>
 <a href="chap72.html#X856AB97E785E0B04">72.4-2 ComplexConjugate</a>
 <a href="chap72.html#X7BCE99B88285EB39">72.4-3 Order</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X828AD0C57EA57C21">72.5 Printing Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7BDD2D4A7F7FB3B1">72.5-1 ViewObj</a>
 <a href="chap72.html#X871160B98595D4BA">72.5-2 PrintObj</a>
 <a href="chap72.html#X8430D31B8163C230">72.5-3 Display</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X7BB90A8F86FFA456">72.6 Creating Class Functions from Values Lists</a>

<div class="ContSSBlock">
 <a href="chap72.html#X78F4E23985FCA259">72.6-1 ClassFunction</a>
 <a href="chap72.html#X7805AFF77EFC3306">72.6-2 VirtualCharacter</a>
 <a href="chap72.html#X849DD34C7968206C">72.6-3 Character</a>
 <a href="chap72.html#X7B38035981D71B1B">72.6-4 ClassFunctionSameType</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X8727C2CB7ABEBC84">72.7 Creating Class Functions using Groups</a>

<div class="ContSSBlock">
 <a href="chap72.html#X86129DC37C55E4D6">72.7-1 TrivialCharacter</a>

 <a href="chap72.html#X82C01DDB82D751A9">72.7-2 NaturalCharacter</a>
 <a href="chap72.html#X7938621F81B65E03">72.7-3 PermutationCharacter</a>

</div></div>
<div class="ContSect"> <a href="chap72.html#X86DDB47A7C6B45D0">72.8 Operations for Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7FE3CD08794051F8">72.8-1 IsCharacter</a>
 <a href="chap72.html#X788DD05C86CB7030">72.8-2 IsVirtualCharacter</a>
 <a href="chap72.html#X79A4B1D3870C8807">72.8-3 IsIrreducibleCharacter</a>
 <a href="chap72.html#X7802BC157C69DD75">72.8-4 DegreeOfCharacter</a>
 <a href="chap72.html#X855FD9F983D275CD">72.8-5 ScalarProduct</a>
 <a href="chap72.html#X858DF4E67EBB99DA">72.8-6 MatScalarProducts</a>
 <a href="chap72.html#X8572B18A7BAED73E">72.8-7 Norm</a>
 <a href="chap72.html#X78550D7087DB1181">72.8-8 ConstituentsOfCharacter</a>
 <a href="chap72.html#X7E0A24498710F12B">72.8-9 KernelOfCharacter</a>
 <a href="chap72.html#X7B4708B47D9C05B3">72.8-10 ClassPositionsOfKernel</a>
 <a href="chap72.html#X7E77D4147A0836D3">72.8-11 CentreOfCharacter</a>
 <a href="chap72.html#X7CE5B4137B399274">72.8-12 ClassPositionsOfCentre</a>
 <a href="chap72.html#X7C3187387C2D9938">72.8-13 InertiaSubgroup</a>
 <a href="chap72.html#X8269BE0079A64D43">72.8-14 CycleStructureClass</a>
 <a href="chap72.html#X86EDB4047C5AD6E7">72.8-15 IsTransitive</a>
 <a href="chap72.html#X801DC07B8029841B">72.8-16 Transitivity</a>
 <a href="chap72.html#X7DD8FDCF7FB7834A">72.8-17 CentralCharacter</a>
 <a href="chap72.html#X7A292A58827B95B8">72.8-18 DeterminantOfCharacter</a>
 <a href="chap72.html#X861B435C7F68AE7D">72.8-19 EigenvaluesChar</a>
 <a href="chap72.html#X7A106BE281EFD953">72.8-20 Tensored</a>
 <a href="chap72.html#X7B83B4108490FD06">72.8-21 TensorProduct</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X854A4E3A85C5F89B">72.9 Restricted and Induced Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X86BABEA6841A40CF">72.9-1 RestrictedClassFunction</a>
 <a href="chap72.html#X86DB64F08035D219">72.9-2 RestrictedClassFunctions</a>
 <a href="chap72.html#X7FE39D3D78855D3B">72.9-3 InducedClassFunction</a>

 <a href="chap72.html#X8484C0F985AD2D28">72.9-4 InducedClassFunctions</a>
 <a href="chap72.html#X7C72003880743D28">72.9-5 InducedClassFunctionsByFusionMap</a>
 <a href="chap72.html#X7C055F327C99CE71">72.9-6 InducedCyclic</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X7C95F7937B752F48">72.10 Reducing Virtual Characters</a>

<div class="ContSSBlock">
 <a href="chap72.html#X86F360D983343C2A">72.10-1 ReducedClassFunctions</a>
 <a href="chap72.html#X7B7138ED8586F09E">72.10-2 ReducedCharacters</a>
 <a href="chap72.html#X7D3289BB865BCF98">72.10-3 IrreducibleDifferences</a>
 <a href="chap72.html#X85B360C085B360C0">72.10-4 LLL</a>
 <a href="chap72.html#X808D71A57D104ED7">72.10-5 Extract</a>
 <a href="chap72.html#X7F97B34A879D11BA">72.10-6 OrthogonalEmbeddingsSpecialDimension</a>
 <a href="chap72.html#X8799AB967C58C0E9">72.10-7 Decreased</a>
 <a href="chap72.html#X85D510DC873A99B4">72.10-8 DnLattice</a>
 <a href="chap72.html#X78754D007F3572A7">72.10-9 DnLatticeIterative</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X87ED98F385B00D34">72.11 Symmetrizations of Class Functions</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7E220413823330EC">72.11-1 Symmetrizations</a>
 <a href="chap72.html#X85CE68CA87CA383A">72.11-2 SymmetricParts</a>
 <a href="chap72.html#X8329E934829FE965">72.11-3 AntiSymmetricParts</a>
 <a href="chap72.html#X87BA59597CA21B3E">72.11-4 ExteriorPower</a>
 <a href="chap72.html#X855A7ECF80FCF0BA">72.11-5 SymmetricPower</a>
 <a href="chap72.html#X78648E367C65B1F1">72.11-6 OrthogonalComponents</a>
 <a href="chap72.html#X788B9AA17DD9418C">72.11-7 SymplecticComponents</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X87B86B427A88CD25">72.12 Molien Series</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7D7F94D2820B1177">72.12-1 MolienSeries</a>
 <a href="chap72.html#X82AC06A880EAA0AB">72.12-2 MolienSeriesInfo</a>
 <a href="chap72.html#X87083C4E7D11A02E">72.12-3 ValueMolienSeries</a>
 <a href="chap72.html#X86BAA3C487CE86D2">72.12-4 MolienSeriesWithGivenDenominator</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X7D6336857E6BDF46">72.13 Possible Permutation Characters</a>

<div class="ContSSBlock">
 <a href="chap72.html#X8477004C7A31D28C">72.13-1 PermCharInfo</a>
 <a href="chap72.html#X7A8CB0298730D808">72.13-2 PermCharInfoRelative</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X8330FDCE83D3DED3">72.14 Computing Possible Permutation Characters</a>

<div class="ContSSBlock">
 <a href="chap72.html#X7D02541482C196A6">72.14-1 PermChars</a>
 <a href="chap72.html#X8127771D7EAB6EA7">72.14-2 TestPerm1, ..., TestPerm5</a>

 <a href="chap72.html#X879D2A127BE366A5">72.14-3 PermBounds</a>
 <a href="chap72.html#X7F11AFB783352903">72.14-4 PermComb</a>
 <a href="chap72.html#X866942167802E036">72.14-5 Inequalities</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X8204FB9F847340C8">72.15 Operations for Brauer Characters</a>

<div class="ContSSBlock">
 <a href="chap72.html#X79BACBC47B4C413E">72.15-1 FrobeniusCharacterValue</a>
 <a href="chap72.html#X8304B68E84511685">72.15-2 BrauerCharacterValue</a>
 <a href="chap72.html#X8038FA0480B78243">72.15-3 SizeOfFieldOfDefinition</a>
 <a href="chap72.html#X782400277F6316A4">72.15-4 RealizableBrauerCharacters</a>
</div></div>
<div class="ContSect"> <a href="chap72.html#X7FEEDC0981A22850">72.16 Domains Generated by Class Functions</a>

</div>
</div>

<h3>72 Class Functions</h3>

This chapter describes operations for class functions of finite groups. For operations concerning character tables, see Chapter <a href="chap71.html#X7B7A9EE881E01C10">71</a>.

Several examples in this chapter require the GAP Character Table Library to be available. If it is not yet loaded then we load it now.

<div class="example"><pre>
gap> LoadPackage( "ctbllib" );
true
</pre></div>

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

<h4>72.1 Why Class Functions?</h4>

In principle it is possible to represent group characters or more general class functions by the plain lists of their values, and in fact many operations for class functions work with plain lists of class function values. But this has two disadvantages.

First, it is then necessary to regard a values list explicitly as a class function of a particular character table, by supplying this character table as an argument. In practice this means that with this setup, the user has the task to put the objects into the right context. For example, forming the scalar product or the tensor product of two class functions or forming an induced class function or a conjugate class function then needs three arguments in this case; this is particularly inconvenient in cases where infix operations cannot be used because of the additional argument, as for tensor products and induced class functions.

Second, when one says that <q>χ is a character of a group G</q> then this object χ carries a lot of information. χ has certain properties such as being irreducible or not. Several subgroups of G are related to χ, such as the kernel and the centre of χ. Other attributes of characters are the determinant and the central character. This knowledge cannot be stored in a plain list.

For dealing with a group together with its characters, and maybe also subgroups and their characters, it is desirable that GAP keeps track of the interpretation of characters. On the other hand, for using characters without accessing their groups, such as characters of tables from the GAP table library, dealing just with values lists is often sufficient. In particular, if one deals with incomplete character tables then it is often necessary to specify the arguments explicitly, for example one has to choose a fusion map or power map from a set of possibilities.

The main idea behind class function objects is that a class function object is equal to its values list in the sense of <code class="func">\=</code> (<a href="chap31.html#X7EF67D047F03CA6F">31.11-1</a>), so class function objects can be used wherever their values lists can be used, but there are operations for class function objects that do not work just with values lists. GAP library functions prefer to return class function objects rather than returning just values lists, for example <code class="func">Irr</code> (<a href="chap71.html#X873B3CC57E9A5492">71.8-2</a>) lists consist of class function objects, and <code class="func">TrivialCharacter</code> (<a href="chap72.html#X86129DC37C55E4D6">72.7-1</a>) returns a class function object.

Here is an example that shows both approaches. First we define some groups.

<div class="example"><pre>
gap> S4:= SymmetricGroup( 4 );; SetName( S4, "S4" );
gap> D8:= SylowSubgroup( S4, 2 );; SetName( D8, "D8" );
</pre></div>

We do some computations using the functions described later in this Chapter, first with class function objects.

<div class="example"><pre>
gap> irrS4:= Irr( S4 );;
gap> irrD8:= Irr( D8 );;
gap> chi:= irrD8[4];
Character( CharacterTable( D8 ), [ 1, -1, 1, -1, 1 ] )
gap> chi * chi;
Character( CharacterTable( D8 ), [ 1, 1, 1, 1, 1 ] )
gap> ind:= chi ^ S4;
Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] )
gap> List( irrS4, x -> ScalarProduct( x, ind ) );
[ 0, 1, 0, 0, 0 ]
gap> det:= Determinant( ind );
Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] )
gap> cent:= CentralCharacter( ind );
ClassFunction( CharacterTable( S4 ), [ 1, -2, -1, 0, 2 ] )
gap> rest:= Restricted( cent, D8 );
ClassFunction( CharacterTable( D8 ), [ 1, -2, -1, -1, 2 ] )
</pre></div>

Now we repeat these calculations with plain lists of character values. Here we need the character tables in some places.

<div class="example"><pre>
gap> tS4:= CharacterTable( S4 );;
gap> tD8:= CharacterTable( D8 );;
gap> chi:= ValuesOfClassFunction( irrD8[4] );
[ 1, -1, 1, -1, 1 ]
gap> Tensored( [ chi ], [ chi ] )[1];
[ 1, 1, 1, 1, 1 ]
gap> ind:= InducedClassFunction( tD8, chi, tS4 );
ClassFunction( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] )
gap> List( Irr( tS4 ), x -> ScalarProduct( tS4, x, ind ) );
[ 0, 1, 0, 0, 0 ]
gap> det:= DeterminantOfCharacter( tS4, ind );
ClassFunction( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] )
gap> cent:= CentralCharacter( tS4, ind );
ClassFunction( CharacterTable( S4 ), [ 1, -2, -1, 0, 2 ] )
gap> rest:= Restricted( tS4, cent, tD8 );
ClassFunction( CharacterTable( D8 ), [ 1, -2, -1, -1, 2 ] )
</pre></div>

If one deals with character tables from the GAP table library then one has no access to their groups, but often the tables provide enough information for computing induced or restricted class functions, symmetrizations etc., because the relevant class fusions and power maps are often stored on library tables. In these cases it is possible to use the tables instead of the groups as arguments. (If necessary information is not uniquely determined by the tables then an error is signalled.)

<div class="example"><pre>
gap> s5 := CharacterTable( "A5.2" );; irrs5 := Irr( s5 );;
gap> m11:= CharacterTable( "M11" );; irrm11:= Irr( m11 );;
gap> chi:= TrivialCharacter( s5 );
Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, 1, 1, 1 ] )
gap> chi ^ m11;
Character( CharacterTable( "M11" ), [ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0
] )
gap> Determinant( irrs5[4] );
Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] )
</pre></div>

Functions that compute normal subgroups related to characters have counterparts that return the list of class positions corresponding to these groups.

<div class="example"><pre>
gap> ClassPositionsOfKernel( irrs5[2] );
[ 1, 2, 3, 4 ]
gap> ClassPositionsOfCentre( irrs5[2] );
[ 1, 2, 3, 4, 5, 6, 7 ]
</pre></div>

Non-normal subgroups cannot be described this way, so for example inertia subgroups (see <code class="func">InertiaSubgroup</code> (<a href="chap72.html#X7C3187387C2D9938">72.8-13</a>)) can in general not be computed from character tables without access to their groups.

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

<h5>72.1-1 IsClassFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsClassFunction</code>( <var class="Arg">obj</var> )</td><td class="tdright">( category )</td></tr></table></div>
A class function (in characteristic p) of a finite group G is a map from the set of (p-regular) elements in G to the field of cyclotomics that is constant on conjugacy classes of G.

Each class function in GAP is represented by an immutable list, where at the i-th position the value on the i-th conjugacy class of the character table of G is stored. The ordering of the conjugacy classes is the one used in the underlying character table. Note that if the character table has access to its underlying group then the ordering of conjugacy classes in the group and in the character table may differ (see <a href="chap71.html#X793E0EBF84B07313">71.6</a>); class functions always refer to the ordering of classes in the character table.

Class function objects in GAP are not just plain lists, they store the character table of the group G as value of the attribute <code class="func">UnderlyingCharacterTable</code> (<a href="chap72.html#X81B55C067D123B76">72.2-1</a>). The group G itself is accessible only via the character table and thus only if the character table stores its group, as value of the attribute <code class="func">UnderlyingGroup</code> (<a href="chap71.html#X7FF4826A82B667AF">71.6-1</a>). The reason for this is that many computations with class functions are possible without using their groups, for example class functions of character tables in the GAP character table library do in general not have access to their underlying groups.

There are (at least) two reasons why class functions in GAP are not implemented as mappings. First, we want to distinguish class functions in different characteristics, for example to be able to define the Frobenius character of a given Brauer character; viewed as mappings, the trivial characters in all characteristics coprime to the order of G are equal. Second, the product of two class functions shall be again a class function, whereas the product of general mappings is defined as composition.

A further argument is that the typical operations for mappings such as <code class="func">Image</code> (<a href="chap32.html#X87F4D35A826599C6">32.4-6</a>) and <code class="func">PreImage</code> (<a href="chap32.html#X836FAEAC78B55BF4">32.5-6</a>) play no important role for class functions.

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

<h4>72.2 Basic Operations for Class Functions</h4>

Basic operations for class functions are <code class="func">UnderlyingCharacterTable</code> (<a href="chap72.html#X81B55C067D123B76">72.2-1</a>), <code class="func">ValuesOfClassFunction</code> (<a href="chap72.html#X7FE14712843C6486">72.2-2</a>), and the basic operations for lists (see <a href="chap21.html#X7B202D147A5C2884">21.2</a>).

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

<h5>72.2-1 UnderlyingCharacterTable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ UnderlyingCharacterTable</code>( <var class="Arg">psi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
For a class function <var class="Arg">psi</var> of a group G the character table of G is stored as value of <code class="func">UnderlyingCharacterTable</code>. The ordering of entries in the list <var class="Arg">psi</var> (see <code class="func">ValuesOfClassFunction</code> (<a href="chap72.html#X7FE14712843C6486">72.2-2</a>)) refers to the ordering of conjugacy classes in this character table.

If <var class="Arg">psi</var> is an ordinary class function then the underlying character table is the ordinary character table of G (see <code class="func">OrdinaryCharacterTable</code> (<a href="chap71.html#X8011EEB684848039">71.8-4</a>)), if <var class="Arg">psi</var> is a class function in characteristic p ≠ 0 then the underlying character table is the p-modular Brauer table of G (see <code class="func">BrauerTable</code> (<a href="chap71.html#X8476B25A79D7A7FC">71.3-2</a>)). So the underlying characteristic of <var class="Arg">psi</var> can be read off from the underlying character table.

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

<h5>72.2-2 ValuesOfClassFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ValuesOfClassFunction</code>( <var class="Arg">psi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
is the list of values of the class function <var class="Arg">psi</var>, the i-th entry being the value on the i-th conjugacy class of the underlying character table (see <code class="func">UnderlyingCharacterTable</code> (<a href="chap72.html#X81B55C067D123B76">72.2-1</a>)).

<div class="example"><pre>
gap> g:= SymmetricGroup( 4 );
Sym( [ 1 .. 4 ] )
gap> psi:= TrivialCharacter( g );
Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] )
gap> UnderlyingCharacterTable( psi );
CharacterTable( Sym( [ 1 .. 4 ] ) )
gap> ValuesOfClassFunction( psi );
[ 1, 1, 1, 1, 1 ]
gap> IsList( psi );
true
gap> psi[1];
1
gap> Length( psi );
5
gap> IsBound( psi[6] );
false
gap> Concatenation( psi, [ 2, 3 ] );
[ 1, 1, 1, 1, 1, 2, 3 ]
</pre></div>

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

<h4>72.3 Comparison of Class Functions</h4>

With respect to <code class="func">\=</code> (<a href="chap31.html#X7EF67D047F03CA6F">31.11-1</a>) and <code class="func">\<</code> (<a href="chap31.html#X7EF67D047F03CA6F">31.11-1</a>), class functions behave equally to their lists of values (see <code class="func">ValuesOfClassFunction</code> (<a href="chap72.html#X7FE14712843C6486">72.2-2</a>)). So two class functions are equal if and only if their lists of values are equal, no matter whether they are class functions of the same character table, of the same group but w.r.t. different class ordering, or of different groups.

<div class="example"><pre>
gap> grps:= Filtered( AllSmallGroups( 8 ), g -> not IsAbelian( g ) );
[ <pc group of size 8 with 3 generators>,
 <pc group of size 8 with 3 generators> ]
gap> t1:= CharacterTable( grps[1] ); SetName( t1, "t1" );
CharacterTable( <pc group of size 8 with 3 generators> )
gap> t2:= CharacterTable( grps[2] ); SetName( t2, "t2" );
CharacterTable( <pc group of size 8 with 3 generators> )
gap> CharacterDegrees( t1 );
[ [ 1, 4 ], [ 2, 1 ] ]
gap> irr1:= Irr( grps[1] );;
gap> irr2:= Irr( grps[2] );;
gap> irr1 = irr2;
true
gap> irr1[1];
Character( t1, [ 1, 1, 1, 1, 1 ] )
gap> irr1[5];
Character( t1, [ 2, 0, 0, -2, 0 ] )
gap> irr2[1];
Character( t2, [ 1, 1, 1, 1, 1 ] )
gap> IsSSortedList( irr1 );
false
gap> irr1[1] < irr1[2]; # the triv. character has no '-1'
false
gap> irr1[2] < irr1[5];
true
</pre></div>

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

<h4>72.4 Arithmetic Operations for Class Functions</h4>

Class functions are row vectors of cyclotomics. The additive behaviour of class functions is defined such that they are equal to the plain lists of class function values except that the results are represented again as class functions whenever this makes sense. The multiplicative behaviour, however, is different. This is motivated by the fact that the tensor product of class functions is a more interesting operation than the vector product of plain lists. (Another candidate for a multiplication of compatible class functions would have been the inner product, which is implemented via the function <code class="func">ScalarProduct</code> (<a href="chap72.html#X855FD9F983D275CD">72.8-5</a>). In terms of filters, the arithmetic of class functions is based on the decision that they lie in <code class="func">IsGeneralizedRowVector</code> (<a href="chap21.html#X87ABCEE9809585A0">21.12-1</a>), with additive nesting depth 1, but they do not lie in <code class="func">IsMultiplicativeGeneralizedRowVector</code> (<a href="chap21.html#X7FBCA5B58308C158">21.12-2</a>).

More specifically, the scalar multiple of a class function with a cyclotomic is a class function, and the sum and the difference of two class functions of the same underlying character table (see <code class="func">UnderlyingCharacterTable</code> (<a href="chap72.html#X81B55C067D123B76">72.2-1</a>)) are again class functions of this table. The sum and the difference of a class function and a list that is not a class function are plain lists, as well as the sum and the difference of two class functions of different character tables.

<div class="example"><pre>
gap> g:= SymmetricGroup( 4 );; tbl:= CharacterTable( g );;
gap> SetName( tbl, "S4" ); irr:= Irr( g );
[ Character( S4, [ 1, -1, 1, 1, -1 ] ),
 Character( S4, [ 3, -1, -1, 0, 1 ] ),
 Character( S4, [ 2, 0, 2, -1, 0 ] ),
 Character( S4, [ 3, 1, -1, 0, -1 ] ),
 Character( S4, [ 1, 1, 1, 1, 1 ] ) ]
gap> 2 * irr[5];
Character( S4, [ 2, 2, 2, 2, 2 ] )
gap> irr[1] / 7;
ClassFunction( S4, [ 1/7, -1/7, 1/7, 1/7, -1/7 ] )
gap> lincomb:= irr[3] + irr[1] - irr[5];
VirtualCharacter( S4, [ 2, -2, 2, -1, -2 ] )
gap> lincomb:= lincomb + 2 * irr[5];
VirtualCharacter( S4, [ 4, 0, 4, 1, 0 ] )
gap> IsCharacter( lincomb );
true
gap> lincomb;
Character( S4, [ 4, 0, 4, 1, 0 ] )
gap> irr[5] + 2;
[ 3, 3, 3, 3, 3 ]
gap> irr[5] + [ 1, 2, 3, 4, 5 ];
[ 2, 3, 4, 5, 6 ]
gap> zero:= 0 * irr[1];
VirtualCharacter( S4, [ 0, 0, 0, 0, 0 ] )
gap> zero + Z(3);
[ Z(3), Z(3), Z(3), Z(3), Z(3) ]
gap> irr[5] + TrivialCharacter( DihedralGroup( 8 ) );
[ 2, 2, 2, 2, 2 ]
</pre></div>

The product of two class functions of the same character table is the tensor product (pointwise product) of these class functions. Thus the set of all class functions of a fixed group forms a ring, and for any field F of cyclotomics, the F-span of a given set of class functions forms an algebra.

The product of two class functions of different tables and the product of a class function and a list that is not a class function are not defined, an error is signalled in these cases. Note that in this respect, class functions behave differently from their values lists, for which the product is defined as the standard scalar product.

<div class="example"><pre>
gap> tens:= irr[3] * irr[4];
Character( S4, [ 6, 0, -2, 0, 0 ] )
gap> ValuesOfClassFunction( irr[3] ) * ValuesOfClassFunction( irr[4] );
4
</pre></div>

Class functions without zero values are invertible, the inverse is defined pointwise. As a consequence, for example groups of linear characters can be formed.

<div class="example"><pre>
gap> tens / irr[1];
Character( S4, [ 6, 0, -2, 0, 0 ] )
</pre></div>

Other (somewhat strange) implications of the definition of arithmetic operations for class functions, together with the general rules of list arithmetic (see <a href="chap21.html#X845EEAF083D43CCE">21.11</a>), apply to the case of products involving lists of class functions. No inverse of the list of irreducible characters as a matrix is defined; if one is interested in the inverse matrix then one can compute it from the matrix of class function values.

<div class="example"><pre>
gap> Inverse( List( irr, ValuesOfClassFunction ) );
[ [ 1/24, 1/8, 1/12, 1/8, 1/24 ], [ -1/4, -1/4, 0, 1/4, 1/4 ],
 [ 1/8, -1/8, 1/4, -1/8, 1/8 ], [ 1/3, 0, -1/3, 0, 1/3 ],
 [ -1/4, 1/4, 0, -1/4, 1/4 ] ]
</pre></div>

Also the product of a class function with a list of class functions is not a vector-matrix product but the list of pointwise products.

<div class="example"><pre>
gap> irr[1] * irr{ [ 1 .. 3 ] };
[ Character( S4, [ 1, 1, 1, 1, 1 ] ),
 Character( S4, [ 3, 1, -1, 0, -1 ] ),
 Character( S4, [ 2, 0, 2, -1, 0 ] ) ]
</pre></div>

And the product of two lists of class functions is not the matrix product but the sum of the pointwise products.

<div class="example"><pre>
gap> irr * irr;
Character( S4, [ 24, 4, 8, 3, 4 ] )
</pre></div>

The powering operator <code class="func">\^</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>) has several meanings for class functions. The power of a class function by a nonnegative integer is clearly the tensor power. The power of a class function by an element that normalizes the underlying group or by a Galois automorphism is the conjugate class function. (As a consequence, the application of the permutation induced by such an action cannot be denoted by <code class="func">\^</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>); instead one can use <code class="func">Permuted</code> (<a href="chap21.html#X7B5A19098406347A">21.20-17</a>).) The power of a class function by a group or a character table is the induced class function (see <code class="func">InducedClassFunction</code> (<a href="chap72.html#X7FE39D3D78855D3B">72.9-3</a>)). The power of a group element by a class function is the class function value at (the conjugacy class containing) this element.

<div class="example"><pre>
gap> irr[3] ^ 3;
Character( S4, [ 8, 0, 8, -1, 0 ] )
gap> lin:= LinearCharacters( DerivedSubgroup( g ) );
[ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ),
 Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3), E(3)^2 ] ),
 Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3)^2, E(3) ] ) ]
gap> List( lin, chi -> chi ^ (1,2) );
[ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ),
 Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3)^2, E(3) ] ),
 Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3), E(3)^2 ] ) ]
gap> Orbit( GaloisGroup( CF(3) ), lin[2] );
[ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3), E(3)^2 ] ),
 Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
 [ 1, 1, E(3)^2, E(3) ] ) ]
gap> lin[1]^g;
Character( S4, [ 2, 0, 2, 2, 0 ] )
gap> (1,2,3)^lin[2];
E(3)
</pre></div>

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

<h5>72.4-1 Characteristic</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Characteristic</code>( <var class="Arg">chi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
The characteristic of class functions is zero, as for all list of cyclotomics. For class functions of a p-modular character table, such as Brauer characters, the prime p is given by the <code class="func">UnderlyingCharacteristic</code> (<a href="chap71.html#X7F58A82F7D88000A">71.9-5</a>) value of the character table.

<div class="example"><pre>
gap> Characteristic( irr[1] );
0
gap> irrmod2:= Irr( g, 2 );
[ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ),
 Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ]
gap> Characteristic( irrmod2[1] );
0
gap> UnderlyingCharacteristic( UnderlyingCharacterTable( irrmod2[1] ) );
2
</pre></div>

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

<h5>72.4-2 ComplexConjugate</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ComplexConjugate</code>( <var class="Arg">chi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GaloisCyc</code>( <var class="Arg">chi</var>, <var class="Arg">k</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Permuted</code>( <var class="Arg">chi</var>, <var class="Arg">pi</var> )</td><td class="tdright">( method )</td></tr></table></div>
The operations <code class="func">ComplexConjugate</code>, <code class="func">GaloisCyc</code>, and <code class="func">Permuted</code> return a class function when they are called with a class function; The complex conjugate of a class function that is known to be a (virtual) character is again known to be a (virtual) character, and applying an arbitrary Galois automorphism to an ordinary (virtual) character yields a (virtual) character.

<div class="example"><pre>
gap> ComplexConjugate( lin[2] );
Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
[ 1, 1, E(3)^2, E(3) ] )
gap> GaloisCyc( lin[2], 5 );
Character( CharacterTable( Alt( [ 1 .. 4 ] ) ),
[ 1, 1, E(3)^2, E(3) ] )
gap> Permuted( lin[2], (2,3,4) );
ClassFunction( CharacterTable( Alt( [ 1 .. 4 ] ) ),
[ 1, E(3)^2, 1, E(3) ] )
</pre></div>

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

<h5>72.4-3 Order</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Order</code>( <var class="Arg">chi</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
By definition of <code class="func">Order</code> (<a href="chap31.html#X84F59A2687C62763">31.10-10</a>) for arbitrary monoid elements, the return value of <code class="func">Order</code> (<a href="chap31.html#X84F59A2687C62763">31.10-10</a>) for a character must be its multiplicative order. The determinantal order (see <code class="func">DeterminantOfCharacter</code> (<a href="chap72.html#X7A292A58827B95B8">72.8-18</a>)) of a character <var class="Arg">chi</var> can be computed as <code class="code">Order( Determinant( <var class="Arg">chi</var> ) )</code>.

<div class="example"><pre>
gap> det:= Determinant( irr[3] );
Character( S4, [ 1, -1, 1, 1, -1 ] )
gap> Order( det );
2
</pre></div>

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

<h4>72.5 Printing Class Functions</h4>

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

<h5>72.5-1 ViewObj</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ViewObj</code>( <var class="Arg">chi</var> )</td><td class="tdright">( method )</td></tr></table></div>
The default <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) methods for class functions print one of the strings <code class="code">"ClassFunction"</code>, <code class="code">"VirtualCharacter"</code>, <code class="code">"Character"</code> (depending on whether the class function is known to be a character or virtual character, see <code class="func">IsCharacter</code> (<a href="chap72.html#X7FE3CD08794051F8">72.8-1</a>), <code class="func">IsVirtualCharacter</code> (<a href="chap72.html#X788DD05C86CB7030">72.8-2</a>)), followed by the <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) output for the underlying character table (see <a href="chap71.html#X7C1941F17BE9FC21">71.13</a>), and the list of values. The table is chosen (and not the group) in order to distinguish class functions of different underlying characteristic (see <code class="func">UnderlyingCharacteristic</code> (<a href="chap71.html#X7F58A82F7D88000A">71.9-5</a>)).

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

<h5>72.5-2 PrintObj</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PrintObj</code>( <var class="Arg">chi</var> )</td><td class="tdright">( method )</td></tr></table></div>
The default <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) method for class functions does the same as <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>), except that the character table is <code class="func">Print</code> (<a href="chap6.html#X7AFA64D97A1F39A3">6.3-4</a>)-ed instead of <code class="func">View</code> (<a href="chap6.html#X851902C583B84CDC">6.3-3</a>)-ed.

Note that if a class function is shown only with one of the strings <code class="code">"ClassFunction"</code>, <code class="code">"VirtualCharacter"</code>, it may still be that it is in fact a character; just this was not known at the time when the class function was printed.

In order to reduce the space that is needed to print a class function, it may be useful to give a name (see <code class="func">Name</code> (<a href="chap12.html#X7F14EF9D81432113">12.8-2</a>)) to the underlying character table.

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

<h5>72.5-3 Display</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Display</code>( <var class="Arg">chi</var> )</td><td class="tdright">( method )</td></tr></table></div>
The default <code class="func">Display</code> (<a href="chap6.html#X83A5C59278E13248">6.3-6</a>) method for a class function <var class="Arg">chi</var> calls <code class="func">Display</code> (<a href="chap6.html#X83A5C59278E13248">6.3-6</a>) for its underlying character table (see <a href="chap71.html#X7C1941F17BE9FC21">71.13</a>), with <var class="Arg">chi</var> as the only entry in the <code class="code">chars</code> list of the options record.

<div class="example"><pre>
gap> chi:= TrivialCharacter( CharacterTable( "A5" ) );
Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] )
gap> Display( chi );
A5

 2 2 2 . . .
 3 1 . 1 . .
 5 1 . . 1 1

 1a 2a 3a 5a 5b
 2P 1a 1a 3a 5b 5a
 3P 1a 2a 1a 5b 5a
 5P 1a 2a 3a 1a 1a

Y.1 1 1 1 1 1
</pre></div>

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

<h4>72.6 Creating Class Functions from Values Lists</h4>

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

<h5>72.6-1 ClassFunction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ClassFunction</code>( <var class="Arg">tbl</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ClassFunction</code>( <var class="Arg">G</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
In the first form, <code class="func">ClassFunction</code> returns the class function of the character table <var class="Arg">tbl</var> with values given by the list <var class="Arg">values</var> of cyclotomics. In the second form, <var class="Arg">G</var> must be a group, and the class function of its ordinary character table is returned.

Note that <var class="Arg">tbl</var> determines the underlying characteristic of the returned class function (see <code class="func">UnderlyingCharacteristic</code> (<a href="chap71.html#X7F58A82F7D88000A">71.9-5</a>)).

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

<h5>72.6-2 VirtualCharacter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ VirtualCharacter</code>( <var class="Arg">tbl</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ VirtualCharacter</code>( <var class="Arg">G</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<code class="func">VirtualCharacter</code> returns the virtual character (see <code class="func">IsVirtualCharacter</code> (<a href="chap72.html#X788DD05C86CB7030">72.8-2</a>)) of the character table <var class="Arg">tbl</var> or the group <var class="Arg">G</var>, respectively, with values given by the list <var class="Arg">values</var>.

It is not checked whether the given values really describe a virtual character.

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

<h5>72.6-3 Character</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Character</code>( <var class="Arg">tbl</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Character</code>( <var class="Arg">G</var>, <var class="Arg">values</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<code class="func">Character</code> returns the character (see <code class="func">IsCharacter</code> (<a href="chap72.html#X7FE3CD08794051F8">72.8-1</a>)) of the character table <var class="Arg">tbl</var> or the group <var class="Arg">G</var>, respectively, with values given by the list <var class="Arg">values</var>.

It is not checked whether the given values really describe a character.

<div class="example"><pre>
gap> g:= DihedralGroup( 8 ); tbl:= CharacterTable( g );
<pc group of size 8 with 3 generators>
CharacterTable( <pc group of size 8 with 3 generators> )
gap> SetName( tbl, "D8" );
gap> phi:= ClassFunction( g, [ 1, -1, 0, 2, -2 ] );
ClassFunction( D8, [ 1, -1, 0, 2, -2 ] )
gap> psi:= ClassFunction( tbl,
> List( Irr( g ), chi -> ScalarProduct( chi, phi ) ) );
ClassFunction( D8, [ -3/8, 9/8, 5/8, 1/8, -1/4 ] )
gap> chi:= VirtualCharacter( g, [ 0, 0, 8, 0, 0 ] );
VirtualCharacter( D8, [ 0, 0, 8, 0, 0 ] )
gap> reg:= Character( tbl, [ 8, 0, 0, 0, 0 ] );
Character( D8, [ 8, 0, 0, 0, 0 ] )
</pre></div>

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

<h5>72.6-4 ClassFunctionSameType</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ClassFunctionSameType</code>( <var class="Arg">tbl</var>, <var class="Arg">chi</var>, <var class="Arg">values</var> )</td><td class="tdright">( function )</td></tr></table></div>
Let <var class="Arg">tbl</var> be a character table, <var class="Arg">chi</var> a class function object (not necessarily a class function of <var class="Arg">tbl</var>), and <var class="Arg">values</var> a list of cyclotomics. <code class="func">ClassFunctionSameType</code> returns the class function ψ of <var class="Arg">tbl</var> with values list <var class="Arg">values</var>, constructed with <code class="func">ClassFunction</code> (<a href="chap72.html#X78F4E23985FCA259">72.6-1</a>).

If <var class="Arg">chi</var> is known to be a (virtual) character then ψ is also known to be a (virtual) character.

<div class="example"><pre>
gap> h:= Centre( g );;
gap> centbl:= CharacterTable( h );; SetName( centbl, "C2" );
gap> ClassFunctionSameType( centbl, phi, [ 1, 1 ] );
ClassFunction( C2, [ 1, 1 ] )
gap> ClassFunctionSameType( centbl, chi, [ 1, 1 ] );
VirtualCharacter( C2, [ 1, 1 ] )
gap> ClassFunctionSameType( centbl, reg, [ 1, 1 ] );
Character( C2, [ 1, 1 ] )
</pre></div>

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

<h4>72.7 Creating Class Functions using Groups</h4>

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

<h5>72.7-1 TrivialCharacter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TrivialCharacter</code>( <var class="Arg">tbl</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TrivialCharacter</code>( <var class="Arg">G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
is the trivial character of the group <var class="Arg">G</var> or its character table <var class="Arg">tbl</var>, respectively. This is the class function with value equal to 1 for each class.

<div class="example"><pre>
gap> TrivialCharacter( CharacterTable( "A5" ) );
Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] )
gap> TrivialCharacter( SymmetricGroup( 3 ) );
Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 1, 1, 1 ] )
</pre></div>

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

<h5>72.7-2 NaturalCharacter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NaturalCharacter</code>( <var class="Arg">G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NaturalCharacter</code>( <var class="Arg">hom</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
If the argument is a permutation group <var class="Arg">G</var> then <code class="func">NaturalCharacter</code> returns the (ordinary) character of the natural permutation representation of <var class="Arg">G</var> on the set of moved points (see <code class="func">MovedPoints</code> (<a href="chap42.html#X85E61B9C7A6B0CCA">42.3-3</a>)), that is, the value on each class is the number of points among the moved points of <var class="Arg">G</var> that are fixed by any permutation in that class.

If the argument is a matrix group <var class="Arg">G</var> in characteristic zero then <code class="func">NaturalCharacter</code> returns the (ordinary) character of the natural matrix representation of <var class="Arg">G</var>, that is, the value on each class is the trace of any matrix in that class.

If the argument is a group homomorphism <var class="Arg">hom</var> whose image is a permutation group or a matrix group then <code class="func">NaturalCharacter</code> returns the restriction of the natural character of the image of <var class="Arg">hom</var> to the preimage of <var class="Arg">hom</var>.

<div class="example"><pre>
gap> NaturalCharacter( SymmetricGroup( 3 ) );
Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 3, 1, 0 ] )
gap> NaturalCharacter( Group( [ [ 0, -1 ], [ 1, -1 ] ] ) );
Character( CharacterTable( Group([ [ [ 0, -1 ], [ 1, -1 ] ] ]) ),
[ 2, -1, -1 ] )
gap> d8:= DihedralGroup( 8 );; hom:= RegularActionHomomorphism( d8 );;
gap> NaturalCharacter( hom );
Character( CharacterTable( <pc group of size 8 with 3 generators> ),
[ 8, 0, 0, 0, 0 ] )
</pre></div>

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

<h5>72.7-3 PermutationCharacter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PermutationCharacter</code>( <var class="Arg">G</var>, <var class="Arg">D</var>, <var class="Arg">opr</var> )</td><td class="tdright">( operation )</td></tr></table></div>
--> --------------------

--> maximum size reached

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

quality100%

¤ Dauer der Verarbeitung: 0.55 Sekunden (vorverarbeitet) ¤

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.