The aim of this GAP package is to provide functions to compute information about p-blocks of groups only from character tables. This means that we know the ordinary character table t of the finite group G, say, and that we know the ordinary character table of some subgroup H of G, together with the class fusion that describes the embedding of H in G, but we cannot assume that G is given or that the p-modular character table of G is known. If such information is actually available then more operations may return non-fail results: If G is known via the attribute UnderlyingGroup (Reference: UnderlyingGroup for character tables) of the character table in question then calling DefectGroup (3.4-2) makes sense, and if the p-modular character table of G is known then calling IBr (3.3-6) for the block object in question makes sense.
For example, the distribution of the irreducible characters of t to p-blocks can be computed with PrimeBlocks (Reference: PrimeBlocks). Note that this information depends on t: When we talk about "the b-th p-block of the character table t" then this means that the list Irr(t) contains characters of exactly b-1 other p-blocks before the first character of the block in question appears.
It is clear that the character theoretic setup does not allow us to perform block theoretic computations with (ideals of) group rings. Only questions about the centre of a group ring may make sense, for example a block idempotent can be represented by a class function of the given character table (see CoefficientsOfOsimaIdempotent (3.3-13)), which is interpreted as the coefficient vector w.r.t. the basis of class sums, that is, the i-th entry is the coefficient of the the sum over the i-th conjugacy class.
Some definitions can be motivated by the identification of p-blocks with ideals of group rings, in this context it is natural to talk about the dimension (see Dimension (3.3-9)) or the kernel (see ClassPositionsOfKernel (3.3-11)) of a block. In this sense, we take the pragmatic viewpoint stated in [Nav98, p. 57]: "Most authors write B = e_B FG. We will also use this notation when we find it convenient." (Here B is a p-block of the group G, F is a field of characteristic p specified in the given p-modular system (see Section 3.2), and e_B is the block idempotent (see CoefficientsOfOsimaIdempotent (3.3-13)) of B.)
"Let (K, R, F) be a p-modular system for the group G." Many statements in modular representation theory start with this sentence or a similar one, where p is a prime integer, R is a complete discrete valuation ring with quotient field K of characteristic zero and F = R / M is a field of characteristic p, for a fixed maximal ideal M, say, of R.
For computational purposes, it is useful to choose the p-modular system in a specific way, as is described in [LP10, Section 4.2] and to some extent also in [JLPW95, Sections 2-5]. The idea is as follows. For positive integers m, we set ζ_m = exp( 2 π i / m ). The set of complex roots of unity of finite order coprime to p consists exactly of the powers of all ζ_m, where m is coprime to p. We fix a bijection from this set to the nonzero elements in finite extensions of the field with p elements, such that the restriction of this map to the m-th roots of unity (for any integer m that is coprime to p) defines a ring homomorphism * from ℤ[ζ_m] into those finite fields of characteristic p that contain elements of multiplicative order m. More generally, we can take the union of the rings ℤ_p[ζ_m] as the domain of *, where ℤ_p is the ring of of p-local numbers in ℚ.
For a group G whose exponent has p'-part m, this setup allows us to lift eigenvalues of p-modular representations of G to ℤ[ζ_m] and thus to compute Brauer character values in this ring from matrices over finite fields (see BrauerCharacterValue (Reference: BrauerCharacterValue)). Moreover, this setup holds also for subgroups of G, so we can restrict and induce Brauer characters via the class fusions in question.
We do not need the p-modular system (K, R, F) explicitly for actual GAP computations. We can think of R as the completion of a valuation ring in ℚ(ζ_m), and the kernel of the map * is the maximal ideal M of R. The map * is implemented via the function FrobeniusCharacterValueExt (4.2-3) (which generalizes FrobeniusCharacterValue (Reference: FrobeniusCharacterValue)), the images are elements of finite fields in the sense of IsFFE (Reference: IsFFE). If we are interested in the interpretation of finite field elements in terms of polynomials then ReductionToFiniteField (4.2-4) can be used. See also Chapter Reference: Cyclotomic Numbers for more details how elements of cyclotomic fields are handled by GAP.
Note that the Brauer characters of G, which depend on the choice of the ideal M, are uniquely determined in our setup. Also the question whether a given conjugacy class is a defect class of some p-block can be decided, but may require explicit computations of images under the map *, and this can be a hard problem. On the other hand, questions such as the distribution of the ordinary irreducible characters of G into p-blocks can be decided without computations in finite fields, and these questions are not computationally hard (see PrimeBlocks (Reference: PrimeBlocks)); the same holds for the question whether some algebraic conjugate of a given conjugacy class is a defect class of some p-block (see Section 3.4).
Lemma: Let R be the ring of algebraic integers in ℂ, p be a prime integer, and M be a maximal ideal in R that contains p R. For positive integers m, set ζ_m = exp( 2 π i / m ). Consider α ∈ R ∩ ℚ(ζ_m) such that all algebraic conjugates of α lie in M. Then α lies in every maximal ideal of R that contains p R, and we have α^k ∈ p R, where k is the degree of the minimal polynomial of α over ℚ. Moreover, if p does not divide m then α ∈ p R.
Proof: (see [LP10, proof of Theorem 4.4.8], [Nav98, proof of Theorem 3.2], or [Isa76, Theorem (15.18)]) Let A denote the set of algebraic conjugates of α (thus |A| = k holds), and set f = ∏_{a ∈ A} (X-a) ∈ ℚ[X]. All coefficients except the leading one lie in M ∩ ℚ = M ∩ R ∩ ℚ = M ∩ ℤ = p ℤ, thus 0 = f(α) ≡ α^k mod p R. Since maximal ideals are prime, α lies in any maximal ideal of R containing p R. If p does not divide m then p does not ramify in ℤ[ζ_m] = R ∩ ℚ(ζ_m), see [Was97, Proposition 2.3]. Thus p R has a unique factorization of the form P_1 P_2 ⋯ P_l, for prime ideals P_i in R which are pairwise different. Since the ideal α^k R = (α R)^k is contained in p R, each P_i divides (α R)^k and hence α R, which means α ∈ p R.
A well-known application of this lemma is the decision whether two given ordinary irreducible characters χ, ψ of a group G, say, belong to the same p-block, that is, whether the corresponding central characters ω_{χ}, ω_{ψ} are congruent modulo the fixed maximal ideal M of R. It is sufficient to test this property for p-regular elements of G (see [LP10, proof of Theorem 4.4.8]). In other words, if ω_{χ} and ω_{ψ} are not congruent modulo M then there is a class C of p-regular elements in G such that (ω_{χ} - ω_{ψ})(C^+) ∉ M, where C^+ ∈ RG denotes the sum of elements in C. Hence all we have to check is whether (ω_{χ} - ω_{ψ})(C^+)/p is an algebraic integer, for representatives C of families of algebraic conjugate classes of p-regular elements in G. See PrimeBlocks (Reference: PrimeBlocks) for more information about the GAP implementation, and the statements cited in the above proof for variants of this theorem.
Similarly, induced blocks can be computed by inducing central characters. Note that in this case, we cannot restrict the comparison to p-regular classes, because the values at p-singular classes may yield that no induced block is defined, see [LP10, Theorem 4.7.7]. See also the examples in Section 3.8 for details.
Another application of the lemma is the computation of defect classes up to Galois conjugacy (see Section 3.4).
This section introduces GAP objects that represent p-blocks of character tables. One may argue that such objects are not necessary because one can simply replace the object that represents the b-th p-block of the character table t by the triple [ t, p, b ]. Another argument against these objects is that the documentation of functions for them is longer than the GAP code that implements them. On the other hand, such objects are convenient as inputs and outputs of operations, and for caching results of computations as values of attributes, such as Irr (3.3-5) and IBr (3.3-6).
Thus we offer such GAP objects, but we offer also variants of the relevant functions that accept the arguments t, p, b instead.
See Section 3.3-14 for technical details.
‣ Block( tbl, p, b ) | ( operation ) |
For an ordinary character table tbl, a prime integer p, and a positive integer b, Block returns the block object that represents the b-th p-block of tbl if this block exists, otherwise fail is returned.
gap> Block( CharacterTable( "A5" ), 2, 1 ); Block( CharacterTable( "A5" ), 2, 1 ) gap> Block( CharacterTable( "A5" ), 2, 3 ); fail
‣ UnderlyingCharacterTable( B ) | ( attribute ) |
‣ UnderlyingCharacteristic( B ) | ( attribute ) |
‣ NumberOfBlock( B ) | ( attribute ) |
These are the defining attributes of the block object B. There are no methods for computing their values, the values must be set upon creation of the block object.
For the b-th p-block of the character table t, the values of UnderlyingCharacterTable, UnderlyingCharacteristic, and NumberOfBlock are t, p, and b, respectively.
gap> b:= Block( CharacterTable( "A5" ), 2, 1 ); Block( CharacterTable( "A5" ), 2, 1 ) gap> UnderlyingCharacterTable( b ); CharacterTable( "A5" ) gap> UnderlyingCharacteristic( b ); 2 gap> NumberOfBlock( b ); 1
‣ PrincipalBlock( tbl, p ) | ( operation ) |
For an ordinary character table tbl and a prime integer PrincipalBlock returns the block object for the p-block of tbl that contains the trivial character of tbl.
Note that the trivial character need not be the first character in the list of irreducibles of tbl, so the principal block need not have number 1.
gap> PrincipalBlock( CharacterTable( "A5" ), 2 ); Block( CharacterTable( "A5" ), 2, 1 )
‣ PBlocks( tbl, p ) | ( function ) |
For an ordinary character table tbl and a prime integer p, PBlocks returns the list of block objects that represent the p-blocks of tbl.
gap> PBlocks( CharacterTable( "A5" ), 2 ); [ Block( CharacterTable( "A5" ), 2, 1 ), Block( CharacterTable( "A5" ), 2, 2 ) ]
‣ Irr( B ) | ( attribute ) |
‣ Irr( ordtbl, p, b ) | ( operation ) |
The arguments can be either a block object B which represents the b-th p-block of the ordinary character table ordtbl, or the three values ordtbl, p, and b.
Irr returns the sublist of those irreducible characters of ordtbl that belong to the block, in the same ordering as in the Irr (Reference: Irr) list of ordtbl.
gap> irr:= Irr( Block( CharacterTable( "A5" ), 2, 1 ) ); [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), Character( CharacterTable( "A5" ), [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ), Character( CharacterTable( "A5" ), [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ), Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ] gap> irr = Irr( CharacterTable( "A5" ), 2, 1 ); true
‣ IBr( B ) | ( attribute ) |
‣ IBr( modtbl, b ) | ( operation ) |
The arguments can be either a block object B which represents the b-th p-block of the ordinary character table whose p-modular Brauer table is modtbl, or the two values modtbl and b.
IBr returns the sublist of those irreducible characters of modtbl that belong to the block, in the same ordering as in the Irr (Reference: Irr) list of modtbl.
If B is given, it may happen that the irreducible p-modular Brauer characters for the character table that defines B are not available. In this case, IBr returns fail.
gap> ibr:= IBr( Block( CharacterTable( "A5" ), 2, 1 ) ); [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ), Character( BrauerTable( "A5", 2 ), [ 2, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ), Character( BrauerTable( "A5", 2 ), [ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ) ] gap> ibr = IBr( CharacterTable( "A5" ) mod 2, 1 ); true gap> IBr( Block( CharacterTable( "M" ), 2, 1 ) ); fail
‣ DecompositionMatrix( B ) | ( attribute ) |
For a p-block B of a character table t, say. DecompositionMatrix returns the decomposition matrix of B, that is, the matrix whose rows and columns are indexed by the ordinary irreducible characters and the p-modular Brauer characters, respectively, that belong to B.
If the p-modular character table of t is not known then fail is returned.
A variant without block objects is DecompositionMatrix (Reference: DecompositionMatrix).
gap> DecompositionMatrix( Block( CharacterTable( "A5" ), 2, 1 ) ); [ [ 1, 0, 0 ], [ 1, 0, 1 ], [ 1, 1, 0 ], [ 1, 1, 1 ] ] gap> DecompositionMatrix( Block( CharacterTable( "A5" ), 2, 2 ) ); [ [ 1 ] ] gap> DecompositionMatrix( Block( CharacterTable( "M" ), 2, 1 ) ); fail
‣ DimensionsOfDecompositionMatrix( B ) | ( attribute ) |
For a p-block B of a character table t, say. DimensionsOfDecompositionMatrix returns the list [ k(B), l(B) ] of the numbers of rows and columns of the decomposition matrix of B. That is, k(B) is the number of ordinary irreducible characters in B, and l(B) is the number of irreducible Brauer characters in B.
Note that these numbers can be computed from the ordinary character table t, whereas DecompositionMatrix (3.3-7) requires the irreducible p-modular Brauer characters of t.
gap> b:= Block( CharacterTable( "M" ), 2, 1 );; gap> DimensionsOfDecompositionMatrix( b ); [ 183, 55 ]
‣ Dimension( B ) | ( attribute ) |
The dimension of the p-block B is ∑_{χ} χ(1)^2, where the summation runs over the ordinary irreducible characters χ of B.
This is the dimension of the algebra e FG, where e is the block idempotent of B (see CoefficientsOfOsimaIdempotent (3.3-13)) and G is the underlying group of B.
(For details, see [Nav98, Thm. 3.14].)
gap> List( PBlocks( CharacterTable( "2.A5" ), 3 ), Dimension ); [ 42, 9, 9, 24, 36 ]
‣ CentralCharacter( B ) | ( attribute ) |
‣ CentralCharacter( tbl, p, b ) | ( operation ) |
The central character of the p-block B of the group G is the algebra homomorphism λ_B: Z(FG) → F that is defined by λ_B(C^+) = ω_{χ}(C^+)^*, for χ ∈ Irr(B) and class sums C^+ of G, see [LP10, p. 324] or [Nav98, p. 48]. Here ω_{χ} is the central character of χ as defined in CentralCharacter (Reference: CentralCharacter), that is, ω_{χ}((g^G)^+) = |g^G| χ(g) / χ(1) for g ∈ G. (Note that the values of ω_{χ} are complex numbers, not elements of a finite field.)
We represent the central character of the b-th p-block of the character table tbl by the vector of reductions of the list returned by CentralCharacter (Reference: CentralCharacter) with argument an irreducible character in the given block. Note that the central character of the block depends on the choice of the p-modular system, see Section 3.2.
CentralCharacter is based on FrobeniusCharacterValueExt (4.2-3), thus the returned list contains fail entries exactly when a Conway polynomial would be needed that is not available.
gap> CentralCharacter( CharacterTable( "A5" ), 2, 1 ); [ Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ] gap> CentralCharacter( Block( CharacterTable( "A5" ), 2, 1 ) ); [ Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ]
‣ ClassPositionsOfKernel( B ) | ( attribute ) |
Let B be a p-block of the group G, say. We define the kernel of B as the intersection of the kernels of the ordinary irreducible characters in B. and ClassPositionsOfKernel returns the list of positions of those conjugacy classes of G (w. r. t. the underlying character table of B) that lie inside the kernel.
The kernel of B is the kernel of the natural action of G on the algebra e FG, where e is the block idempotent of B (see CoefficientsOfOsimaIdempotent (3.3-13)).
The kernel of B is equal to the intersection of the kernel of any character in B with the largest normal p'-subgroup of G, which is usually denoted by O_{p'}(G), see [LP10, Theorem 4.11.13], [Nav98, Theorem 6.10], or [NT89, Ch. 5, Sect. 8]. In particular, the kernel of the principal p block of G is equal to O_{p'}(G).
gap> t:= CharacterTable( "6.A6" );; gap> List( PBlocks( t, 2 ), ClassPositionsOfKernel ); [ [ 1, 3, 5 ], [ 1, 3, 5 ], [ 1, 3, 5 ], [ 1 ], [ 1 ] ] gap> List( PBlocks( t, 3 ), ClassPositionsOfKernel ); [ [ 1, 4 ], [ 1, 4 ], [ 1 ] ] gap> List( PBlocks( t, 5 ), ClassPositionsOfKernel ); [ [ 1, 2, 3, 4, 5, 6 ], [ 1, 2, 3, 4, 5, 6 ], [ 1, 2, 3, 4, 5, 6 ], [ 1, 2, 3, 4, 5, 6 ], [ 1, 3, 5 ], [ 1, 3, 5 ], [ 1, 3, 5 ], [ 1, 4 ], [ 1, 4 ], [ 1, 4 ], [ 1, 4 ], [ 1 ], [ 1 ] ]
‣ IsFaithful( B ) | ( property ) |
The block B is called faithful if its kernel is trivial, see ClassPositionsOfKernel (3.3-11).
gap> t:= CharacterTable( "6.A6" );; gap> List( PBlocks( t, 2 ), IsFaithful ); [ false, false, false, true, true ]
‣ CoefficientsOfOsimaIdempotent( B ) | ( attribute ) |
‣ CoefficientsOfOsimaIdempotent( tbl, p, b ) | ( operation ) |
Let B be a p-block of the group G. The primitive idempotent corresponding to χ ∈ Irr(G) is
e_{χ} = (χ(1) / |G|) ∑_g χ(g^{-1}) g ∈ Z(ℂG),
where the summation runs over the elements of G.
The Osima idempotent of B is defined as f_B = ∑_{χ} e_{χ}, where the summation runs over χ ∈ Irr(B). The coefficient of g ∈ G in f_B is
a_g = (1 / |G|) ∑_{χ} χ(1) χ(g^{-1}),
where the summation runs over χ ∈ Irr(B).
CoefficientsOfOsimaIdempotent returns the vector [ a_{g_1}, a_{g_2}, ... ], where g_i lies in the i-th conjugacy class of the character table tbl.
The name "Osima idempotent" appears in [Isa76, p. 277]. Both f_B and its reduction (f_B)^* are called block idempotent in [LP10, p. 324], whereas this term is used only for e_B = (f_B)^* in [Nav98, p. 55].
gap> CoefficientsOfOsimaIdempotent( CharacterTable( "A5" ), 2, 1 ); [ 11/15, 0, -1/15, 1/15, 1/15 ] gap> CoefficientsOfOsimaIdempotent( Block( CharacterTable( "A5" ), 2, 1 ) ); [ 11/15, 0, -1/15, 1/15, 1/15 ]
‣ IsBlockOfCharacterTable( B ) | ( category ) |
A p-block of a character table can be represented by a GAP object in the filter IsBlockOfCharacterTable. The idea is that such an object is created by Block (3.3-1) from the defining data, and that there are various operations that can take a block object as arguments (for example attributes such as Defect (3.4-1) and Irr (3.3-5)) or can return block objects (for example PrincipalBlock (3.3-3)).
Block objects aren't domains in the sense of Reference: Domains, in particular they do not have elements; one can use Irr (3.3-5) and IBr (3.3-6) for accessing the ordinary or modular irreducible characters that "belong to" the given block.
Two objects that represent blocks of character tables are compared w.r.t. the triples [ id, p, b ], where id is the identifier of the underlying character table, p is the underlying characteristic, and b is the number of the block.
The declarations of operations and the installations of methods for these block objects should not cause conflicts to situations where blocks of algebras, in the sense of direct summands, are considered. (At the moment, there seems to be no GAP package with such functionality.)
gap> tbl:= CharacterTable( "D8" );; gap> tbl2:= CharacterTable( "A4" );; gap> IsBlockOfCharacterTable( tbl ); false gap> IsBlockOfCharacterTable( Block( tbl, 2, 1 ) ); true gap> Block( tbl, 2, 1 ) = Block( tbl2, 2, 1 ); false gap> Block( tbl, 2, 1 ) < Block( tbl2, 2, 1 ); true
Let G be a group and p be a prime integer. For any positive integer m, let m_p denote the highest power of p that divides m.
The p-defect groups of a conjugacy class C of G are the Sylow p-subgroups of the centralizers in G of the elements in C.
Let t be the character table of the group G, p be a prime integer, and B be a p-block of t. The defect of B is defined as the integer
max{ log_p( |G|_p / χ(1)_p ); χ ∈ Irr(B) },
see [Nav98, Def. 3.15] and [LP10, Def. 4.4.12].
A class g^G of p-regular elements in G is called a defect class of B if both λ_B((g^G)^+) and (a_g)^* are nonzero, where λ_B is the central character of B (see CentralCharacter (3.3-10)) and a_g is the coefficient of the Osima idempotent of B at g (see CoefficientsOfOsimaIdempotent (3.3-13)). Note that the set of defect classes of a block depends on the choice of the p-modular system, see Section 3.2.
The p-defect groups of a B are the defect groups of the defect classes of B. Equivalently, the defect groups of B are the defect groups of arbitrary algebraic conjugates of defect classes of B. ([Isa76, p. 280] defines the defect of a block via the order of its defect group –if the defect group has order p^d then the defect is d. Then it is shown in [Isa76, Theorem 15.41] that this definition coincides with the above one.)
By the lemma from Section 3.2-1, the set of algebraic conjugates of the defect classes of a p-block does not depend on the choice of the p-modular system and can be computed without computing p-modular reductions of cyclotomic numbers. In order to see this, we fix a class C = g^G of p-regular elements of order m in G, and ask whether at least one algebraic conjugate of C is a defect class of a given p-block B. This is not the case if and only if λ_B((h^G)^+) ⋅ (a_h)^* = 0 holds for all algebraic conjugates h of g, that is, for all generators h of the cyclic group ⟨ g ⟩. Choose χ ∈ Irr(B) and set β = ω_{χ}((g^G)^+) ⋅ a_g. Then there is an integer n coprime to p such that α = n ⋅ β is an algebraic integer, and α^* = 0 holds if and only if β^* = λ_B((g^G)^+) ⋅ (a_g)^* = 0 holds. Thus no algebraic conjugate of C is a defect class of B if and only if α / p ∈ ℤ[ζ_m] holds.
‣ Defect( B ) | ( attribute ) |
‣ Defect( tbl, p, b ) | ( operation ) |
For a block that is either given by a block object B or as the b-th p-block of the character table tbl, Defect returns the defect of this block, see above.
gap> Defect( Block( CharacterTable( "A5" ), 2, 1 ) ); 2 gap> Defect( CharacterTable( "A5" ), 2, 1 ); 2
‣ DefectGroup( B ) | ( attribute ) |
‣ DefectGroup( tbl, p, b ) | ( operation ) |
Let tbl be an ordinary character table with underlying group (see UnderlyingGroup (Reference: UnderlyingGroup for character tables)) G, say, p be a prime integer, and b be a positive integer denoting the number of a p-block of tbl. Alternatively, let B be the b-th p-block of tbl.
DefectGroup returns a defect group of the b-th p-block of tbl.
If the UnderlyingGroup (Reference: UnderlyingGroup for character tables) is not known then fail is returned.
gap> tbl:= CharacterTable( AlternatingGroup( 5 ) );; gap> DefectGroup( tbl, 2, 1 ); Group([ (2,3)(4,5), (2,4)(3,5) ]) gap> DefectGroup( Block( CharacterTable( "A5" ), 2, 1 ) ); fail
‣ NormalizerOfDefectGroup( B ) | ( attribute ) |
‣ NormalizerOfDefectGroup( tbl, p, b ) | ( operation ) |
Let tbl be an ordinary character table with underlying group (see UnderlyingGroup (Reference: UnderlyingGroup for character tables)) G, say, p be a prime integer, and b be a positive integer denoting the number of a p-block of tbl. Alternatively, let B be the b-th p-block of tbl.
NormalizerOfDefectGroup returns the normalizer in G of a defect group of the b-th p-block of tbl.
If the UnderlyingGroup (Reference: UnderlyingGroup for character tables) value is not set in tbl then fail is returned.
Note that there are methods for fetching defect normalizer information from the CTBlocks database, see NormalizerOfDefectGroup.
gap> tbl:= CharacterTable( AlternatingGroup( 5 ) );; gap> NormalizerOfDefectGroup( tbl, 2, 1 ); Group([ (2,3)(4,5), (2,4)(3,5), (3,4,5) ]) gap> NormalizerOfDefectGroup( Block( CharacterTable( "A5" ), 2, 1 ) ); fail
‣ ClassPositionsOfDefectGroupOfClass( tbl, p, c ) | ( operation ) |
Let p be a prime integer and c be the position of a p-regular class in the ordinary character table tbl. ClassPositionsOfDefectGroupOfClass returns the list of positions of those classes that contain elements of the defect groups of the c-th class.
Note that for a p-regular element g in a group G, the classes of those p-elements in G that contain elements in the centralizer of g in G are the p-parts of those classes of G that contain the roots of g.
gap> tbl:= CharacterTable( "J2" );; gap> OrdersClassRepresentatives( tbl ); [ 1, 2, 2, 3, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 10, 10, 10, 10, 12, 15, 15 ] gap> ClassPositionsOfDefectGroupOfClass( tbl, 2, 4 ); [ 1, 2, 6 ]
‣ ClassPositionsOfDefectGroupOfBlock( B ) | ( attribute ) |
‣ ClassPositionsOfDefectGroupOfBlock( tbl, p, b ) | ( operation ) |
Let tbl be an ordinary character table, p be a prime integer, and b be a positive integer denoting the number of a p-block of tbl. Alternatively, let B be the b-th p-block of tbl.
ClassPositionsOfDefectGroupOfBlock returns the list of positions of those classes that contain elements of the defect groups of the b-th p-block of tbl.
gap> tbl:= CharacterTable( "J2" );; gap> ClassPositionsOfDefectGroupOfBlock( Block( tbl, 2, 1 ) ); [ 1, 2, 3, 6, 14 ] gap> ClassPositionsOfDefectGroupOfBlock( tbl, 2, 1 ); [ 1, 2, 3, 6, 14 ]
‣ IsClassWithNormalDefectGroup( tbl, p, c ) | ( operation ) |
returns true if the p-defect groups of the c-th class of the ordinary character table tbl are normal subgroups of the group of tbl, and false otherwise.
The c-th class of tbl must be p-regular.
gap> IsClassWithNormalDefectGroup( CharacterTable( "A5" ), 2, 1 ); false gap> IsClassWithNormalDefectGroup( CharacterTable( "A5" ), 2, 3 ); true
‣ IsBlockWithNormalDefectGroup( B ) | ( property ) |
‣ IsBlockWithNormalDefectGroup( tbl, p, b ) | ( operation ) |
returns true if the defect groups of the b-th p-block of the ordinary character table tbl are normal subgroups of the group of tbl, and false otherwise.
The block can also be entered as a block object B.
gap> IsBlockWithNormalDefectGroup( CharacterTable( "A5" ), 2, 1 ); false gap> IsBlockWithNormalDefectGroup( Block( CharacterTable( "A5" ), 2, 2 ) ); true
‣ IsClassWithCyclicDefectGroup( tbl, p, c ) | ( operation ) |
returns true if the p-defect groups of the c-th class of the ordinary character table tbl are cyclic, and false otherwise.
The c-th class of tbl must be p-regular.
gap> IsClassWithCyclicDefectGroup( CharacterTable( "A5" ), 2, 1 ); false gap> IsClassWithCyclicDefectGroup( CharacterTable( "A5" ), 2, 3 ); true
‣ IsBlockWithCyclicDefectGroup( B ) | ( property ) |
‣ IsBlockWithCyclicDefectGroup( tbl, p, b ) | ( operation ) |
returns true if the defect groups of the b-th p-block of the ordinary character table tbl are cyclic, and false otherwise.
The block can also be entered as a block object B.
gap> IsBlockWithCyclicDefectGroup( CharacterTable( "A5" ), 2, 1 ); false gap> IsBlockWithCyclicDefectGroup( Block( CharacterTable( "A5" ), 2, 2 ) ); true
‣ TestBlockWithAbelianDefectGroup( B ) | ( attribute ) |
‣ TestBlockWithAbelianDefectGroup( tbl, p, b ) | ( operation ) |
‣ IsBlockWithAbelianDefectGroup( B ) | ( attribute ) |
‣ IsBlockWithAbelianDefectGroup( tbl, p, b ) | ( operation ) |
Brauer's height zero conjecture states that the defect groups of a p-block of G are abelian if and only if all ordinary irreducible characters in the block have height zero (cf. [LP10, Conjecture 4.14.6] or [Nav98, p. 212]). If this conjecture would be true then it would allow us to compute from the character table of a group whether the defect groups of a block are abelian.
Currently it is known that the existence of an irreducible character of positive defect implies that the defect groups of its block are nonabelian (see [KM13]). The other direction of the conjecture is still open, and it is in general not known whether the character table of a group determines which defect groups of its p-blocks are abelian. Therefore, there is no GAP function IsBlockWithAbelianDefectGroup with return values only true and false. Instead, TestBlockWithAbelianDefectGroup tests some necessary conditions and allows for a fail result. The return value is a record as described below.
Let tbl be an ordinary character table, p be a prime integer, and b be a positive integer denoting the number of a p-block of tbl. Alternatively, let B be the b-th p-block of tbl.
TestBlockWithAbelianDefectGroup returns a record with the following components.
resultHZCtrue if all ordinary irreducible characters in the block have height zero, and false otherwise; if Brauer's height zero conjecture is true then this holds if and only if the defect groups of the block are abelian,
resulttrue or false if the defect groups of the block can be shown to be abelian or nonabelian, respectively, and fail if the criteria listed below do not suffice for a decision.
commenta string that explains the reason for the value of the result component.
The following criteria are used.
If not all ordinary irreducible characters in the block have height zero then the defect groups of the block are nonabelian, by [KM13].
If the defect is at most 2 or if the exponent of the defect groups is 2 or if the defect groups are cyclic then the defect groups are abelian.
If tbl is p-solvable then the height zero conjecture holds for tbl, by [GW84].
If the defect groups contain elements whose centralizer order is not divisible by the order of the defect groups then the defect groups are nonabelian.
For a block of maximal defect, [NST15] yields that the defect groups (the Sylow subgroups) are abelian if and only if all ordinary irreducibles in the principal p-block have height zero and the class lengths of all p-elements are not divisible by p.
For a block whose defect group is normal in the group of tbl, the height zero conjecture is true by a theorem of Reynolds, see [Nav98, Thm. 9.23].
If the Sylow p-subgroups the group of tbl are abelian (which can be computed by [NST15]) then the defect groups of any p-block are abelian.
gap> TestBlockWithAbelianDefectGroup( CharacterTable( "A5" ), 2, 1 ); rec( comment := "defect at most 2", result := true, resultHZC := true ) gap> TestBlockWithAbelianDefectGroup( CharacterTable( "A6" ), 2, 1 ); rec( comment := "not all irreducibles have height zero", result := false, resultHZC := false ) gap> TestBlockWithAbelianDefectGroup( CharacterTable( "J1" ), 2, 1 ); rec( comment := "defect group is an el. ab. 2-group", result := true, resultHZC := true ) gap> TestBlockWithAbelianDefectGroup( > CharacterTable( "2.L2(23).2" ), 2, 2 ); rec( comment := "cyclic defect group", result := true, resultHZC := true ) gap> TestBlockWithAbelianDefectGroup( > CharacterTable( "U3(11)" ), 2, 2 ); rec( comment := "no criterion yields a decision", result := fail, resultHZC := true )
More examples are shown in Section 2.2.
IsBlockWithAbelianDefectGroup returns the value of the result component of the result of TestBlockWithAbelianDefectGroup, called with the same arguments.
gap> IsBlockWithAbelianDefectGroup( CharacterTable( "A5" ), 2, 1 ); true gap> IsBlockWithAbelianDefectGroup( CharacterTable( "A6" ), 2, 1 ); false gap> IsBlockWithAbelianDefectGroup( CharacterTable( "J1" ), 2, 1 ); true gap> IsBlockWithAbelianDefectGroup( CharacterTable( "2.L2(23).2" ), > 2, 2 ); true gap> IsBlockWithAbelianDefectGroup( CharacterTable( "U3(11)" ), > 2, 2 ); fail
(Note that technically, IsBlockWithAbelianDefectGroup cannot be implemented via a property in the sense of GAP's type system, see Reference: Properties. It is implemented via an attribute.)
‣ ClassPositionsOfDefectClasses( B ) | ( attribute ) |
‣ ClassPositionsOfDefectClasses( tbl, p, b ) | ( operation ) |
Let tbl be an ordinary character table, p be a prime integer, and b be a positive integer denoting the number of a p-block of tbl. Alternatively, let B be the b-th p-block of tbl.
ClassPositionsOfDefectClasses returns the list of positions of those conjugacy classes of tbl that are defect classes of its b-th p-block if GAP can decide this with reasonable effort, and fail otherwise. The result fail occurs if and only if either tbl has no b-th p-block or if the known Conway polynomials (see ConwayPolynomial (Reference: ConwayPolynomial)) do not suffice.
gap> ClassPositionsOfDefectClasses( CharacterTable( "A5" ), 2, 1 ); [ 1 ] gap> b:= Block( CharacterTable( "A5" ), 2, 2 );; gap> ClassPositionsOfDefectClasses( b ); [ 3, 4, 5 ] gap> b:= Block( CharacterTable( "J4" ), 23, 32 );; gap> ClassPositionsOfDefectClasses( b ); #I the Conway polynomial of degree 21 for p = 23 is not known fail
‣ ClassPositionsOfDefectClassesUpToGaloisConjugacy( B ) | ( attribute ) |
‣ ClassPositionsOfDefectClassesUpToGaloisConjugacy( tbl, p, b ) | ( operation ) |
ClassPositionsOfDefectClassesUpToGaloisConjugacy is similar to ClassPositionsOfDefectClasses (3.4-11). The result is either fail or the list of those class positions such that at least one algebraic conjugate class is a defect class of the b-th p-block of tbl.
By the lemma from Section 3.2-1, this information can be computed without using Conway polynomials, thus fail is returned only if tbl has no b-th p-block. (Note that ClassPositionsOfDefectClasses (3.4-11) returns fail also if not all defect classes can be determined.)
gap> b:= Block( CharacterTable( "A5" ), 2, 2 ); Block( CharacterTable( "A5" ), 2, 2 ) gap> ClassPositionsOfDefectClassesUpToGaloisConjugacy( b ); [ 3, 4, 5 ] gap> ClassPositionsOfDefectClassesUpToGaloisConjugacy( > CharacterTable( "J4" ), 23, 32 ); [ 2, 3, 5, 6, 7, 14, 15, 16, 19, 20, 34, 57, 58, 59, 60 ]
Let D be a p-subgroup of the group G, where p is a prime integer. Then D is called a radical p-subgroup of G if D is equal to the p-core (see PCore (Reference: PCore)) of the normalizer of D in G, see [LP10, Def. 4.7.25] and [Nav98, p. 84].
For example, the p-core of G (see PCore (Reference: PCore)) is radical, and every radical p-subgroup of G contains the p-core of G. Moreover, the defect groups of p-blocks of G (see Section 3.4) are radical. In particular the Sylow p-subgroups of G are radical.
Radical p-subgroups are important for example if one deals with p-weights, see Section 3.7. See Section 3.6 for computing chains of radical p-subgroups.
‣ IsRadicalPSubgroup( G, D, p ) | ( operation ) |
For a subgroup D of the group G (this relation is not checked), IsRadicalPSubgroup returns true if D is a radical p-subgroup of G (see above), and false otherwise.
gap> g:= SmallGroup( 48, 29 );; # GL(2,3) gap> syl2:= SylowSubgroup( g, 2 );; gap> ccl:= ConjugacyClassesSubgroups( syl2 );; gap> reps:= List( ccl, Representative );; gap> List( reps, Size ); [ 1, 2, 2, 4, 4, 4, 8, 8, 8, 16 ] gap> israd:= List( reps, r -> IsRadicalPSubgroup( g, r, 2 ) ); [ false, false, false, false, false, false, true, false, false, true ]
‣ NormalizerOfRadicalPSubgroup( G, D, p ) | ( operation ) |
Let D be a p-subgroup of the group G, where p is a prime integer. (It is not checked whether D is actually a subgroup of G.) NormalizerOfRadicalPSubgroup returns fail if D is not a radical p-subgroup of G, see IsRadicalPSubgroup (3.5-1), and the normalizer of D in G otherwise.
The advantage of using this function instead of IsRadicalPSubgroup (3.5-1) is that the normalizer need not be computed twice if one is interested in it.
gap> # (continuing the example for IsRadicalPSubgroup) gap> norm:= List( reps, r -> NormalizerOfRadicalPSubgroup( g, r, 2 ) ); [ fail, fail, fail, fail, fail, fail, Group([ f1, f2, f3, f4, f5 ]), fail, fail, Group([ f1, f3, f4, f5 ]) ] gap> Positions( israd, false ) = Positions( norm, fail ); true
‣ RepresentativesRadicalPSubgroupsAndNormalizers( G, p[, arec] ) | ( function ) |
‣ RepresentativesRadicalPSubgroupsAndNormalizers( tom, p ) | ( function ) |
Let the first argument be either a group G or the table of marks tom of the group G such that the filter IsTableOfMarksWithGens (Reference: IsTableOfMarksWithGens) is set in tom, and let p be a prime integer. RepresentativesRadicalPSubgroupsAndNormalizers returns a list of records with the components subgroup and normalizer, with the values U and N, respectively, such that U runs over representatives of conjugacy classes of radical p-subgroups of G and N is the normalizer of U in G.
Calling PCore (Reference: PCore) with the arguments N and p yields U, this value is cached inside N.
If the first argument is a table of marks tom then also the components subgroupnr and normalizernr are bound in the records that are returned, their values are the positions of the conjugacy classes of U and N in the list of classes of subgroups of tom. Thus these numbers can be used for fetching a conjugate of U and N with RepresentativeTom (Reference: RepresentativeTom).
The optional argument arec, if given, must be a record. It can be used to submit data for accelerating the computations in the case that a group G is given as the first argument. The following components of arec are supported.
Maxesa list l of subgroups of G such that any p-local subgroup of G is conjugate to a subgroup of one of the groups in l; this holds if l contains representatives of all classes of maximal subgroups of G, but often a smaller list suffices,
CharacterTablethe ordinary character table of G.
The idea behind the Maxes component is that the union L, say, of class representatives of p-radical subgroups in the subgroups in the list l covers the classes of non-normal radical p-subgroups of G: If U is p-radical in G and not normal in G then U is p-radical in some maximal subgroup of G that contains U. (If U is not normal in G then the normalizer N of U in G is contained in some maximal subgroup M of G, thus N is also the normalizer of U in M, and hence U is p-radical in M.) Thus we can find candidates for all classes of radical p-subgroups of G by omitting those subgroups from L that are not p-radical in G, omitting also duplicates in the sense that the subgroups are conjugate in G, and adding the p-core of G.
gap> g:= DihedralGroup( 8 );; gap> RepresentativesRadicalPSubgroupsAndNormalizers( g, 2 ); [ rec( normalizer := Group([ f1, f2, f3 ]), subgroup := Group([ f1, f2, f3 ]) ) ] gap> g:= SymmetricGroup( 5 );; gap> RepresentativesRadicalPSubgroupsAndNormalizers( g, 2 ); [ rec( normalizer := Sym( [ 1 .. 5 ] ), subgroup := Group(()) ), rec( normalizer := Group([ (3,4,5), (3,4), (1,2) ]), subgroup := Group([ (1,2) ]) ), rec( normalizer := Group([ (1,2)(3,4), (1,3)(2,4), (2,4), (2,3) ]), subgroup := Group([ (1,3)(2,4), (1,2)(3,4) ]) ), rec( normalizer := Group([ (1,4)(2,3), (3,4), (1,2) ]), subgroup := Group([ (3,4), (1,2), (1,3)(2,4) ]) ) ] gap> tom:= TableOfMarks( "A5" );; gap> RepresentativesRadicalPSubgroupsAndNormalizers( tom, 2 ); [ rec( normalizer := Alt( [ 1 .. 5 ] ), normalizernr := 9, subgroup := Group(()), subgroupnr := 1 ), rec( normalizer := Group([ (2,4)(3,5), (2,3)(4,5), (3,4,5) ]), normalizernr := 8, subgroup := Group([ (2,3)(4,5), (2,4)(3,5) ]) , subgroupnr := 4 ) ]
The above computation shows that the alternating group on five points has exactly two classes of radical 2-subgroups, the trivial subgroup and a Klein four group contained in the stabilizer of a point. Thus we can restrict the computations to this point stabilizer and get essentially the same result.
gap> g:= AlternatingGroup( 5 );; gap> r:= rec( Maxes:= [ Stabilizer( g, 5 ) ], > CharacterTable:= CharacterTable( "A5" ) );; gap> RepresentativesRadicalPSubgroupsAndNormalizers( g, 2, r ); [ rec( normalizer := Alt( [ 1 .. 5 ] ), subgroup := Group(()) ), rec( normalizer := Group([ (1,4)(2,3), (1,3)(2,4), (2,3,4) ]), subgroup := Group([ (1,4)(2,3), (1,3)(2,4) ]) ) ]
The following methods are available.
If a table of marks tom is given then we run over the classes of p-subgroups.
If a group G but no record arec with Maxes component is given then first we run over the classes of subgroups of a Sylow p-subgroup of G/ N, where N is the p-core of G, then fuse G/ N-conjugate classes, and finally compute preimages under the natural epimorphism from G to G/ N.
If a group G and a record arec with Maxes component l are given then we run over the subgroups in l and compute, for each such subgroup U, its p-radical subgroups with the above method. Finally, representatives under G-conjugacy are computed.
Once RepresentativesRadicalPSubgroupsAndNormalizers has computed the result, it is stored via the attribute ComputedRepresentativesRadicalPSubgroupsAndNormalizers.
A p-chain of length n of the group G is any strictly increasing chain P_0 < P_1 < ⋯ < P_n of p-subgroups of G, see [LP10, p. 433]. The normalizer of this chain is defined as N_0 ∩ N_1 ∩ ⋯ ∩ N_n, where N_i is the normalizer of P_i in G.
‣ RepresentativesChainsOfRadicalPSubgroupsAndNormalizers( G, p[, arec] ) | ( function ) |
‣ RepresentativesChainsOfRadicalPSubgroupsAndNormalizers( tom, p ) | ( function ) |
Called with the same arguments as RepresentativesRadicalPSubgroupsAndNormalizers (3.5-3), this function returns a list l, say, such that l[k] describes those ascending p-chains of length k of the group in question (that is, either G or the underlying group of tom), up to conjugation in this group, that start at the p-core P, say, of this group and that consist of radical p-subgroups. Each entry in l[k] is a record with the following components.
subgroupsthe list [ P_1, P_2, ..., P_k ] such that P < P_1 < P_2 < ⋯ < P_k is the p-chain in question (note that the p-core itself does not appear in the list) and
normalizerthe normalizer of the chain.
The function calls the function RepresentativesRadicalPSubgroupsAndNormalizers (3.5-3) for computing class representatives of radical p-subgroups. The optional argument arec, if present, is used for this purpose.
gap> g:= DihedralGroup( 8 );; gap> RepresentativesChainsOfRadicalPSubgroupsAndNormalizers( g, 2 ); [ ] gap> g:= SymmetricGroup( 5 );; gap> RepresentativesChainsOfRadicalPSubgroupsAndNormalizers( g, 2 ); [ [ rec( normalizer := Group([ (3,4,5), (3,4), (1,2) ]), subgroups := [ Group([ (1,2) ]) ] ), rec( normalizer := Group([ (1,2)(3,4), (1,3)(2,4), (2,4), (2,3) ]), subgroups := [ Group([ (1,3)(2,4), (1,2)(3,4) ]) ] ), rec( normalizer := Group([ (1,4)(2,3), (3,4), (1,2) ]), subgroups := [ Group([ (3,4), (1,2), (1,3)(2,4) ]) ] ) ], [ rec( normalizer := Group([ (3,4), (1,2) ]), subgroups := [ Group([ (1,2) ]), Group([ (3,4), (1,2), (1,3)(2,4) ]) ] ), rec( normalizer := Group([ (1,4)(2,3), (3,4), (1,2) ]), subgroups := [ Group([ (1,3)(2,4), (1,2)(3,4) ]), Group([ (3,4), (1,2), (1,3)(2,4) ]) ] ) ] ] gap> tom:= TableOfMarks( "A5" );; gap> RepresentativesChainsOfRadicalPSubgroupsAndNormalizers( tom, 2 ); [ [ rec( normalizer := Group([ (2,4)(3,5), (2,3)(4,5), (3,4,5) ]), subgroups := [ Group([ (2,3)(4,5), (2,4)(3,5) ]) ] ) ] ]
RepresentativesChainsOfRadicalPSubgroupsAndNormalizers stores the computed result via the attribute ComputedRepresentativesChainsOfRadicalPSubgroupsAndNormalizers.
Let G be a group, p be a prime integer, P be a p-subgroup of G, and N be the normalizer of P in G. A p-weight of G is defined as a pair (P, ψ) where ψ is an irreducible defect zero character of N/P, that is, the p-parts of ψ(1) and |N/P| are equal (see [Nav98, p. 90]).
The p-weight (P, ψ) is said to belong to the p-block B of G if the p-block of ψ induces B, see Section 3.8. Note that each p-weight belongs to a block, because block induction (in the sense of Brauer) from N to G is always defined, see for example [LP10, Thm. 4.7.19].
A more suitable way of representing p-weights in our context –we want to deal with character tables instead of groups– is the following.
Let t be the ordinary character table of G and n be the ordinary character table of N, and if n is different from t then assume that the class fusion of N in G is stored on n. Then the p-weight (P, ψ) can be represented by the pair (n, ψ'), where ψ' is the irreducible character of N that is obtained from ψ by inflation.
Note that P is p-radical in G (see Section 3.5) if N/P has a p-block of defect zero, thus P is uniquely determined by N as its p-core. (To see this, note that the p-core of a group G is contained in the defect groups of all p-blocks of G, see [Nav98, Thm. 4.8] or [LP10, Thm. 4.6.10].)
Note also that the character table of N determines which of its conjugacy classes lie in P, see ClassPositionsOfPCore (Reference: ClassPositionsOfPCore).
In order to deal also with cases where the ordinary character table of N is not known, we provide the following alternative description of p-weights. Suppose that there is a chain 1 < K ≤ P < N ≤ M < G of subgroups of G such that K is normal in M, and such that the character tables m, m', and n' of M, M/K, and N/K, respectively, are known. Again we have to assume that the relevant class fusions are stored on the character tables: the fusion that describes the embedding of N/K in M/K and the fusion that describes the projection from M to M/K. In this situation, we can represent (P, ψ) by the pair ((n', m', m), ψ'), where ψ' is the irreducible character of N/K that is obtained from ψ by inflation.
Note that we can compute, for a p-weight described by ((n', m', m), ψ'), to which p-block of G it belongs: Let ψ be the irreducible character of N that is obtained from ψ' by inflation, and let B denote the p-block of G that is induced by the p-block of ψ. We compute B by first inducing the p-block of ψ' from N/K to M/K, then taking the corresponding block of M, and then inducing this block to G. (Note that block induction is transitive, see for example [LP10, Exercise 4.7.3]).
‣ DescriptionOfPWeights( B ) | ( function ) |
‣ DescriptionOfPWeights( tbl, p[, b] ) | ( function ) |
First consider the case of two arguments. Let tbl be the ordinary character table of a group G, say, and p be a prime integer. DescriptionOfPWeights returns either fail or a record r that describes the p-weights of G, up to G-conjugacy, as follows.
Suppose that G has k conjugacy classes of radical p-subgroups, with representatives P_1, P_2, ..., P_k.
The normalizers component of r is a dense list [ n_1, n_2, ..., n_k ], where n_i is either the character table of the normalizer N_i of P_i in G, or n_i is a triple ((n_i)', (m_i)', m_i) of character tables as defined above in this section, which describes this normalizer.
The characters component of r is a dense list of the same length k, its i-th entry is the list of those irreducible characters ψ of n_i or of (n_i)', respectively, with the property that P_i is contained in the kernel of ψ and that ψ has defect zero w.r.t. the factor group N_i / P_i.
The blocks component of r is a dense list of the same length k, its i-th entry is the list of numbers of the blocks in tbl to which the given characters ψ of n_i belong.
Now consider the case of three arguments, where b is a positive integer, and the case of one argument B that stands for the b-th p-block of tbl. In these cases, the format of the result is the same, but it is restricted to those classes of radical p-subgroups and to those irreducible characters for which the induced block is B.
gap> DescriptionOfPWeights( CharacterTable( AlternatingGroup( 5 ) ), 2 ); rec( blocks := [ [ 2 ], [ 1, 1, 1 ] ], characters := [ [ Character( CharacterTable( Alt( [ 1 .. 5 ] ) ), [ 4, 0, 1, -1, -1 ] ) ], [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ), Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, E(3)^2, E(3), 1 ] ), Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, E(3), E(3)^2, 1 ] ) ] ], normalizers := [ CharacterTable( Alt( [ 1 .. 5 ] ) ), CharacterTable( Alt( [ 1 .. 4 ] ) ) ] ) gap> DescriptionOfPWeights( CharacterTable( AlternatingGroup( 5 ) ), 2, 1 ); rec( characters := [ [ ], [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ), Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, E(3)^2, E(3), 1 ] ), Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, E(3), E(3)^2, 1 ] ) ] ], normalizers := [ CharacterTable( Alt( [ 1 .. 5 ] ) ), CharacterTable( Alt( [ 1 .. 4 ] ) ) ] )
If the attribute UnderlyingGroup (Reference: UnderlyingGroup for character tables) is not set in tbl and if the p-weights of tbl are not yet known then fail is returned.
Block induction relates certain p-blocks of subgroups of a group G to p-blocks of G. From the various definitions of induced blocks that appear in the literature, each two of the following ones coincide when both of them are defined.
In all cases, G is a finite group, p is a prime integer, H is a subgroup of G, and we are given a p-block b of H. Recall that the central character ω_b^* is defined as the p-modular reduction of the class function ω_{χ}, for any irreducible character χ in b.
Let s_H: Z(FG) → Z(FH) be the F-linear map that is defined by C^+ ↦ (C ∩ H)^+, for each conjugacy class C of G. If λ_b ∘ s_H = λ_B (see CentralCharacter (3.3-10)) holds for some p-block B of G then we call B the block induced by b, and write B = b^G.
The function BrauerCorrespondent (3.8-1) can be used to compute the number of the block B. See [LP10, Section 4.7] or [Nav98, p. 86 ff.] for details. Note that λ_b ∘ s_H can be computed as (ω_{χ^G})^*, if we extend the definition of CentralCharacter (Reference: CentralCharacter) to arbitrary characters, see [LP10, Lemma 4.7.5].
For any two different p-blocks B, C of G, the class functions λ_B, λ_C differ at some p-regular class, see [LP10, Proof of Thm. 4.4.8]. Thus it makes sense to define the induced block B by the condition that λ_b ∘ s_H and λ_B coincide at p-regular classes –if such a block B exists then it is unique. If b^G is defined in the sense of Brauer then of course B = b^G holds.
The function PRegularCorrespondent (3.8-2) can be used to compute the number of the block B. Note that this computation is cheaper than that of b^G. Thus it is advisable to call PRegularCorrespondent (3.8-2) instead of BrauerCorrespondent (3.8-1) if one knows in advance that b^G is defined.
This induction concept is defined not character theoretically but using the interpretation of the p-blocks as the indecomposable direct summands of the group algebra RG. Namely, RG is a R[G × G]-module, w. r. t. the action x ⋅ (g_1, g_2) = g_1^{-1} x g_2, for x ∈ RG and g_1, g_2 ∈ G. Restricting this action on a block B of RG to R[H × H] yields a direct sum of blocks of RH. If B is the unique block of RG with the property that the block b of RH occurs as a direct summand of the restriction then block induction in the sense of Alperin-Burry is defined, and B is the induced block (see [AB80]).
The function AlperinBurryCorrespondent (3.8-3) can be used to compute the number of the block B, provided that the underlying groups of the character tables in question are available.
If B is the unique block of G with the property (λ_b ∘ s_H)((f_B)^*) not= 0, where f_B ∈ Z(RG) is the block idempotent of B (see CoefficientsOfOsimaIdempotent (3.3-13)), then we say that extended block induction (or block induction in the sense of Wheeler) is defined for b, and B is the induced block. It is shown in [Whe94] that this condition holds if block induction is defined in the sense of Brauer or of Alperin-Burry, thus it provides a common generalization of these concepts. (In fact it generalizes p-regular induction.)
The function WheelerCorrespondent (3.8-4) can be used to compute the number of the block B. Using [Whe94, Lemma 1.3], we can compute the induced block via the equality (λ_b ∘ s_H)((f_B)^*) = (χ^B(1) / χ^G(1))^*, where χ is any character in b and χ^B is the restriction of χ^G to B. (With this approach, we need not compute reductions of cyclotomic numbers to finite fields, cf. Section 3.2.
The following functions implement the above concepts of block induction. In all cases, four arguments occur. The first two are the ordinary character tables of the two groups H and G, with H ≤ G, the third is the prime integer p, and and the fourth is either a positive integer b denoting the number of a p-block of the character table of H or an irreducible character of H that lies in the b-th p-block of H.
Alternatively, the b-th p-block of the character table of H can be entered via a block object B. In this case, only the character table of G must be supplied in addition to B.
‣ BrauerCorrespondent( B, tblG ) | ( operation ) |
‣ BrauerCorrespondent( tblH, tblG, p, b ) | ( operation ) |
Called with the arguments as described above, BrauerCorrespondent returns the number of the induced p-block of tblG if block induction to G is defined for the given block in the sense of Brauer (see above), otherwise fail is returned.
‣ PRegularCorrespondent( B, tblG ) | ( operation ) |
‣ PRegularCorrespondent( tblH, tblG, p, b ) | ( operation ) |
Called with the arguments as described above, PRegularCorrespondent returns the number of the induced p-block of G if p-regular block induction to G is defined for the given block, otherwise fail is returned.
‣ AlperinBurryCorrespondent( B, tblG ) | ( operation ) |
‣ AlperinBurryCorrespondent( tblH, tblG, p, b ) | ( operation ) |
Called with the arguments as described above, AlperinBurryCorrespondent returns the number of the induced p-block of G if block induction to G is defined for the given block in the sense of Alperin-Burry (see above), otherwise fail is returned. The currently available methods require that underlying groups are stored for tblH and tblG, and that these groups are compatible.
‣ WheelerCorrespondent( B, tblG ) | ( operation ) |
‣ WheelerCorrespondent( tblH, tblG, p, b ) | ( operation ) |
Called with the arguments as described above, WheelerCorrespondent returns the number of the induced p-block of G if extended block induction to G is defined for the given block, otherwise fail is returned.
A conjugacy class C of the group G is called real if C is equal to the class of inverses of the elements in C (see RealClasses (Reference: RealClasses)).
The class C is called strongly real if its elements are either the identity in G or are inverted by conjugation with an involution (that is, an element of order two) in G. Equivalently, the elements in a strongly real class C are the identity or products of at most two involutions in G; note that if t ∈ G is an involution such that t g = g^{-1} t holds for g ∈ C then (t g)^2 is the identity, hence g = t (t g) is a product of at most two involutions.
A p-block B of G is called real if Irr(B) is invariant under complex conjugation (see ComplexConjugate (Reference: ComplexConjugate)). In [Nav98, p. 75], real p-blocks are called selfdual.
The p-block B is called strongly real (see [Mur06]) if it is real and has a strongly real defect class (see ClassPositionsOfDefectClasses (3.4-11)). Since a class is strongly real if and only if all of its algebraic conjugates are strongly real, the real p-block B is strongly real if and only if the set of defect classes of B up to Galois conjugacy (see ClassPositionsOfDefectClassesUpToGaloisConjugacy (3.4-12)) contains a strongly real class.
‣ IsRealClass( tbl, c ) | ( operation ) |
Let c be the position of a class in the ordinary character table tbl. IsRealClass returns true if the c-th class in tbl is real, and false otherwise.
gap> tbl:= CharacterTable( "M22" );; gap> List( [ 1 .. NrConjugacyClasses( tbl ) ], > c -> IsRealClass( tbl, c ) ); [ true, true, true, true, true, true, true, false, false, true, false, false ]
‣ IsStronglyRealClass( tbl, c ) | ( operation ) |
Let c be the position of a class in the ordinary character table tbl. IsStronglyRealClass returns true if the c-th class in tbl is strongly real, and false otherwise.
This property can be checked using the class multiplication coefficients of tbl, see ClassMultiplicationCoefficient (Reference: ClassMultiplicationCoefficient for character tables).
gap> tbl:= CharacterTable( "M22" );; gap> List( [ 1 .. NrConjugacyClasses( tbl ) ], > c -> IsStronglyRealClass( tbl, c ) ); [ true, true, true, true, true, true, true, false, false, false, false, false ]
‣ IsRealBlock( B ) | ( property ) |
‣ IsRealBlock( tbl, p, b ) | ( operation ) |
returns true if the b-th p-block of the ordinary character table tbl is real, and false otherwise.
The block can also be entered as a block object B.
gap> IsRealBlock( CharacterTable( "A7" ), 5, 1 ); true gap> IsRealBlock( Block( CharacterTable( "A7" ), 5, 2 ) ); false
‣ IsStronglyRealBlock( B ) | ( property ) |
‣ IsStronglyRealBlock( tbl, p, b ) | ( operation ) |
returns true if the b-th p-block of the ordinary character table tbl is strongly real, and false otherwise.
The block can also be entered as a block object B.
gap> tbl:= CharacterTable( "2.A5" );; gap> IsStronglyRealBlock( Block( tbl, 2, 1 ) ); true gap> IsStronglyRealBlock( tbl, 2, 2 ); false
The principal block is always strongly real. The unique nonprincipal 2-block of 2.A_5 ≅ SL(2,5) is not strongly regular; note that the corresponding defect zero block of the factor group A_5 is strongly regular.
gap> tbl:= CharacterTable( "A5" );; gap> IsStronglyRealBlock( tbl, 2, 2 ); true
(This example can be generalized: The group G = SL(2,q), for odd q, contains exactly one involution, which is central in G. Thus G cannot have strongly real p-blocks of nonmaximal defect.)
The idea behind the functions described in this section is that one selects those p-blocks from a given set that satisfy certain conditions, where the candidates can be given either by a list of block objects or by a list of character tables whose p-blocks are considered, for all prime divisors p of the group order. (In the case of character tables from GAP's character table library, one can enter also a list of admissible names of these tables, for example their Identifier (Reference: Identifier for character tables) values.)
For example all p-blocks with positive defect or with trivial kernel can be considered, or more generally all p-blocks with prescribed values for some properties and attributes that have been introduced in the previous sections.
AllPBlocks (3.10-1) and OnePBlock (3.10-2) return all blocks and one block with the desired properties, respectively.
BlockInvariants (3.10-3) returns a record that contains a matrix of block invariants (one row for each block with the desired properties) and a description of the invariants corresponding to the columns. DisplayBlockInvariants (3.10-4) and BrowseBlockInvariants (3.10-5) (this function requires the Browse package [BL18]) show a tabular overview of these invariants. The columns of these matrices of block invariants can be customized, see CTBlocks.BlockInvariantsColumns (3.10-6).
‣ AllPBlocks( source[, fun1, val1, ...] ) | ( function ) |
The first argument source must be either a list l_1 of block objects or (an admissible name of) an ordinary character table t or a list of (admissible names of) ordinary character tables l_2. If there is just this argument then AllPBlocks returns l_1 or the list of all p-blocks of t, for all primes dividing the order of the underlying group of t, or the concatenation of these lists for the tables in l_2.
Additional arguments fun1, val1, fun2, val2 ... can be used to restrict the output. Each of fun1, fun2, ... must be a unary function that takes a block object as its argument, and each of val1, val2, ... describes the admissible values, as follows: The i-th value is admissible for the result of the i-th function applied to a given block object if the result is either equal to the value or (if the value is a list) is contained in the value or (if the value is a function) yields true when the value is applied to the result. AllPBlocks returns the list of those blocks for which the values of all functions are admissible.
gap> t:= CharacterTable( "A5" );; gap> AllPBlocks( t ); [ Block( CharacterTable( "A5" ), 2, 1 ), Block( CharacterTable( "A5" ), 2, 2 ), Block( CharacterTable( "A5" ), 3, 1 ), Block( CharacterTable( "A5" ), 3, 2 ), Block( CharacterTable( "A5" ), 3, 3 ), Block( CharacterTable( "A5" ), 5, 1 ), Block( CharacterTable( "A5" ), 5, 2 ) ] gap> AllPBlocks( t, Defect, 2 ); [ Block( CharacterTable( "A5" ), 2, 1 ) ] gap> AllPBlocks( t, Defect, IsPosInt ); [ Block( CharacterTable( "A5" ), 2, 1 ), Block( CharacterTable( "A5" ), 3, 1 ), Block( CharacterTable( "A5" ), 5, 1 ) ]
‣ OnePBlock( source[, fun1, val1, ...] ) | ( function ) |
The difference between OnePBlock and AllPBlocks (3.10-1) is that OnePBlock, when called with the same arguments, returns the first entry of the result of AllPBlocks (3.10-1) if this result is nonempty, and fail otherwise.
gap> t:= CharacterTable( "A5" );; gap> OnePBlock( t ); Block( CharacterTable( "A5" ), 2, 1 ) gap> OnePBlock( t, UnderlyingCharacteristic, 2 ); Block( CharacterTable( "A5" ), 2, 1 ) gap> OnePBlock( t, Defect, 2 ); Block( CharacterTable( "A5" ), 2, 1 ) gap> OnePBlock( t, Defect, IsPosInt ); Block( CharacterTable( "A5" ), 2, 1 )
‣ BlockInvariants( source[, fun1, val1, ...][, arec] ) | ( function ) |
This function returns a record with the following components.
lista matrix of block invariants whose rows correspond to the block objects that are returned by AllPBlocks (3.10-1) when this function is called with the same arguments,
columnsa list af records that correspond to the columns of the matrix stored in the list component; for the format of these records, see CTBlocks.BlockInvariantsColumns (3.10-6),
headera list of strings that describe the contents.
For the meaning of the arguments of this function except arec, see AllPBlocks (3.10-1). The optional argument arec can be used to customize the columns of the list component, see CTBlocks.BlockInvariantsColumns (3.10-6).
gap> t:= CharacterTable( "A5" );; gap> inv:= BlockInvariants( t );; gap> List( inv.columns, r -> r.label ); [ "p", "b", "d", "k", "l", "c", "a", "n", "f", "r", "sr" ] gap> Display( inv.list ); [ [ 2, 1, 2, 4, 3, false, true, false, true, true, true ], [ 2, 2, 0, 1, 1, true, true, true, true, true, true ], [ 3, 1, 1, 3, 2, true, true, false, true, true, true ], [ 3, 2, 0, 1, 1, true, true, true, true, true, true ], [ 3, 3, 0, 1, 1, true, true, true, true, true, true ], [ 5, 1, 1, 4, 2, true, true, false, true, true, true ], [ 5, 2, 0, 1, 1, true, true, true, true, true, true ] ]
The following values of fun1, fun2, ... have the additional effect that the corresponding column is omitted from the list component if exactly one admissible value is prescribed.
Defect (3.4-1)
IsBlockWithAbelianDefectGroup (3.4-10)
IsBlockWithCyclicDefectGroup (3.4-9)
IsBlockWithNormalDefectGroup (3.4-7)
IsFaithful (3.3-12)
NumberOfBlock (3.3-2)
UnderlyingCharacteristic (3.3-2)
gap> inv:= BlockInvariants( t, UnderlyingCharacteristic, 2 );; gap> List( inv.columns, r -> r.label ); [ "b", "d", "k", "l", "c", "a", "n", "f", "r", "sr" ] gap> Display( inv.list ); [ [ 1, 2, 4, 3, false, true, false, true, true, true ], [ 2, 0, 1, 1, true, true, true, true, true, true ] ]
‣ DisplayBlockInvariants( source[, fun1, val1, ...][, arec] ) | ( function ) |
This function prints the return value of BlockInvariants (3.10-3), when this function is called with the same arguments, in tabular form.
If there is just one argument then DisplayBlockInvariants prints tabular information about the p-blocks of the given character table(s), for all primes p dividing the group order(s). Each row corresponds to a p-block, and each column corresponds to a block invariant.
(First we set the user preference DisplayFunction to the value "Print" in order to make sure that only ASCII characters are shown in the following example output. The value will be reset at the end of the examples in this manual chapter.)
gap> origpref:= UserPreference( "AtlasRep", "DisplayFunction" );; gap> SetUserPreference( "AtlasRep", "DisplayFunction", "Print" ); gap> t:= CharacterTable( "2.A5" );; gap> DisplayBlockInvariants( t ); Block invariants for 2.A5 ---------------------------------------------- | p | b | d | k | l | c | a | n | f | r | sr | ---------------------------------------------- | 2 | 1 | 3 | 7 | 3 | - | - | - | + | + | + | | | 2 | 1 | 2 | 1 | + | + | + | + | + | - | | 3 | 1 | 1 | 3 | 2 | + | + | - | - | + | + | | | 2 | 0 | 1 | 1 | + | + | + | - | + | - | | | 3 | 0 | 1 | 1 | + | + | + | - | + | - | | | 4 | 1 | 3 | 2 | + | + | - | + | + | + | | | 5 | 0 | 1 | 1 | + | + | + | + | + | - | | 5 | 1 | 1 | 4 | 2 | + | + | - | - | + | + | | | 2 | 0 | 1 | 1 | + | + | + | - | + | - | | | 3 | 1 | 4 | 2 | + | + | - | + | + | + | ----------------------------------------------
See CTBlocks.BlockInvariantsColumns (3.10-6) for the meaning of the columns.
The meaning of the arguments fun1, val1, fun2, val2 ... for restricting the rows and the meaning of arec for customizing the columns and the header is the same as described for BlockInvariants (3.10-3).
gap> DisplayBlockInvariants( t, UnderlyingCharacteristic, 2 );; Block invariants for 2.A5 p = 2 ------------------------------------------ | b | d | k | l | c | a | n | f | r | sr | ------------------------------------------ | 1 | 3 | 7 | 3 | - | - | - | + | + | + | | 2 | 1 | 2 | 1 | + | + | + | + | + | - | ------------------------------------------
The user preference DisplayFunction from the package AtlasRep controls whether the output is just printed or shown using a pager. Depending on the value of this user preference and the terminal capabilities, nicer table borders may be used than are shown in the above examples.
‣ BrowseBlockInvariants( source[, fun1, val1, ...][, arec] ) | ( function ) |
The arguments of this function are equal to the ones for DisplayBlockInvariants (3.10-4). The difference to that function is that BrowseBlockInvariants does not print the overview to the screen but shows it in a browse table, see Browse: Browsing Tables in GAP using ncurses –The User Interface.
BrowseBlockInvariants can be used only if the Browse package [BL18] is loaded.
The full functionality of the function NCurses.BrowseGeneric (Browse: NCurses.BrowseGeneric) is available.
gap> n:= [ 14, 14, 14, 14, 14, 14 ];; # ``do nothing'' gap> enter:= [ NCurses.keys.ENTER ];; gap> BrowseData.SetReplay( Concatenation( > "sc", # select the 'p' column, > "sc", # categorize by this column, > "X", # expand all categories > n, # wait a little > "scrrrrrrr", # select the 'f' column > "f+", enter, # restrict to the faithful blocks > n, # wait a little > "!", # reset the filtering etc. > n, # wait a little > "Q" ) ); # and quit gap> t:= CharacterTable( "2.A5" );; gap> BrowseBlockInvariants( t ); gap> BrowseData.SetReplay( false );
‣ CTBlocks.BlockInvariantsColumns | ( global variable ) |
This variable defines the columns of the overviews that are computed by BlockInvariants (3.10-3), DisplayBlockInvariants (3.10-4), and BrowseBlockInvariants (3.10-5). Each column is described by a record with the following components.
labela string that serves as a column label in the table header,
funa unary function that takes a block object as its argument, for example Defect (3.4-1),
alignone of "left" or "right", meaning the alignment of the values in the printed table,
replace (optional)if present, this must be a list of length three, the first entry being the list of admissible values, the second entry being the list of the corresponding strings that shall be printed in the overview, and the third entry being the list of the corresponding strings that shall be shown in the table header when the output is restricted to the given value; the same strings are also shown in the category rows of the browse table shown by BrowseBlockInvariants (3.10-5). If no component replace is present then String (Reference: String) is applied to the invariant in question, and the label together with the value will be used in the header and in category rows of the printed table.
gap> CTBlocks.BlockInvariantsColumns[1]; rec( align := "left", fun := function( B ) ... end, label := "G" )
The columns of the overview tables can be customized via the optional record that can be entered as the last argument to BlockInvariants (3.10-3), DisplayBlockInvariants (3.10-4), and BrowseBlockInvariants (3.10-5). If this record contains the component columns with value a list of records as described above then this list of columns is considered instead of the default list CTBlocks.BlockInvariantsColumns. This way one can reduce, extend, or reorder the columns that are shown.
gap> cols:= List( [ "c", "a", "n", "f" ], > l -> First( CTBlocks.BlockInvariantsColumns, > r -> r.label = l ) );; gap> t:= CharacterTable( "2.A5" );; gap> DisplayBlockInvariants( t, rec( columns:= cols ) ); Block invariants for 2.A5 ----------------- | c | a | n | f | ----------------- | - | - | - | + | | + | + | + | + | | + | + | - | - | | + | + | + | - | | + | + | + | - | | + | + | - | + | | + | + | + | + | | + | + | - | - | | + | + | + | - | | + | + | - | + | -----------------
By default, the following columns appear.
G (omitted if only one character table is given)the identifier of the underlying character table,
bthe block number,
dthe defect of the block,
kthe number of ordinary irreducibles in the block,
lthe number of modular irreducibles in the block,
c+ if the defect groups of the block are cyclic, - otherwise,
a+ if the defect groups of the block are abelian, - if they are nonabelian, ? if the character table does not determine this property,
n+ if the defect groups of the block are normal, - otherwise,
f+ if the block is faithful, - otherwise,
r+ if the block is real, - otherwise,
sr+ if the block is strongly real, - otherwise,
gap> List( CTBlocks.BlockInvariantsColumns, r -> r.label ); [ "G", "p", "b", "d", "k", "l", "c", "a", "n", "f", "r", "sr" ]
Another supported component of the optional record is header. If it is bound then its value must be a list of strings which apper as the header component of the record returned by BlockInvariants (3.10-3) and which are shown as a header above the tables printed by DisplayBlockInvariants (3.10-4) and BrowseBlockInvariants (3.10-5). The default for the header is [ "Block invariants" ] except that the line is extended by the identifier of the character table if exactly one character table is entered as the first argument.
gap> DisplayBlockInvariants( t, Defect, IsPosInt, > rec( columns:= cols, > header:= [ "only Boolean invariants" ] ) ); only Boolean invariants ----------------- | c | a | n | f | ----------------- | - | - | - | + | | + | + | + | + | | + | + | - | - | | + | + | - | + | | + | + | - | - | | + | + | - | + | -----------------
(The user preference DisplayFunction from the AtlasRep had been changed before showing examples for DisplayBlockInvariants (3.10-4). Now we reset this preference to its original value.)
gap> SetUserPreference( "AtlasRep", "DisplayFunction", origpref );
The functions described in this section create algebra objects (see Reference: Algebras) which are isomorphic with the centres of blocks or group algebras. The structure constants of the centre of a group algebra can be computed from the character table of the group in question, see ClassMultiplicationCoefficient (Reference: ClassMultiplicationCoefficient for character tables), and the centre of a p-block is a suitable subalgebra.
‣ SCAlgebraCentreOfGroupAlgebra( G, p ) | ( function ) |
‣ SCAlgebraCentreOfGroupAlgebra( G, F ) | ( function ) |
‣ SCAlgebraCentreOfGroupAlgebra( tbl, p ) | ( function ) |
‣ SCAlgebraCentreOfGroupAlgebra( tbl, F ) | ( function ) |
Let either G be a group or tbl be the ordinary character table of a group.
If the second argument is a prime integer p then SCAlgebraCentreOfGroupAlgebra returns a s. c. algebra (see Reference: Constructing Algebras by Structure Constants that is isomorphic with the centre of the group algebra of the group, over the field with p elements.
If the second argument is a finite field F then the same holds, except that the coefficients domain of the algebra is F.
The canonical basis of the algebra corresponds to the class sums in the group; the basis vectors appear in the same ordering as in the ConjugacyClasses (Reference: ConjugacyClasses attribute) value for G or tbl, respectively.
gap> tbl:= CharacterTable( "M11" ); CharacterTable( "M11" ) gap> a:= SCAlgebraCentreOfGroupAlgebra( tbl, 3 ); <algebra-with-one of dimension 10 over GF(3)> gap> a.2 * a.3; (Z(3))*C2+(Z(3))*C4+C7+C8+(Z(3))*C9+(Z(3))*C10 gap> Dimension( RadicalOfAlgebra( a ) ); 8 gap> SCAlgebraCentreOfGroupAlgebra( tbl, GF(9) ); <algebra-with-one of dimension 10 over GF(3^2)>
‣ BlockDecompositionSCAlgebraCentreOfGroupAlgebra( tbl, p ) | ( function ) |
‣ BlockDecompositionSCAlgebraCentreOfGroupAlgebra( tbl, F ) | ( function ) |
Let tbl be an ordinary character table.
If the second argument is a prime integer p then this function returns a list of subalgebras of the s. c. algebra returned by SCAlgebraCentreOfGroupAlgebra (3.11-1) when this is called with tbl and the smallest field that contains the p-modular reductions of all block idempotents of tbl in characteristic p. The i-th subalgebra corresponds to the i-th p-block of tbl.
If the second argument is a finite field F then the same holds, except that the coefficients domain of the algebras is F. If F is too small then fail is returned.
gap> tbl:= CharacterTable( "M11" ); CharacterTable( "M11" ) gap> dec:= BlockDecompositionSCAlgebraCentreOfGroupAlgebra( > tbl, 5 ); [ <algebra of dimension 5 over GF(5^2)>, <algebra of dimension 1 over GF(5^2)>, <algebra of dimension 1 over GF(5^2)>, <algebra of dimension 1 over GF(5^2)>, <algebra of dimension 1 over GF(5^2)>, <algebra of dimension 1 over GF(5^2)> ] gap> List( dec, Dimension ); [ 5, 1, 1, 1, 1, 1 ] gap> dec:= BlockDecompositionSCAlgebraCentreOfGroupAlgebra( > tbl, GF(5) ); fail
‣ SCAlgebraCentreOfBlock( tbl, p, b ) | ( function ) |
‣ SCAlgebraCentreOfBlock( tbl, F, b ) | ( function ) |
Let tbl be an ordinary character table, and b be a positive integer.
If the second argument is a prime integer p then SCAlgebraCentreOfBlock returns a subalgebra of the s. c. algebra returned by SCAlgebraCentreOfGroupAlgebra (3.11-1) when this is called with tbl and the smallest field that contains the p-modular reductions of the b-th block idempotent of tbl in characteristic p.
If the second argument is a finite field F then the same holds, except that the coefficients domain of the algebra is F. If F is too small then fail is returned.
gap> tbl:= CharacterTable( "M11" ); CharacterTable( "M11" ) gap> SCAlgebraCentreOfBlock( tbl, 5, 1 ); <algebra of dimension 5 over GF(5)> gap> SCAlgebraCentreOfBlock( tbl, 5, 3 ); <algebra of dimension 1 over GF(5^2)> gap> SCAlgebraCentreOfBlock( tbl, GF(5), 3 ); fail
generated by GAPDoc2HTML