7 Functions for calculating Schur indices and identifying division algebras

`‣ WedderburnDecompositionWithDivAlgParts` ( A ) | ( property ) |

Returns: A list of lists `[r,D]`

, each representing a ring of \( r \times r \) matrices over a field or division algebra `D`

.

The input `A` should be a group ring of a finite group over an abelian number field. The function will give the same result as `WedderburnDecompositionInfo`

(2.1-2) if the field of coefficients for the group ring is finite. The output is a list of pairs `[r,D]`

, each of which indicates a simple component isomorphic to the ring of \( r \times r\) matrices over a division algebra described using the information in the record `D`

. This record contains information on the center, Schur index, and local indices of the division algebra.

`Local indices`

is a list of pairs \([p,m]\), where \(p\) is a rational prime (possibly 'infinity') and \(m\) is the local index of the division algebra at the prime \(p\).

gap> G:=SmallGroup(48,15); <pc group of size 48 with 5 generators> gap> R:=GroupRing(Rationals,G); <algebra-with-one over Rationals, with 5 generators> gap> WedderburnDecompositionInfo(R); [ [ 1, Rationals ], [ 1, Rationals ], [ 1, Rationals ], [ 1, Rationals ], [ 2, Rationals ], [ 2, Rationals ], [ 2, Rationals ], [ 2, NF(8,[ 1, 7 ]) ], [ 2, CF(3) ], [ 1, Rationals, 12, [ [ 2, 5, 3 ], [ 2, 7, 0 ] ], [ [ 3 ] ] ] ] gap> WedderburnDecompositionWithDivAlgParts(R); [ [ 1, Rationals ], [ 1, Rationals ], [ 1, Rationals ], [ 1, Rationals ], [ 2, Rationals ], [ 2, Rationals ], [ 2, Rationals ], [ 2, NF(8,[ 1, 7 ]) ], [ 2, CF(3) ], [ 2, rec( Center := Rationals, DivAlg := true, LocalIndices := [ [ 2, 2 ], [ 3, 2 ] ], SchurIndex := 2 ) ] ]

`‣ CyclotomicAlgebraWithDivAlgPart` ( A ) | ( property ) |

Returns: A list of length two indicating a matrix ring of a given size over a field or a noncommutative division algebra.

The input `A` should be a cyclotomic algebra; i.e. a crossed product in the same form as in the output of `WedderburnDecompositionInfo`

(2.1-2). The output is in the form `[r,D]`

, which indicates an \( r \times r \) matrix ring over the division algebra described by `D`

. `D`

is either a field or a noncommutative division algebra described using a record giving information on the center, Schur index, and local indices of the division algebra.

gap> G:=SmallGroup(240,89); <permutation group of size 240 with 2 generators> gap> R:=GroupRing(Rationals,G); <algebra-with-one over Rationals, with 2 generators> gap> W:=WedderburnDecompositionInfo(R); Wedderga: Warning!!! Some of the Wedderburn components displayed are FRACTIONAL MATRIX ALGEBRAS!!! [ [ 1, Rationals ], [ 1, Rationals ], [ 1, Rationals, 10, [ 4, 3, 5 ] ], [ 4, Rationals ], [ 4, Rationals ], [ 5, Rationals ], [ 5, Rationals ], [ 6, Rationals ], [ 1, NF(12,[ 1, 11 ]), 10, [ 4, 3, 5 ] ], [ 3/2, NF(8,[ 1, 7 ]), 10, [ 4, 3, 5 ] ] ] gap> CyclotomicAlgebraWithDivAlgPart(W[3]); [ 2, rec( Center := Rationals, DivAlg := true, LocalIndices := [ [ 5, 2 ], [ infinity, 2 ] ], SchurIndex := 2 ) ] gap> CyclotomicAlgebraWithDivAlgPart(W[9]); [ 2, rec( Center := NF(12,[ 1, 11 ]), DivAlg := true, LocalIndices := [ [ infinity, 2 ] ], SchurIndex := 2 ) ] gap> CyclotomicAlgebraWithDivAlgPart(W[10]); [ 3, rec( Center := NF(8,[ 1, 7 ]), DivAlg := true, LocalIndices := [ [ infinity, 2 ] ], SchurIndex := 2 ) ]

`‣ SchurIndex` ( A ) | ( property ) |

`‣ SchurIndexByCharacter` ( F, G, n ) | ( operation ) |

Returns: The first of these returns the Schur index of the simple algebra `A`. The second returns the Schur index of the simple component of the group ring `FG` corresponding to the irreducible character `Irr(G)[n]`

of `G`.

These are the main functions for computing Schur indices. The first can be used to find the rational Schur index of a simple component of the group ring of a finite group over an abelian number field, or a quaternion algebra in **GAP** (see `QuaternionAlgebra`

(Reference: QuaternionAlgebra)) whose center is the field of rational numbers. If `A` is a quaternion algebra over a number field other than the Rationals, `fail`

is returned. In these cases, the quaternion algebra can be converted to a cyclic algebra and the Schur index of the cyclic algebra can be determined through the solution of norm equations. Currently this functionality is not implemented in **GAP**, but available in number theory packages such as **PARI/GP**.

The second function computes the Schur index of the cyclotomic algebra that would occur as the simple component of the group ring `FG` that corresponds to the irreducible character `Irr(G)[n]`

. The function uses `SimpleComponentByCharacterDescent`

(7.3-2), which uses the character descent algorithm to reduce to as small a group as possible. For larger groups this is preferrable as it is less demanding on memory. The Schur index of the resulting cyclotomic algebra is then computed with the `SchurIndex`

function.

