[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Element Operations

Subsections

Arithmetic

In the list of arithmetic operations below x and y denote class functions in the same ring, and a denotes a scalar, which is any element coercible into a cyclotomic field. Also, j denotes an integer.

+ y : AlgChtrElt -> AlgChtrElt
- y : AlgChtrElt -> AlgChtrElt

x + y : AlgChtrElt, AlgChtrElt -> AlgChtrElt
x - y : AlgChtrElt, AlgChtrElt -> AlgChtrElt
x * y : AlgChtrElt, AlgChtrElt -> AlgChtrElt

a * x : FldCycElt, AlgChtrElt -> AlgChtrElt
x ^ j : AlgChtrElt, RngIntElt -> AlgChtrElt

Predicates and Booleans

The following Boolean-valued functions are available. Note that with the exception of in, notin, IsReal and IsFaithful, these functions use the table of irreducible characters, which will be created if it is not yet available.

a in F : FldFunElt, FldFun -> BoolElt
a notin F : FldFunElt, FldFun -> BoolElt

x eq y : AlgChtrElt, AlgChtrElt -> BoolElt
x ne y : AlgChtrElt, AlgChtrElt -> BoolElt

IsOne(x) : AlgChtrElt -> BoolElt
IsMinusOne(x) : AlgChtrElt -> BoolElt
IsZero(x) : AlgChtrElt -> BoolElt

x in y : AlgChtrElt, AlgChtrElt -> BoolElt
Returns true if the inner product of class functions x and y is non-zero, otherwise false. If x is irreducible and y is a character, this tests whether or not x is a constituent of y.
x notin y : AlgChtrElt, AlgChtrElt -> BoolElt
Returns true if the inner product of class functions x and y is zero, otherwise false. If x is irreducible and y is a character, this tests whether or not x is not a constituent of y. Returns true if the character x is not a constituent of the character y, otherwise false.
IsCharacter(x) : AlgChtrElt -> BoolElt
Returns true if the class function x is a character, otherwise false. A class function is a character if and only if all inner products with the irreducible characters are non-negative integers.
IsGeneralizedCharacter(x) : AlgChtrElt -> BoolElt
Returns true if the class function x is a generalized character, otherwise false. A class function is a generalized character if and only if all inner products with the irreducible characters are integers.
IsIrreducible(x) : AlgChtrElt -> BoolElt
Returns true if the character x is an irreducible character, otherwise false.
IsLinear(x) : AlgChtrElt -> BoolElt
Returns true if the character x is a linear character, otherwise false.
IsFaithful(x) : AlgChtrElt -> BoolElt
Returns true if the character x is faithful, i.e. has trivial kernel, otherwise false.
IsReal(x) : AlgChtrElt -> BoolElt
Returns true if the character x is a real character, i.e. takes real values on all of the classes of G, otherwise false.

Accessing Class Functions

In this subsection T is a character table, and x is any class function. A character table is an enumerated sequence of characters that has a special print function attached. In particular, its entries can be accessed with the ordinary sequence indexing operations.

T[i] : TabChtr, RngIntElt -> AlgChtrElt
Given the table T of ordinary characters of G, return the i-th character of G, where i is an integer in the range [1...k].
T[i][j] : TabChtr, RngIntElt, RngIntElt -> FldCycElt
The value of the i-th irreducible character (from the character table T) on the j-th conjugacy class of G.
# T : SeqEnum -> RngIntElt
Given a character table T (or any sequence of characters), return the number of entries.
x(g) : AlgChtrElt, GrpElt -> FldCycElt
g @ x : GrpElt, AlgChtrElt -> FldCycElt
The value of the class function x on the element g of G.
x[i] : AlgChtrElt, RngIntElt -> FldCycElt
The value of the class function x on the i-th conjugacy class of G.
# x : AlgChtrElt -> RngIntElt
Given a class function x on G return its length (which equals the number of conjugacy classes of the group G).

Conjugation of Class Functions

x ^ g : AlgChtrElt, GrpElt -> AlgChtrElt
Given a class function x on a normal subgroup N of the group G, and an element g of G, construct the conjugate class function xg of x which is defined as follows: xg(n) = x( g - 1ng), for all n in N.
x ^ H : AlgChtrElt, Grp -> { AlgChtrElt }
Given a class function x on a normal subgroup N of the group G, and a subgroup H of G, construct the sequence of conjugates of x under the action of the subgroup H. The action of an element of H on x is that defined in the previous function.
GaloisConjugate(x, j) : AlgChtrElt, RngIntElt -> AlgChtrElt
Let Q(x) be the subfield of Qm generated by Q and the values of the G-character x. This function returns the Galois conjugate xj of x under the action of the element of the Galois group Gal(Q(x)/Q) determined by the integer j. The integer j must be coprime to m.
GaloisOrbit(x) : AlgChtrElt -> { AlgChtrElt }
Let Q(x) be the subfield of Qm generated by Q and the values of the G-character x. This function returns the sequence of Galois conjugates of x under the action of the Galois group Gal(Q(x)/Q).
ClassPowerCharacter(x, j) : AlgChtrElt, RngIntElt -> AlgChtrElt
Given a class function x on the group G and a positive integer j, construct the class function xj which is defined as follows: xj(g) = x(gj).

Functions Returning a Scalar

Degree(x) : AlgChtrElt -> RngIntElt
The degree of the class function x, i.e. the value of x on the identity element of G.
InnerProduct(x, y) : AlgChtrElt, AlgChtrElt -> FldCycElt
The inner product of the class functions x and y, where x and y are class functions belonging to the same character ring.
Order(x) : AlgChtrElt -> RngIntElt
Given a linear character of the group G, determine the order of x as an element of the group of linear characters of G.
Norm(x) : AlgChtrElt -> FldCycElt
Norm of the class function x (which is the inner product with itself).
Schur(x, k) : AlgChtrElt, RngIntElt -> FldCycElt
Indicator(x) : AlgChtrElt -> FldCycElt
Given class function x and a positive integer k, return the generalised Frobenius--Schur indicator which is defined as follows: Suppose g is some element of G, and set Tk(g) = |{ h∈G | hk = g}|. The value of Schur(x, k) is the coefficient ax in the expression Tk = ∑ x∈Irr(G) ax x.

The call Indicator(x) is equivalent to Schur(x,2).

StructureConstant(G, i, j, k) : Grp, RngIntElt, RngIntElt, RngIntElt -> RngIntElt
The structure constant ai, j, k for the centre of the group algebra of the group G. If Ki is the formal sum of the elements of the i-th conjugacy class, ai, j, k is defined by the equation Ki * Kj = ∑k ai, j, k * Kk.

The Schur Index

Magma incorporates functions for computing the Schur index of an ordinary irreducible character over various number fields and local fields. The routines below are all based on the function SchurIndices(x), which computes the Schur Indices of the given character over all the completions of the rationals.

The algorithm is based on calculations with characters, groups and fields, and does not compute representations.

The algorithm was devised by Gabi Nebe and Bill Unger, with code written by Bill Unger. The extension to compute a Schur index over a number field was written by Claus Fieker.

The construction of the previous example is used in the following two intrinsics.

SchurIndex(x) : AlgChtrElt -> RngIntElt
SchurIndex(x, Q) : AlgChtrElt, FldRat -> RngIntElt
SchurIndex(x, F) : AlgChtrElt, FldAlg -> RngIntElt
The Schur index of the character x over the given field. When no field is given, the Schur index over the rationals is returned. The character x must be a complex irreducible character. The field F must be an absolute number field.
SchurIndices(x) : AlgChtrElt -> SeqEnum
SchurIndices(x, Q) : AlgChtrElt, FldRat -> SeqEnum
SchurIndices(x, F) : AlgChtrElt, FldAlg -> SeqEnum
SchurIndices(C, s, F) : FldAlg, SeqEnum, FldAlg -> SeqEnum
Compute the Schur indices of the character x over the completions of the given field. The character x must be a complex irreducible character. The field F must be an absolute number field. When no field is specified the rational field is assumed. The last form takes the character field, C, and the output from SchurIndices(x), s, as well as a number field. This is sufficient to compute the Schur indices over the number field without repeating group and character computations when a number of fields are being considered for one character.

The return value is a sequence of pairs. Each pair gives a completion at which the Schur index is not 1, followed by the Schur index over the complete field. For the rational field, a completion is specified by an integer. The integer zero specifies the archimedean completion (the real numbers), while a prime p specifies the p-adic field Qp. When a number field is given, the completions are specified by a place of the field, an object of type PlcNumElt.

If the character has Schur index 1 over the given field the return value will be an empty sequence. Otherwise the Schur index over the given field is the least common multiple of the second entries of the tuples returned.


Example Chtr_SchurIndex (H91E3)

We first look at the faithful irreducible character of the Dihedral group of order 8. It has Schur index 1.

> T := CharacterTable(SmallGroup(8, 3));
> T[5];
( 2, -2, 0, 0, 0 )
> SchurIndex(T[5]);
1
> SchurIndices(T[5]);
[]
The corresponding character of the quaternion group of order 8 has non-trivial Schur index.

> T := CharacterTable(SmallGroup(8, 4));
> T[5];
( 2, -2, 0, 0, 0 )
> SchurIndex(T[5]);
2
> SchurIndices(T[5]);
[ <0, 2>, <2, 2> ]
The Schur index is 2 over the real numbers and Q2. For all odd primes p, the Schur index over Qp is 1. We look at the Schur index of this character over some number fields. First we look at some cyclotomic fields.

> [SchurIndex(T[5], CyclotomicField(n)):n in [3..20]];
[ 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1 ]
> SchurIndices(T[5], CyclotomicField(7));
[ <Place at Prime Ideal
Two element generators:
  [2, 0, 0, 0, 0, 0]
  [1, 1, 0, 1, 0, 0], 2>, <Place at Prime Ideal
Two element generators:
  [2, 0, 0, 0, 0, 0]
  [1, 0, 1, 1, 0, 0], 2> ]
The cyclotomic field of order 7 gives Schur index 2. An archimedean completion of this field is necessarily the field of complex numbers, hence no infinite places give Schur index greater than 1. There are now two 2-adic completions which give Schur index 2.

> P<t> := PolynomialRing(Rationals());
> F := ext<Rationals()|t^3-2>;
> SchurIndex(T[5], F);
2
> SchurIndices(T[5], F);
[ <1st place at infinity, 2>, <Place at Prime Ideal
Two element generators:
  [2, 0, 0]
  [0, 1, 0], 2> ]
For the non-normal field F, one archimedean completion is real, the other complex. Thus the real field features in the output of SchurIndices, along with the 2-adic completion.

Example Chtr_recipe-for-schur-index (H91E4)

We will use a general construction for a character with given Schur index over the rationals to construct a character with Schur index 6. Given an integer n ge1, we select a prime p such that p = kn + 1 where k and n are coprime. We take an integer a such that a has order n modulo p. We then consider the metacyclic group G = < <x, y| xn2, yp, yx = ya >. The order of G is n2p. The subgroup of G generated by xn and y is cyclic, normal and self-centralizing in G with order np. If λis any faithful linear character of this subgroup, then λG is an irreducible character of G with Schur index n over the rational field. The correctness of this construction is proved in Lemma 3 of [Tur01].

We construct G in two stages. First as a finitely presented group as described above. Then we convert to a PC-presentation for further computations. We take n=6, p=7 and a = 3.

> G1 := Group<x,y|x^36, y^7, y^x = y^3>;
> G, f := SolubleQuotient(G1, 36*7);
> x := f(G1.1); y := f(G1.2);
> C := sub<G|x^6,y>;
> IsCyclic(C);
true
> IsNormal(G, C);
true
> Centralizer(G,C) eq C;
true
> exists(l){l:l in LinearCharacters(C)|IsFaithful(l)};
true;
> c := Induction(l, G);
> IsIrreducible(c);
true
> Degree(c);
6
> CharacterField(c);
Cyclotomic Field of order 3 and degree 2 in sparse
representation
> SchurIndex(c);
6

SchurIndexGroup(n: parameters) : RngIntElt -> GrpPC
    Prime: RngIntElt                    Default: 
Return a group having a faithful character with Schur index n over the rational field. The construction used is as in the previous example. The parameter Prime may be used to supply the prime p. (The necessary conditions on p are not checked. If these conditions are not met, an error is possible.) If Prime is not set, then the least prime meeting the conditions is used.
CharacterWithSchurIndex(n: parameters) : RngIntElt -> AlgChtrElt. GrpPC
    Prime: RngIntElt                    Default: 
Return a character with Schur index n over the rational field. The construction used is as in the previous example. The second return value is the group of the character, equal to SchurIndexGroup(n). The parameter Prime is as for SchurIndexGroup.

Attribute

AssertAttribute(x, "IsCharacter", b) : AlgChtrElt, MonStgElt, BoolElt ->
Procedure that, given a class function x and a Boolean value b, stores with x the information that the value of the predicate IsCharacter(x) equals b.

Induction, Restriction and Lifting

Induction(x, G) : AlgChtrElt, Grp -> AlgChtrElt
Induction(Q, G) : SeqEnum[AlgChtrElt], Grp -> SeqEnum[AlgChtrElt]
Given a class function x on the subgroup H of the group G, construct the class function obtained by induction of x to G. Note that if x is a character of H, then Induction(x, G) will return a character of G.

The Induction command may also be used to induce a sequence of characters of a particular subgroup (such as a character table) to the given supergroup.

LiftCharacter(c, f, G) : AlgChtrElt, Map, Grp -> AlgChtrElt
Given a class function c of the quotient group Q of the group G and the natural homomorphism f : G -> Q, lift c to a class function of G.
LiftCharacters(T, f, G) : [AlgChtrElt], Map, Grp -> AlgChtrElt
Given a sequence T of class functions of the quotient group Q of the group G and the natural homomorphism f : G -> Q, lift T to a sequence of corresponding class functions of G. Since a character table is just a sequence of class functions which is printed in a special way, this intrinsic may also be applied to it.
Restriction(x, H) : AlgChtrElt, Grp -> AlgChtrElt
Given a class function x on the group G and a subgroup H of G, construct the restriction of x to H (a class function). Note that if x is a character of G, then Restriction(x, H) will return a character of H.

Symmetrization

See [Mur58] or [Fra82] for more details.

Symmetrization(x, p) : AlgChtrElt, [ RngIntElt ] -> AlgChtrElt
Given a class function x and a partition p of n (2≤n≤6), this function returns the symmetrized character with respect to p; the partition must be specified in the form of a sequence of positive integers (adding up to n).
OrthogonalComponent(x, p) : AlgChtrElt, [ RngIntElt ] -> AlgChtrElt
Given a class function x and a partition p of n (2≤n≤6), this function returns the Murnaghan component of the orthogonal symmetrization of x with respect to p; the partition must be specified in the form of a sequence of positive integers (adding up to n). Here x may not be a linear character, and its Frobenius--Schur indicator must be 1.
SymplecticComponent(x, p) : AlgChtrElt, [ RngIntElt ] -> AlgChtrElt
Given a class function x and a partition p of n (2≤n≤6), this function returns the Murnaghan component of the symplectic symmetrization of x with respect to p; the partition must be specified in the form of a sequence of positive integers (adding up to n). Here x may not be a linear character, and its Frobenius--Schur indicator must be -1.
SymmetricComponents(x, n) : AlgChtrElt, RngIntElt -> SetEnum
Given a class function x and an integer n, return the set of symmetrizations of x by all partitions of m with 2<m≤n≤5.
OrthogonalComponents(x, n) : AlgChtrElt, RngIntElt -> SetEnum
Given a class function x, return the set of Murnaghan components for orthogonal symmetrizations of x by all partitions of m with 2<m≤n≤6. Here x may not be a linear character, and its Frobenius--Schur indicator must be 1.
SymplecticComponents(x, n) : AlgChtrElt, RngIntElt -> SetEnum
Given a class function x, return the set of Murnaghan components for symplectic symmetrizations of x by all partitions of m with 2<m≤n≤5. Here x may not be a linear character, and its Frobenius--Schur indicator must be -1.

Permutation Character

PermutationCharacter(G) : GrpPerm -> AlgChtrElt
Given group G represented as a permutation group, construct the character of G afforded by the defining permutation representation of G.
PermutationCharacter(G, H) : Grp, Grp -> AlgChtrElt
Given a group G and some subgroup H of G, construct the character of G afforded by the permutation representation of G given by the action of G on the right cosets of H in G.

Composition and Decomposition

Composition(T, q) : [ AlgChtrElt ], [RngElt] -> AlgChtrElt
Given a sequence or table of characters T for the group G and a sequence q of k elements of Qm (possibly Q), create the class function q1 * T1 + ... + qk * Tk, where Ti is the i-th character in T.
Decomposition(T, y) : [AlgChtrElt], AlgChtrElt -> [ FldCycElt ], AlgChtrElt
Given a sequence or table of class functions T for G of length l and a class function y on G, attempt to express y as a linear combination of the elements of T.

The function returns two values: a sequence q=[q1, ..., ql] of cyclotomic field elements and a class function z. For 1≤i≤l, the i-th term of q is defined to be the ratio of inner products (y, Ti)/(Ti, Ti), where Ti is the i-th entry of T. The sequence q determines a class function x=q1.T1 + ... + ql.Tl which will equal y if T is the complete table of irreducible characters. The difference z=y - x is the second return value. If the entries in T are mutually orthogonal, then z is the zero class function if and only if y is a linear combination of the Ti.

Finding Irreducibles

A common approach to finding the irreducible characters of a group is to start with an irreducible character and generate new characters by applying SymmetricComponents, OrthogonalComponents or SymplecticComponents. Then, by examining norms and inner products, it is often possible to identify irreducible characters or at least characters with smaller norms. There are two Magma intrinsics available to help with this task.

RemoveIrreducibles(I, C) : [ AlgChtrElt ], [ AlgChtrElt ] -> [ AlgChtrElt ], [ AlgChtrElt ]
Remove occurrences of the irreducible characters in the sequence I from the characters in the sequence C and look for characters of norm 1 among the reduced characters. Return a sequence of new irreducibles found and the sequence of reduced characters.
ReduceCharacters(I, C) : [ AlgChtrElt ], [ AlgChtrElt ] -> [ AlgChtrElt ], [ AlgChtrElt ]
Make the norms of the characters in the sequence C smaller by computing the differences of appropriate pairs. Return a sequence of new irreducibles found and a sequence of reduced characters.

Example Chtr_A5 (H91E5)

This example shows how the above functions can be used to construct the character table for A5 (compare Isaacs, p64), using only characters on subgroups.

> A := AlternatingGroup(GrpPerm, 5);
> R := CharacterRing(A);
The first character will be the principal character

> T1 := R ! 1;
> T1;
( 1, 1, 1, 1, 1 )
Next construct the permutation character

> pc := PermutationCharacter(A);
> T2 := pc - T1;
> InnerProduct(pc, T1), InnerProduct(T2, T2);
1 1
> T2;
( 4, 0, 1, -1, -1 )
It follows that pc - T1 is an irreducible character

> B := Stabilizer(A, 5);
> r := RootOfUnity(3, CyclotomicField(3));
> S := CharacterRing(B);
> lambda := S ! [1, 1, r, r^2 ];
> IsLinear(lambda);
true
This defines a linear character on a subgroup of index 5 in A

> T3 := Induction(lambda, A);
> InnerProduct(T3, T3);
1
> T3;
( 5, 1, -1, 0, 0 )
Finally we use characters on the cyclic subgroup of order 5:

> K := sub<A |  (1,2,3,4,5) >;
> Y := CharacterTable(K);
> Y;


Character Table of Group K
--------------------------


-------------------------------
Class |   1    2    3    4    5
Size  |   1    1    1    1    1
Order |   1    5    5    5    5
-------------------------------
p  =  5   1    1    1    1    1
-------------------------------
X.1   +   1    1    1    1    1
X.2   0   1   Z1 Z1#2 Z1#3 Z1#4
X.3   0   1 Z1#2 Z1#4   Z1 Z1#3
X.4   0   1 Z1#3   Z1 Z1#4 Z1#2
X.5   0   1 Z1#4 Z1#3 Z1#2   Z1




Explanation of Symbols:
-----------------------


# denotes algebraic conjugation, that is,
# k indicates replacing the root of unity w by w^k


Z1     = -1 - zeta_5 - zeta_5^2 - zeta_5^3


> mu := Induction(Y[2], A);
We subtract what we already know from mu and get a new irreducible. We use decomposition with respect to a sequence.

> _, T4 := Decomposition([T1, T2, T3], mu);
> InnerProduct(T4, T4);
1
> T4;
( 3, -1, 0, (1 + zeta_5^2 + zeta_5^3), (-zeta_5^2 - zeta_5^3) )
> T5 := GaloisConjugate(T4, 2);
> T5;
( 3, -1, 0, (-zeta_5^2 - zeta_5^3), (1 + zeta_5^2 + zeta_5^3) )
Compare this to the standard character table:

> CharacterTable(A);


Character Table of Group A
--------------------------


---------------------------
Class |   1  2  3    4    5
Size  |   1 15 20   12   12
Order |   1  2  3    5    5
---------------------------
p  =  2   1  1  3    5    4
p  =  3   1  2  1    5    4
p  =  5   1  2  3    1    1
---------------------------
X.1   +   1  1  1    1    1
X.2   +   3 -1  0   Z1 Z1#2
X.3   +   3 -1  0 Z1#2   Z1
X.4   +   4  0  1   -1   -1
X.5   +   5  1 -1    0    0




Explanation of Symbols:
-----------------------


#  denotes algebraic conjugation, that is,
# k indicates replacing the root of unity w by w^k


Z1     =(1 + zeta_5^2 + zeta_5^3)

Brauer Characters

Magma has some support for the calculation of Brauer characters. These functions are noted in this section. We anticipate considerable change to the functionality described here in the near future.

A Brauer character modulo p in Magma is represented as a class function (that is, element of a character ring) which is zero on p-singular group elements. In this format the standard character operations of addition, multiplication, induction and restriction all apply directly to Brauer characters as they do to other class functions.

Note that problems associated with choice of lifting from finite fields to complex roots of unity have not yet been dealt with.

BrauerCharacter(x, p) : AlgChtrElt, RngIntElt -> AlgChtrElt
The Brauer character modulo the prime p obtained by setting the value of x on p-singular elements to be zero.
Blocks(T, p) : SeqEnum[AlgChtrElt], RngIntElt -> SeqEnum, SeqEnum
When T is the full ordinary character table of a group, return the partition of T into p-blocks, where p is a given prime. The partition is returned as a sequence of sets of integers which give the blocks by the positions of the characters in T. The second return value is the corresponding sequence of defects of the blocks. The blocks are ordered first by decreasing defect, second by first character in the block.

Example Chtr_brauer (H91E6)

We give an example of the use of these Brauer character functions. We consider the 3-modular characters of the Higman-Sims simple group.

> load hs176;
> T := CharacterTable(G);
> Blocks(T,3);
[
  { 1, 2, 5, 10, 18, 19, 21, 23, 24 },
  { 3, 4, 6, 7, 11, 12, 14, 15, 20 },
  { 8, 13, 16 },
  { 9 },
  { 17 },
  { 22 }
]
[ 2, 2, 1, 0, 0, 0 ]
The characters T[8], T[13], T[16] are the ordinary irreducible characters in a 3-block of defect one. In such a small block the two ordinary irreducibles of minimal degree will restrict to modular irreducibles.

> [Degree(T[i]): i in [8, 13, 16]];
[ 231, 825, 1056 ]
> BrauerCharacter(T[8], 3);
( 231, 7, -9, 0, 15, -1, -1, 6, 1, 1, 0, 0, 0, -1, -1, -1,
2, 1, 0, 0, 0, 0, 0, 0 )
> BrauerCharacter(T[13], 3);
( 825, 25, 9, 0, -15, 1, 1, 0, -5, 0, 0, 0, -1, 1, 1, 1, 0,
-1, 0, 0, 0, 0, 0, 0 )
> $1 + $2 eq BrauerCharacter(T[16], 3);
true
The projective indecomposable characters corresponding to these Brauer irreducible characters are as follows.

> T[8] + T[16];
( 1287, 39, -9, 0, 15, -1, -1, 12, -3, 2, 0, 0, -1, -1, -1,
-1, 4, 1, 0, 0, 0, 0, 0, 0 )
> T[13] + T[16];
( 1881, 57, 9, 0, -15, 1, 1, 6, -9, 1, 0, 0, -2, 1, 1, 1, 2,
-1, 0, 0, 0, 0, 0, 0 )
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013