gap> G:=SmallGroup(63,1); <pc group of size 63 with 3 generators> gap> R:=GroupRing(Rationals,G); <algebra-with-one over Rationals, with 3 generators> gap> W:=WedderburnDecompositionInfo(R); [ [ 1, Rationals ], [ 1, CF(3) ], [ 1, CF(9) ], [ 3, NF(7,[ 1, 2, 4 ]) ], [ 1, NF(21,[ 1, 4, 16 ]), 21, [ 3, 4, 7 ] ] ] gap> SchurIndex(W[5]); 3 gap> G:=SmallGroup(40,3); <pc group of size 40 with 4 generators> gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> SchurIndexByCharacter(GaussianRationals,G,Irr(G)[i]); 2 gap> SchurIndexByCharacter(CF(3),G,i); 1

gap> G:=AtlasGroup("J2"); <permutation group of size 604800 with 2 generators> gap> Irr(G)[20];; gap> SchurIndexByCharacter(Rationals,G,Irr(G)[20]); 1

`‣ WedderburnDecompositionAsSCAlgebras` ( R ) | ( operation ) |

`‣ CyclotomicAlgebraAsSCAlgebra` ( A ) | ( operation ) |

`‣ SimpleComponentByCharacterAsSCAlgebra` ( F, G, n ) | ( operation ) |

Returns: The first of these returns the Wedderburn decomposition of the group ring `R`

with each simple component presented as an algebra with structure constants in **GAP** (see Reference: Constructing Algebras by Structure Constants in the main **GAP** manual). The second converts a list `A`

that is output from `WedderburnDecompositionInfo`

(2.1-2) into an algebra with structure constants in **GAP**. The third determines an algebra with structure constants that is isomorphic to the simple component of the group ring of the finite group `G`

over the field `F`

that corresponds to the irreducible character `Irr(G)[n]`

.

These functions are an option for obtaining a Wedderburn decomposition or simple component of the group ring `FG`

in which the output is in the form of an algebra with structure constants, which is more compatible with GAP's built-in operations for finite-dimensional algebras.

gap> G:=SmallGroup(63,1); <pc group of size 63 with 3 generators> gap> R:=GroupRing(Rationals,G); <algebra-with-one over Rationals, with 3 generators> gap> W:=WedderburnDecompositionInfo(R); [ [ 1, Rationals ], [ 1, CF(3) ], [ 1, CF(9) ], [ 3, NF(7,[ 1, 2, 4 ]) ], [ 1, NF(21,[ 1, 4, 16 ]), 21, [ 3, 4, 7 ] ] ] gap> WedderburnDecompositionWithDivAlgParts(R); [ [ 1, Rationals ], [ 1, CF(3) ], [ 1, CF(9) ], [ 3, NF(7,[ 1, 2, 4 ]) ], [ 1, rec( Center := NF(21,[ 1, 4, 16 ]), DivAlg := true, LocalIndices := [ [ 7, 3 ] ], SchurIndex := 3 ) ] ] gap> WedderburnDecompositionAsSCAlgebras(R); [ Rationals, CF(3), CF(9), ( NF(7,[ 1, 2, 4 ])^[ 3, 3 ] ), <algebra of dimension 9 over NF(21,[ 1, 4, 16 ])> ] gap> CyclotomicAlgebraAsSCAlgebra(W[5]); <algebra of dimension 9 over NF(21,[ 1, 4, 16 ])> gap> Size(Irr(G)); 15 gap> SimpleComponentByCharacterAsSCAlgebra(Rationals,G,15); <algebra of dimension 9 over NF(21,[ 1, 4, 16 ])>

`‣ PPartOfN` ( n, p ) | ( operation ) |

`‣ PDashPartOfN` ( n, p ) | ( operation ) |

These are standard arithmetic functions required by several subroutines for the cyclotomic reciprocity and Schur index functions in **Wedderga**.

gap> PPartOfN(2275,5); 25 gap> PDashPartOfN(2275,5); 91

`‣ PSplitSubextension` ( F, n, p ) | ( operation ) |

Returns: The maximal subextension `K`

of the cyclotomic extension `F(E(n))/F`

for which \(K/F\) splits completely at the prime \(p\).

This function finds the maximal subextension `K`

of the cyclotomic extension `F(E(n))`

of an abelian number field `F`

for which both the ramification index and residue degree of `K/F`

over any prime lying over `p` are \(1\). To do this, it finds the field fixed by an appropriate power of the field automorphism inducing the local Frobenius automorphism.

gap> PSplitSubextension(Rationals,60,5); GaussianRationals gap> PSplitSubextension(NF(5,[1,4]),70,2); NF(35,[ 1, 4, 9, 11, 16, 29 ]) gap> PSplitSubextension(NF(40,[1,9,11,19]),20,2); NF(40,[ 1, 9, 11, 19])

`‣ SplittingDegreeAtP` ( F, n, p ) | ( operation ) |

`‣ ResidueDegreeAtP` ( F, n, p ) | ( operation ) |

`‣ RamificationIndexAtP` ( F, n, p ) | ( operation ) |

Returns: The splitting degree, residue degree, and ramification index of the extension `F(E(n))/F`

at the prime \(p\).

These functions calculate the cyclotomic reciprocity parameters `g`

, `f`

, and `e`

for the extension `F(E(n))/F`

at the prime \(p\) for an abelian number field `F`

. To do this, it finds the `p`

-split subextension `K`

and the \(p\)-dash part \(n'\) of \(n\), then calculates `g = [K:F]`

, `f = [K(E(n'):K]`

, and `e = [K(E(n)):K(E(n'))]`

. These functions enable the user to calculate cyclotomic reciprocity parameters for any extension of abelian number fields, as the example illustrates.

gap> F:=CF(12); CF(12) gap> K:=NF(120,[1,49]) # Note that F is a subfield of K, with index 4. > ; # Then we can find e, f, and g for the extension K/F at the prime 5. NF(120,[ 1, 49 ]) gap> RamificationIndexAtP(F,120,5); RamificationIndexAtP(K,120,5); last2/last; 4 2 2 gap> ResidueDegreeAtP(F,120,5); ResidueDegreeAtP(K,120,5); last2/last; 1 1 1 gap> SplittingDegreeAtP(F,120,5); SplittingDegreeAtP(K,120,5); last2/last; 2 1 2

`‣ GlobalSplittingOfCyclotomicAlgebra` ( A ) | ( operation ) |

`‣ KillingCocycle` ( A ) | ( operation ) |

`‣ AntiSymMatUpMat` ( x ) | ( operation ) |

`‣ CyclotomicExtensionGenerator` ( K, F ) | ( operation ) |

`‣ ReducingCyclotomicAlgebra` ( A ) | ( operation ) |

Returns: If the input cyclotomic crossed product algebra `A`

admits a rescaling of basis elements by roots of unity that makes it equivalent to one with a trivial factor set, the first function here returns a full matrix algebra over the same center with the same dimension as `A`

. In general the function will output a cyclotomic algebra equivalent to `A`

whose factor set does not admit a partial splitting by a simple rescaling of basis elements by roots of unity. `KillingCocycle`

is a subroutine used by `GlobalSplittingOfCyclotomicAlgebra`

function to produce equivalent factor sets that have more zeroes, `AntiSymMatUpMat`

is a subroutine it uses to manipulate the factor set information in anti-symmetric matrix form. `ReducingCyclotomicAlgebra`

is another subroutine used by the `GlobalSplittingOfCyclotomicAlgebra`

that either returns an isomorphic cyclotomic algebra whose associated Galois group has fewer generators than the input, or returns fail. `CyclotomicExtensionGenerator`

is a subroutine called by `ReducingCyclotomicAlgebra`

which returns a positive integer `m`

if the field `K`

is the cyclotomic extension of `F`

obtained by adjoining a primitive `m`

-th root of `1`

, and returns fail otherwise.

The input `A`

must be a list representing a cyclotomic algebra in the same form as in the output of `WedderburnDecompositionInfo`

(2.1-2) or `SimpleAlgebraByCharacterInfo`

(2.2-2). If the output has length 5, the function will first search using `KillingCocycle`

and `AntiSymMatUpMat`

for a rescaling of basis elements that makes the factor set trivial, and in general finds one that produces as many zeroes as possible in the factor set information. If there is a generator that produces a split tensor factor with a cyclotomic algebra `B`

defined over a root of unity of smaller order, then `ReducingCyclotomicAlgebra`

reduces to `B`

. These steps are repeated until such tensor factorizations are no longer available.

gap> A := [ 1, Rationals, 20, [ [ 2, 11, 0 ], [ 4, 3, 0 ] ], [ [ 0 ] ] ];; gap> GlobalSplittingOfCyclotomicAlgebra(A); [ 8, Rationals ] gap> A := [ 1, Rationals, 20, [ [ 2, 11, 0 ], [ 4, 3, 10 ] ], [ [ 0 ] ] ];; gap> GlobalSplittingOfCyclotomicAlgebra(A); [ 2, Rationals, 10, [ 4, 3, 5 ] ]

`‣ CharacterDescent` ( F, G, n, e, H ) | ( operation ) |

`‣ GlobalCharacterDescent` ( F, G, n ) | ( operation ) |

`‣ SimpleComponentByCharacterDescent` ( F, G, n ) | ( operation ) |

Returns: The first function returns `[r,F1,H,k]`

where `r`

is a positive rational, `F1`

is an extension field of `F`

, `H`

is the input subgroup `H`

, and `k`

is the position in `Irr(H)`

of the irreducible character that admits a Global Character Descent reduction; i.e. an irreducible character of `H`

that has the same local indices as `Irr(G)[n]`

. The second function returns the limit of the Character Descent reductions, it returns the last `CharacterDescent`

output obtained before reaching a state where no maximal subgroup of `G`

admits a further reduction by `CharacterDescent`

. The third function returns the simple component of `FG`

resulting from `GlobalCharacterDescent`

that is produced by applying `SimpleComponentOfGroupRingByCharacter`

(7.5-3) and adjusting the matrix degree.

The `CharacterDescent`

function tries to find an irreducible character `psi`

=`Irr(H)[k]`

of `H`

for which `[F(chi,psi),F(chi)]`

and `(chi_H,psi)`

are both coprime to `|G|`

. This character `psi`

will have the same local indices over `F`

as `chi`

by a theorem of Yamada. The `GlobalCharacterDescent`

function iterates a search for these global character descent reductions over irreducible characters of maximal subgroups of `G`

, and when it finds one it replaces `G`

, `F(chi)`

, and `chi`

by `H`

, `F(chi,psi)`

, and `psi`

, and then begins a search over maximal subgroups of `H`

. It terminates when no maximal subgroup admits a global reduction, and returns the relevant matrix degree factor along with the last `H`

and `psi`

it found. `SimpleComponentByCharacterDescent`

implements an algorithm that returns the simple component of `FG`

associated with `Irr(G)[n]`

obtained using the global character descent algorithm.

gap> G:=PSU(3,3); <permutation group of size 6048 with 2 generators> gap> sc := SimpleComponentByCharacterDescent(Rationals,G,8);; gap> sc{[1..3]}; # the 4th entry is [ 2, 5, 3 ] or [ 2, 5, 9 ] [ 21/2, GaussianRationals, 12 ] gap> SchurIndex(sc); 1

`‣ GaloisRepsOfCharacters` ( F, G ) | ( operation ) |

Returns: A list of positive integers `n`

that indicates the positions in `Irr(G)`

of the Galois conjugacy classes of irreducible characters of `G`

over the field `F`

.

`GaloisRepsOfCharacters`

finds a list of representatives of the distinct Galois conjugacy classes of irreducible characters of `G`

over `F`

. It runs through the irreducible characters and determines if a given irreducible is Galois conjugate over `F`

to any of the previous ones, and if not it adds the position of that character to the list.

gap> G:=SmallGroup(63,1); <pc group of size 63 with 3 generators> gap> GaloisRepsOfCharacters(Rationals,G); [ 1, 2, 4, 10, 12 ] gap> GaloisRepsOfCharacters(CF(9),G); [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13 ] gap> GaloisRepsOfCharacters(NF(7,[1,2,4]),G); [ 1, 2, 4, 10, 11, 12, 14 ] gap> GaloisRepsOfCharacters(CF(63),G); [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ]

`‣ WedderburnDecompositionByCharacterDescent` ( F, G ) | ( operation ) |

Returns: A Wedderburn decomposition of `FG`

that is obtained by applying the global character descent algorithm to representatives of the Galois conjugacy classes of irreducible characters of `G`

over `F`

.

`WedderburnDecompositionByCharacterDescent`

is available as an option to `WedderburnDecompositionInfo`

(2.1-2) that can be more effective for larger groups, especially ones with relatively few irreducible characters. As long as `GAP`

is able to compute maximal subgroups and restrict irreducible characters of `G`

to them, this function should eventually return a Wedderburn decomposition. As it operates on one irreducible character at a time, it is less effective on Abelian groups, which have far too many irreducible characters, and on most groups in GAP's Small Groups Library, where memory limitations are not a factor and it is possible for the Shoda pair algorithms can deal with many irreducible characters at the same time.

gap> G:=GL(3,3); GL(3,3) gap> Size(G); 11232 gap> WedderburnDecompositionByCharacterDescent(Rationals,G); [ [ 1, Rationals ], [ 1, Rationals ], [ 12, Rationals ], [ 12, Rationals ], [ 13, Rationals ], [ 13, Rationals ], [ 16, NF(13,[ 1, 3, 9 ]) ], [ 16, NF(13,[ 1, 3, 9 ]) ], [ 26, Rationals ], [ 26, Rationals ], [ 26, NF(8,[ 1, 3 ]) ], [ 26, NF(8,[ 1, 3 ]) ], [ 27, Rationals ], [ 27, Rationals ], [ 39, Rationals ], [ 39, Rationals ] ]

`‣ LocalIndicesOfCyclicCyclotomicAlgebra` ( A ) | ( operation ) |

Returns: A list of the pairs `[p,m]`

indicating the nontrivial local indices `m`

at the primes `p`

of the cyclic cyclotomic algebra indicated by `A`

.

The input `A`

must be a list representing a cyclic cyclotomic algebra in the same form as in the output of `WedderburnDecompositionInfo`

(2.1-2) or `SimpleAlgebraByCharacterInfo`

(2.2-2). This function computes the local Schur indices at rational primes \(p\) using the specialized functions for cyclic cyclotomic algebras described in this section.

gap> A:=[1,Rationals,6,[2,5,3]]; [ 1, Rationals, 6, [ 2, 5, 3 ] ] gap> LocalIndicesOfCyclicCyclotomicAlgebra(A); [ [ 3, 2 ], [ infinity, 2 ] ]

`‣ LocalIndexAtInfty` ( A ) | ( operation ) |

`‣ LocalIndexAtTwo` ( A ) | ( operation ) |

`‣ LocalIndexAtOddP` ( A, p ) | ( operation ) |

Returns: These return the local index of the cyclic cyclotomic algebra `A` at the indicated rational prime.

The input `A`

must be a cyclic cyclotomic algebra; that is, a list of the form `[r,F,n,[a,b,c]]`

that indicates a cyclic cyclotomic crossed product algebra. This is a special case of the output of **wedderga**'s `WedderburnDecompositionInfo`

(2.1-2) or `SimpleAlgebraByCharacterInfo`

(2.2-2). For the `LocalIndexAtOddP`

function, `p` must be an odd prime. The functions `PPartOfN`

(7.2-1) and `PDashPartOfN`

(7.2-1) are standard (and self-explanatory) arithmetic functions for a positive integer \(n\) and prime \(p\).

These functions determine the local index of a cyclic cyclotomic algebra at the rational primes `'infinity'`

, \(2\), or odd primes \(p\), respectively. The first two functions check for a relationship of \(A\) to a nonsplit real or 2-adic quaternion algebra. `LocalIndexAtOddP`

calculates the local index at \(p\) by counting the number of roots of unity coprime to \(p\) found in the \(p\)-adic completion, and using a formula due to Janusz.

gap> A:=[1,CF(4),20,[4,13,15]]; [ 1, GaussianRationals, 20, [ 4, 13, 15 ] ] gap> LocalIndexAtOddP(A,5); 4 gap> A:=[1,NF(8,[1,7]),8,[2,7,4]]; [ 1, NF(8,[ 1, 7 ]), 8, [ 2, 7, 4 ] ] gap> LocalIndexAtInfty(A); 2 gap> A:=[1,CF(7),28,[2,15,14]]; [ 1, CF(7), 28, [ 2, 15, 14 ] ] gap> LocalIndexAtTwo(A); 2

`‣ LocalIndicesOfCyclotomicAlgebra` ( A ) | ( operation ) |

Returns: A list of pairs `[p,m]`

indicating the nontrivial local indices `m`

at the primes `p`

of the cyclic cyclotomic algebra indicated by `A`

.

The input `A`

should be a cyclotomic algebra; i.e. a list of length 2, 4, or 5 in the form of the output by **Wedderga**'s "-Info" functions. If the cyclotomic algebra `A` is represented by a list of length 2, the local indices are all \(1\), so the function will return an empty list. If the cyclotomic algebra `A` is given by a list of length 4, then it represents a cyclic cyclotomic algebra, so the function `LocalIndicesOfCyclicCyclotomicAlgebra`

(7.4-1) is utilized. If the cyclotomic algebra `A`

is presented as a list of length 5 or more, the function first applies `GlobalSplittingOfCyclotomicAlgebra`

(7.3-1) to reduce the length as much as possible. If this does not reduce the length to 4 or less, it applies the character descent algorithm to try to reduce it again with Clifford theory: it determines the group and character `chi`

that faithfully represent the algebra using `DefiningGroupOfCyclotomicAlgebra`

(7.5-3) and `DefiningCharacterOfCyclotomicAlgebra`

(7.5-3), then applies `SimpleComponentByCharacterDescent`

(7.3-2). It repeats this until it cannot reduce the length of cyclotomic algebra any longer. If the length is 4 it will apply the local index functions for cyclic cyclotomic algebras to compute the local indices at each prime dividing the order of the group. If the length is 5 or more, it applies the character-theoretic local Schur index functions to the output `[G,chi]`

of `DefiningGroupAndCharacterOfCyclotAlg`

(7.5-3). It uses the Frobenius-Schur indicator of `chi`

to determine the local index at infinity (see `LocalIndexAtInftyByCharacter`

(7.5-4)). For local indices at odd primes and sometimes for the prime \(2\), the defect group of the block containing `chi`

will be cyclic, so the local index can be found using the values of a Brauer character by a theorem of Benard (see `LocalIndexAtPByBrauerCharacter`

(7.5-6).) Sometimes for the prime 2 the defect group is not necessarily cyclic, so in these cases we appeal to the classification of dyadic Schur groups by Schmid and Riese (see `LocalIndexAtTwoByCharacter`

(7.5-7)).

gap> G:=SmallGroup(480,600); <pc group of size 480 with 7 generators> gap> W:=WedderburnDecompositionInfo(GroupRing(Rationals,G));; gap> Size(W); 27 gap> W[27]; [ 1, NF(5,[ 1, 4 ]), 60, [ [ 2, 11, 0 ], [ 2, 19, 30 ], [ 2, 31, 30 ] ], [ [ 0, 45 ], [ 15 ] ] ] gap> LocalIndicesOfCyclotomicAlgebra(W[27]); [ [ infinity, 2 ] ]

gap> G:=SmallGroup(160,82); <pc group of size 160 with 6 generators> gap> W:=WedderburnDecompositionInfo(GroupRing(Rationals,G));; gap> Size(W); 14 gap> W[14]; [ 1, Rationals, 20, [ [ 2, 11, 0 ], [ 4, 3, 0 ] ], [ [ 5 ] ] ] gap> LocalIndicesOfCyclotomicAlgebra(W[14]); [ [ 2, 2 ], [ 5, 2 ] ]

`‣ RootOfDimensionOfCyclotomicAlgebra` ( A ) | ( operation ) |

Returns: A positive integer representing the square root of the dimension of the cyclotomic algebra over its center.

gap> A:=[3,Rationals,12,[[2,5,3],[2,7,0]],[[3]]]; [ 3, Rationals, 12, [ [ 2, 5, 3 ], [ 2, 7, 0 ] ], [ [ 3 ] ] ] gap> RootOfDimensionOfCyclotomicAlgebra(A); 12

`‣ DefiningGroupOfCyclotomicAlgebra` ( A ) | ( operation ) |

`‣ DefiningCharacterOfCyclotomicAlgebra` ( A ) | ( operation ) |

`‣ DefiningGroupAndCharacterOfCyclotAlg` ( A ) | ( operation ) |

Returns: These functions return a finite group `G`

and a positive integer `n`

(or, in the case to the third function, an irreducible character `n`

of `G`

for which the simple component of a group algebra over `G`

over the center of the cyclotomic algebra `A`

corresponding to the character `Irr(G)[n]`

(resp. `n`

) will be (rationally) isomorphic to `A`

.

`‣ SimpleComponentOfGroupRingByCharacter` ( F, G, n ) | ( operation ) |

Returns: A list that describes the algebraic structure of the simple component of the group algebra `FG`

which corresponds to the irreducible character `Irr(G)[n]`

(or `n`

).

This function is an alternative to `SimpleAlgebraByCharacterInfo(GroupRing(F,G),`

`Irr(G)[n]);`

. It is used in subroutines of local index functions when we need to work over a field larger than the field of character values.

gap> G:=SmallGroup(48,15); <pc group of size 48 with 5 generators> gap> R:=GroupRing(Rationals,G); <algebra-with-one over Rationals, with 5 generators> gap> W:=WedderburnDecompositionInfo(R);; gap> A:=W[10]; [ 1, Rationals, 12, [ [ 2, 5, 3 ], [ 2, 7, 0 ] ], [ [ 3 ] ] ] gap> g:=DefiningGroupOfCyclotomicAlgebra(A);; gap> IdSmallGroup(g); [ 48, 15 ] gap> n:=DefiningCharacterOfCyclotomicAlgebra(A); 12 gap> SimpleComponentOfGroupRingByCharacter(Rationals,G,n) > ;#Note:this cyclotomic algebra is isomorphic to the other by a change of basis. [ 1, Rationals, 12, [ [ 2, 5, 3 ], [ 2, 7, 0 ] ], [ [ 3 ] ] ]

`‣ LocalIndexAtInftyByCharacter` ( F, G, n ) | ( operation ) |

Returns: The local index at an infinite prime of the field `F` of the irreducible character `Irr(G)[n]`

(or `n`

) of the finite group `G`.

This function computes the Frobenius-Schur indicator of the irreducible character `Irr(G)[n]`

, and uses it to calculate the local index at `infinity`

of the corresponding simple component of `FG`.

gap> G:=SmallGroup(48,16); <pc group of size 48 with 5 generators> gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> LocalIndexAtInftyByCharacter(Rationals,G,i); 2 gap> LocalIndexAtInftyByCharacter(CF(3),G,Irr(G)[i]); 1

`‣ DefectGroupOfConjugacyClassAtP` ( G, c, p ) | ( operation ) |

`‣ DefectGroupsOfPBlock` ( G, n, p ) | ( operation ) |

`‣ DefectOfCharacterAtP` ( G, n, p ) | ( operation ) |

Returns: The first of these functions returns a defect group of the `c`

-th conjugacy class of the finite group `G`

at the prime `p`

. The second returns the conjugacy class of `p`

-subgroups of `G`

that consists of defect groups for the `p`

-block containing the ordinary irreducible character `Irr(G)[n]`

. The last of these functions returns the nonnegative integer `d`

for which `p^d`

is the order of a `p`

-defect group for `Irr(G)[n]`

.

The `p`

-defect group of a given conjugacy class of `G`

is a `p`

-Sylow subgroup of the centralizer in `G`

of any representative of the class. A defect group for a `p`

-block of `G`

is a minimal `p`

-subgroup that is a defect group for a defect class of the block. By Brauer's Min-Max theorem, this will occur for at least one `p`

-regular class of `G`

. The function `DefectGroupsOfPBlock`

identifies the defect classes for the block containing `Irr(G)[n]`

, finds the one whose defect group has minimal order, and returns the conjugacy class of the defect group of this class. The function `DefectOfCharacterAtP`

gives the logarithm base `p`

of the order of a defect group of the `p`

-block containing the character `Irr(G)[n]`

.

gap> G:=SmallGroup(72,21); <pc group of size 72 with 5 generators> gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> D:=DefectGroupOfConjugacyClassAtP(G,i,3); Group([ f4, f5 ]) gap> IsCyclic(last); false gap> D:=DefectGroupsOfPBlock(G,Irr(G)[i],3); Group( [ f4, f5 ] )^G gap> IsCyclic(Representative(D)); false gap> DefectOfCharacterAtP(G,Irr(G)[i],3); 2

`‣ LocalIndexAtPByBrauerCharacter` ( F, G, n, p ) | ( operation ) |

`‣ FinFieldExt` ( F, G, p, n, m ) | ( operation ) |

Returns: The first returns the local index at the rational prime \(p\) of the simple component of the group ring `FG`

that corresponds to `Irr(G)[n]`

. The second returns the degree of a certain extension of finite fields of `p`

-power order.

The input of `LocalIndexAtPByBrauerCharacter`

must be an abelian number field `F`, a finite group `G`, and the number `n` of an ordinary irreducible character `Irr(G)[n]`

, and `p` a prime divisor of the order of `G`. Since this function is intended to be used for faithful characters of groups that are the defining groups of non-cyclic cyclotomic algebras that result from **Wedderga**'s Info functions, it is expected that `G`

is a non-nilpotent cyclic-by-abelian group, and `Irr(G)[n]`

is a faithful character. The Brauer character table records of such groups can be accessed in `GAP`

(provided `G`

is sufficiently small).

The local index calculation uses Benard's theorem, which shows that the local index at `p` of the simple component of the rational group algebra `QG` corresponding to the character `Irr(G)[n]`

is the degree of the extension of the residue field of the center given by adjoining an irreducible `p`-Brauer character `IBr(G,p)[m]`

lying in the same block, provided the defect group of the block is cyclic. If the defect group of the block is not cyclic, the resulting calculation is unreliable, and the function will output a list whose second term is the warning label `"DGnotCyclic"`

. The degree of this finite field extension is calculated by `FinFieldExt`

. It determines the local index relative to the field `F`

by dividing the local index at \(p\) over the rationals by a constant determied using a theorem of Yamada.

gap> G:=SmallGroup(80,28); <pc group of size 80 with 5 generators> gap> T:=CharacterTable(G);; gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> S:=T mod 5; BrauerTable( <pc group of size 80 with 5 generators>, 5 ) gap> LocalIndexAtPByBrauerCharacter(Rationals,G,i,5); 2 gap> FinFieldExt(Rationals,G,5,i,9); 2

gap> G:=SmallGroup(72,20); <pc group of size 72 with 5 generators> gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> LocalIndexAtPByBrauerCharacter(Rationals,G,Irr(G)[i],3); [ 2, "DGnotCyclic" ] gap> LocalIndexAtPByBrauerCharacter(Rationals,G,i,2); 1

`‣ LocalIndexAtOddPByCharacter` ( F, G, n, p ) | ( operation ) |

`‣ LocalIndexAtTwoByCharacter` ( F, G, n ) | ( operation ) |

`‣ IsDyadicSchurGroup` ( G ) | ( operation ) |

Returns: The first two function determines the local index at the given prime \(p\) of the simple component of `FG` corresponding to the irreducible character `Irr(G)[n]`

. The third one returns `'true'`

if `G`

is a dyadic Schur group, and otherwise `'false'`

.

`LocalIndexAtOddPByCharacter`

and `LocalIndexAtTwoByCharacter`

first determine a cyclotomic algebra representing the simple component of `FG` corresponding to the character `Irr(G)[n]`

. They then extend the field \(F\) to \(K\), where \(K\) is the maximal \(p\)-split subextension of `F(E(n))/F`

, and recalculates the simple component of `KG`

corresponding to `Irr(G)[n]`

. It then uses the `DefiningGroup...`

functions to reduce to a faithful character of a possibly smaller cyclic-by-abelian group. If the simple component for this character is given in **Wedderga** as a list of length 2 or 4, they make use of `LocalIndexAtOddP`

(7.4-2) or `LocalIndexAtTwo`

(7.4-2) as appropriate. If the simple component over \(F\) has length 5, it checks if the defect group of the \(p\)-block containing `Irr(G)[n]`

is cyclic. If this is definitely so, they use `LocalIndexAtPByBrauerCharacter`

(7.5-6) to calculate the \(p\)-local index. Exceptions can occur when \(p\) is \(2\). When the defect group is not necessarily cyclic, `LocalIndexAtTwoByCharacter`

makes use of `IsDyadicSchurGroup`

, which checks if a quasi-elementary group has a faithful irreducible character `2`

-local index `2`

, then verifies that \(K\) does not split the simple component generated by this character.

These functions are designed for faithful characters of groups that faithfully represent cyclotomic algebras, and so should be used with caution in other situations.

gap> G:=SmallGroup(48,15); <pc group of size 48 with 5 generators> gap> i:=First([1..Length(Irr(G))],i->Size(KernelOfCharacter(Irr(G)[i]))=1);; gap> LocalIndexAtOddPByCharacter(Rationals,G,Irr(G)[i],3); 2 gap> LocalIndexAtTwoByCharacter(Rationals,G,Irr(G)[i]); 2 gap> LocalIndexAtTwoByCharacter(CF(3),G,Irr(G)[i]); 1

`‣ LocalIndicesOfRationalQuaternionAlgebra` ( A ) | ( operation ) |

`‣ LocalIndicesOfRationalSymbolAlgebra` ( a, b ) | ( operation ) |

`‣ LocalIndicesOfTensorProductOfQuadraticAlgs` ( L, M ) | ( operation ) |

`‣ GlobalSchurIndexFromLocalIndices` ( L ) | ( operation ) |

Returns: The first of these functions return a list of pairs `[p,m]`

indicating that `m`

is the local index at the prime \(p\) for the given quaternion algebra. The second does the same for `QuaternionAlgebra(Rationals,a,b)`

. The third returns a list of local indices computed from two given lists of local indices, and the fourth returns the least common multiple of the local indices in the given list of local indices.

For the first function, the input must be a quaternion algebra over the rationals, output from `QuaternionAlgebra(Rationals,a,b)`

. For the first function, \(a\) and \(b\) can be any pair of integers, and for the second rational symbol algebra version, \(a\) and \(b\) are restricted to be either -1 or positive prime integers, otherwise it will return `fail`

. The input of the third function is a pair of lists of \(p\)-local indices in which the maximum local index at any prime is at most 2. The input of the fourth function is a list of pairs `[p,m]`

in which each prime that appears only appears in one of the pairs, and the `m`

's that appear are all positive integers.

`LocalIndicesOfRationalQuaternionAlgebra`

first factors the algebra as a tensor product of rational quaternion algebras, obtaining suitable pairs `a`

and `b`

to which `LocalIndicesOfRationalSymbolAlgebra`

can be applied. The local indices are calculated using well-known formulas involving the Legendre Symbol. The local indices of the original algebra are then determined using `LocalIndicesOfTensorProductOfQuadraticAlgs`

, which takes a pair of lists of local indices of quadratic algebras - for which the maximum local index at any prime \(p\) is 2, and finds the list of local indices of the tensor product of two algebras with these local indices.

`GlobalSchurIndexFromLocalIndices`

simply computes the least common multiple of the local indices at each prime that occurs in the list.

gap> LocalIndicesOfRationalSymbolAlgebra(-1,-1); [ [ infinity, 2 ], [ 2, 2 ] ] gap> LocalIndicesOfRationalSymbolAlgebra(3,-1); [ [ 2, 2 ], [ 3, 2 ] ] gap> LocalIndicesOfRationalSymbolAlgebra(-3,2); fail gap> LocalIndicesOfRationalSymbolAlgebra(3,7); [ [ 2, 2 ], [ 7, 2 ] ] gap> A:=QuaternionAlgebra(Rationals,-30,-15); <algebra-with-one of dimension 4 over Rationals> gap> LocalIndicesOfRationalQuaternionAlgebra(A); [ [ 5, 2 ], [ infinity, 2 ] ] gap> A:=QuaternionAlgebra(CF(5),3,-2); <algebra-with-one of dimension 4 over CF(5)> gap> LocalIndicesOfRationalQuaternionAlgebra(A); fail

`‣ IsRationalQuaternionAlgebraADivisionRing` ( A ) | ( operation ) |

Returns: If the rational quaternion algebra is a noncommutative division ring, `true`

is returned, and if otherwise, `false`

.

The input \(A\) must be a quaternion algebra over the rationals, as output from `QuaternionAlgebra(Rationals,a,b)`

. \(a\) and \(b\) must be rational integers. When applied to other algebras, it returns `fail`

.

The function calculates the rational Schur index of the algebra using `LocalIndicesOfRationalQuaternionAlgebra`

(7.6-1), and returns `true`

if the rational Schur index of the algebra is `2`

, and `false`

if the rational Schur index is `1`

.

This function should be preferred over `GAP`

's `IsDivisionRing`

(Reference: IsDivisionRing) when dealing with rational quaternion algebras, since the result of latter function only depends on the local index at infinity for quaternion algebras, and makes no use of the local indices at the finite primes.

gap> A:=QuaternionAlgebra(Rationals,-30,-15); <algebra-with-one of dimension 4 over Rationals> gap> IsRationalQuaternionAlgebraADivisionRing(A); true gap> LocalIndicesOfRationalQuaternionAlgebra(A); [ [ 5, 2 ], [ infinity, 2 ] ] gap> A:=QuaternionAlgebra(Rationals,3,-2); <algebra-with-one of dimension 4 over Rationals> gap> IsRationalQuaternionAlgebraADivisionRing(A); false gap> LocalIndicesOfRationalQuaternionAlgebra(A); [ ]

Cyclic algebras are represented in **Wedderga** as lists of length 3, in the form `[F,K,[c]]`

, which stands for a cyclic crossed product algebra of the form `(K/F,c)`

, with `K/F`

a cyclic galois extension of abelian number fields, and `c`

an element of `F`

determining the factor set. Schur indices of cyclic algebras can be determined through the solution of inverse norm equations in general. Though currently algorithms for this are not available in **GAP**, algorithms have been implemented in some computational number theory software systems such as **PARI/GP**.

The functions in this section allow one to convert cyclotomic algebras into cyclic algebras (or possibly as tensor products of two cyclic algebras), to convert generalized quaternion algebras into quadratic algebras (i.e. cyclic algebras for a Galois extension of degree 2), to convert quadratic algebras into generalized quaternion algebras, and to convert cyclic algebras into cyclic cyclotomic algebras, whenever possible.

`‣ DecomposeCyclotomicAlgebra` ( A ) | ( operation ) |

Returns: Two lists, each representing a cyclic algebra over the center of \(A\), whose tensor product is isomorphic to the cyclotomic algebra described by \(A\).

The input must be list representing a cyclotomic algebra of length 5 whose Galois group has `2`

generators. This is represented in **Wedderga** as a list of the form `[r,F,n,[[m1,k1,l1],[m2,k2,l2]],[[d]]]`

. (Longer presentations of cyclotomic algebras do occur in **Wedderga** output. Currently we do not have a general decomposition algorithm for them.)

For these algebras, the extension `F(E(n))/F`

is the tensor product of two disjoint extensions `K1`

and `K2`

of `F`

, and the program adjusts one of the factor sets (corresponding to \(l1\) or \(l2\)) so that \(d\) becomes `0`

. After this adjustment, the algebra is then the tensor product of cyclic algebras of the form `[F,K1,[c1]]`

and `[F,K2,[c2]]`

provided `c1`

and `c2`

lie in `F`

. If the latter condition is not satisfied, the string "fails" is appended to the output. (We have not encountered this problem among the group algebras of small groups we have tested so far.)

gap> G:=SmallGroup(96,35); <pc group of size 96 with 6 generators> gap> W:=WedderburnDecompositionInfo(GroupRing(Rationals,G));; gap> Size(W); 12 gap> A:=W[12]; [ 1, NF(8,[ 1, 7 ]), 24, [ [ 2, 7, 12 ], [ 2, 17, 9 ] ], [ [ 3 ] ] ] gap> DecomposeCyclotomicAlgebra(A); [ [ NF(8,[ 1, 7 ]), CF(8), [ -1 ] ], [ NF(8,[ 1, 7 ]), NF(24,[ 1, 7 ]), [ E(8)+2*E(8)^2+E(8)^3 ] ] ]

`‣ ConvertCyclicAlgToCyclicCyclotomicAlg` ( A ) | ( operation ) |

Returns: A list of the form `[1,F,n,[a,b,c]]`

which represents a cyclic cyclotomic algebra.

This function converts a cyclic algebra given by a list `[F,F(E(n)),[E(n)^c]]`

to an isomorphic cyclic cyclotomic algebra represented as the list `[1,F,n,[a,b,c]]`

.

`‣ ConvertQuadraticAlgToQuaternionAlg` ( A ) | ( operation ) |

Returns: A generalized quaternion algebra.

The input should be a list of the form `[F,K,[c]]`

where the field `K`

must be obtained by adjoining the square root of a nonsquare element `d`

of `F`

. The function then returns the quaternion algebra given in `GAP`

by `QuaternionAlgebra(F,d,c);`

.

gap> A:=[NF(24,[1,11]),CF(24),[-1]]; [ NF(24,[ 1, 11 ]), CF(24), [ -1 ] ] gap> ConvertCyclicAlgToCyclicCyclotomicAlg(A); [ 1, NF(24,[ 1, 11 ]), 24, [ 2, 11, 12 ] ] gap> LocalIndicesOfCyclicCyclotomicAlgebra(last); [ ] gap> ConvertQuadraticAlgToQuaternionAlg(A); <algebra-with-one of dimension 4 over NF(24,[ 1, 11 ])> gap> b:=Basis(last);; b[1]^2; b[2]^2; b[3]^2; b[4]^2; e (-1)*e (-1)*e (-1)*e gap> b[2]*b[3]+b[3]*b[2]; 0*e

`‣ ConvertQuaternionAlgToQuadraticAlg` ( A ) | ( operation ) |

Returns: A list of the form `[F,K,[c]]`

representing a cyclic algebra for which the degree of the extension `K/F`

is `2`

.

The input must be a quaternion algebra whose center is an abelian number field \(F\), presented as in the output from `QuaternionAlgebra( F, a, b )`

, with \(a\), \(b\) in \(F\). It returns a list `[F,F(ER(a)),[b]]`

representing the cyclic algebra isomorphic to \(A\).

`‣ ConvertCyclicCyclotomicAlgToCyclicAlg` ( A ) | ( operation ) |

Returns: A list of the form `[F,K,[c]]`

.

The input should be a list `[r,F,n,[a,b,c]]`

representing a matrix ring over a cyclic cyclotomic algebra. The function returns the list `[F,F(E(n)),[E(n)^c]]`

, which represents a cyclic algebra that is Morita equivalent to the given cyclic cyclotomic algebra.

gap> A:=QuaternionAlgebra(CF(5),-3,-1); <algebra-with-one of dimension 4 over CF(5)> gap> ConvertQuaternionAlgToQuadraticAlg(A); [ CF(5), CF(15), [ -1 ] ] gap> ConvertCyclicAlgToCyclicCyclotomicAlg(last); [ 1, CF(5), 30, [ 2, 11, 15 ] ] gap> SchurIndex(last); 1 gap> ConvertCyclicCyclotomicAlgToCyclicAlg(last2); [ 1, [ CF(5), CF(15), [ -1 ] ] ] gap> ConvertQuadraticAlgToQuaternionAlg(last[2]); <algebra-with-one of dimension 4 over CF(5)> gap> b:=Basis(last);; b[1]^2; b[2]^2; b[3]^2; b[4]^2; e (-3)*e (-1)*e (-3)*e

generated by GAPDoc2HTML