Algebras with Involution

This section introduces two general constructions for *-algebras:

(i)
The algebra of adjoints of a system of reflexive (alternating, reflexive, or Hermitian) forms [φ1, ..., φe] defined on a common vector space V.

(ii)
The group algebra K[G], where K is any ring and G is a finite group.

We also provide a constructor function for simple *-algebras.

Contents

Reflexive Forms

A reflexive form on a K-vector space V is a bilinear function φ: V x V to K such that, whenever φ(u, v)=0 for u, v∈V, we also have φ(v, u)=0. Reflexive forms φ and ψ on V are isometric if φ(u, v)=ψ(u, v) for all u, v∈V; they are similar if there exists a∈K such that φ and aψ are isometric. The radical of a reflexive form φ is the subspace (rad)φ={u∈V:φ(u, V)=0}, and φ is nondegenerate if (rad)φ=0.

A fundamental result of Birkhoff and von Neumann states that there are three similarity classes of reflexive forms: alternating, symmetric, and Hermitian. Each such form φ is represented by a matrix and an automorphism of K. Specifically, regarding V as the space of row vectors, we specify F and α such that φ(u, v)=uαFv^((tr)), where α is the identity if φ is bilinear, or the automorphism x |-> /line(x) of order 2 if φ is Hermitian. Thus a matrix g∈(GL)(d, K) is an isometry (respectively similarity) of the reflexive form if gαFg^((tr))=F (respectively gαFg^((tr))=aF).

IsometryGroup(F : parameters) : AlgMatElt -> GrpMat
    Auto: RngIntElt                     Default: 0
The group of isometries of the (possibly degenerate) reflexive form represented by the matrix F with entries in a finite field GF(pe). The field automorphism associated with F is specified by the parameter Auto, which represents the exponent f in the map x |-> xpf. The default is that F is bilinear on its base ring.
SimilarityGroup(F : parameters) : AlgMatElt -> GrpMat
    Auto: RngIntElt                     Default: 0
The group of similarities of the (possibly degenerate) reflexive form represented by the matrix F with entries in a finite field GF(pe). The field automorphism associated with F is specified by the parameter Auto, which represents the exponent f in the map x |-> xpf. The default is that F is bilinear on its base ring.

Systems of Reflexive Forms

A system of forms is a sequence [φ1, ..., φe], where each φi is a reflexive form on a common K-vector space V. The radical of a system of forms is the intersection of the radicals of the individual forms in the system; A system is nondegenerate if its radical is zero.

A classical group on a K-vector space V preserves a reflexive form on V that is unique up to similarity. Hence systems of forms arise naturally from sets of classical groups having V as their common defining module.

Systems of forms also arise naturally from the study of p-groups. Let G be a finite p-group. Let G=γ1(G)>γ2(G)> ... >γm(G)=1 denote the lower central series of G, and let 1=ζ1(G)<ζ2(G)< ... <ζn(G)=G denote its upper central series. Let Φ(G) be the Frattini subgroup of G, and put N:=< Φ(G), ζn - 1(G) >. Then V=G/N and W=γ2(G)/γ3(G) are (GF)(p)-vector spaces and commutation in G induces a bilinear map V x V to W. One now obtains a system of forms associated to G by choosing bases for V and W.

Just as matrices are useful representations of bilinear forms, so are systems of forms convenient computational models for bilinear maps.

PGroupToForms(G) : GrpPC -> SeqEnum
PGroupToForms(G,p) : GrpPC, RngIntElt -> SeqEnum
Return a system of forms associated to the p-group G, which must be of type GrpPC.
PGroupToForms(G) : GrpMat -> SeqEnum
PGroupToForms(G,p) : GrpMat, RngIntElt -> SeqEnum
Return a system of forms associated to the matrix group G, which must be a class 2 p-group.

Example AlgInv_PGroupToForms (H94E1)

We construct a system of forms associated to a Sylow 7-subgroup of (GL)(3, 7).
> S := ClassicalSylow(GL (3, 7), 7);
> G := PCGroup(S);
> Forms := PGroupToForms(G);
> Forms;
[
    [0 1]
    [6 0]
]
Now we apply the same construction working directly with the matrix group as a p-group of class 2.
> Forms := PGroupToForms(S);
> Forms;
[
    [0 1]
    [6 0]
]
It is preferable to input a PC-group if such a representation can readily be obtained. The option to use a matrix group for p-groups of class 2 enables the user to construct an associated system of forms in situations where it requires considerably more time to first construct a PC-representation.

Basic Attributes of *-Algebras

Using the following functions one can ascertain whether or not a given algebra has an assigned involution, and also access the map if it has.

IsStarAlgebra(A) : AlgMat -> BoolElt
IsStarAlgebra(A) : AlgGrp -> BoolElt
Return true if and only if A has an assigned involution.
Star(A) : AlgMat -> Map
Star(A) : AlgGrp -> Map
Return the involution associated to the *-algebra A.

Adjoint Algebras

Let S=[φ1, ..., φe] be a system of reflexive forms on a K-vector space V. Let R denote the algebra (End)K(V) and R^((op)) denote its opposite ring. Then the algebra of adjoints of S is defined as follows:

(Adj)(S) = {(x, y)∈R x R^((op)): φi(ux, v)=φi(u, yv) forall u, v∈V, forall i∈{1, ..., e}}.

As the φi are reflexive forms, (x, y)∈(Adj)(S) if and only if (y, x)∈(Adj)(S). If S is nondegenerate, then y is uniquely determined by x; thus we identify (Adj)(S) with its projection onto R and the assignment x * :=y equips (Adj)(S) with an involution.

The function to compute (Adj)(S) is an implementation of the algorithms in [BW12a, Proposition 5.1] and [BW12b, Section 5].

AdjointAlgebra(S : parameters) : SeqEnum -> AlgMat
    Autos: SeqEnum                      Default: [0,..,0]
Given a sequence S containing a nondegenerate system of reflexive forms, this function returns the *-algebra of adjoints of the forms in S. The parameter Autos is used to specify a list of Frobenius exponents associated with the given forms. By default all forms are considered to be bilinear over their common base ring, which must be a finite field. Note that the individual forms in the system are allowed to be degenerate.

Example AlgInv_AdjointAlgebra (H94E2)

We construct the algebra of adjoints of a particular pair of forms on a vector space of dimension 3 over (GF)(52). The matrices have entries in (GF)(5) but we regard them as forms over the larger field, and define the first (symmetric) form to be Hermitian over the larger field.
> MA := MatrixAlgebra(GF (25), 3);
> F := MA![1,2,0,2,3,4,0,4,1];
> G := MA![0,1,0,4,0,0,0,0,0];
> A := AdjointAlgebra([F, G] : Autos := [1, 0]);
> IsStarAlgebra(A);
true
> Degree(A);
6
> BaseRing(A);
Finite field of size 5
Observe that the function has converted the given system of forms to a new system over (GF)(5) and returned an algebra of degree 6 over the subfield. Now we access the involution on A and apply it to a generator of A.
> star := Star(A);
> A.3;
[1 0 2 0 2 0]
[0 1 0 2 0 2]
[1 0 4 0 4 0]
[0 1 0 4 0 4]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
> A.3@star;
[4 0 3 0 3 0]
[0 4 0 3 0 3]
[4 0 1 0 1 0]
[0 4 0 1 0 1]
[0 0 0 0 0 0]
[0 0 0 0 0 0]

Group Algebras

If G is a finite group and R is any ring, then the group algebra A=R[G] possesses a natural involution. Thus each group algebra may be regarded as a *-algebra.

StarOnGroupAlgebra(A) : AlgGrp -> Map
The natural involution on the group algebra A induced by inversion on the underlying group. Specifically, if a=∑g∈Gαgg∈A, then a * =∑g∈Gαgg - 1.
GroupAlgebraAsStarAlgebra(R, G) : Rng, Grp -> AlgGrp
Construct the group algebra R[G] equipped with the natural involution afforded by inversion in G.

Example AlgInv_GroupAlgebraAsStarAlgebra (H94E3)

We construct the group algebra Z[S3] as a *-algebra.
> G := SymmetricGroup(3);
> K := Integers();
> A := GroupAlgebraAsStarAlgebra(K, G);
> IsStarAlgebra(A);
true
Now access the involution on A and apply it to an element of A.
> star := Star(A);
> a := A![0,0,1,0,3,0];
> a;
(1, 3, 2) + 3*(1, 2)
> a@star;
(1, 2, 3) + 3*(1, 2)

Example AlgInv_GroupAlgebraAsStarAlgebra2 (H94E4)

Alternatively, Z[S3] can be constructed using the standard constructor and the involution can be attached later.
> A := GroupAlgebra(K, G);
> IsStarAlgebra(A);
false
> StarOnGroupAlgebra(A);
Mapping from: AlgGrp: A to AlgGrp: A given by a rule [no inverse]
> IsStarAlgebra(A);
true

Simple *-Algebras

The Artinian simple *-algebras -- those having no proper *-invariant ideals -- were classified by Albert [Alb61]. They come in two basic flavours: classical and exchange. The classical types are simple as algebras and arise as adjoints of nondegenerate reflexive forms. A simple *-algebra of exchange type is a direct sum of two isomorphic simple algebras where the involution interchanges the two factors. Naturally extending the Magma classification of reflexive forms (see the manual entry for the function ClassicalForms) a simple *-algebra S is assigned a name as follows:

"symplectic" if S is defined by an alternating form;

"orthogonalcircle" if S is defined by a symmetric form in odd dimension;

"orthogonalplus" if S is defined by a symmetric form of maximal Witt index;

"orthogonalminus" if S is defined by a symmetric form of non-maximal Witt index;

"unitary" if S is defined by an Hermitian form; and

"exchange" if S has exchange type.

Every simple *-algebra is isomorphic to a standard simple *-algebra having one of these six names defined naturally on a suitable vector space.

We note that involutions on simple *-algebras are often classified as being "of the first kind" or "of the second kind" according to whether or not they induce the identity on the center of the algebra. Thus, involutions of the second kind are unitary and exchange, and the others are all involutions of the first kind [KMRT98].

SimpleStarAlgebra(name, d, K) : MonStgElt, RngIntElt, FldFin -> AlgMat
Given a name, a positive integer d, and a field K, this function constructs the standard copy of the simple *-algebra of type name defined naturally on a K-vector space of dimension d.

Example AlgInv_SimpleStarAlgebra (H94E5)

We construct the standard copy of the simple *-algebra of exchange type on the vector space of dimension 4 over (GF) (16).
> K := GF(16);
> S := SimpleStarAlgebra("exchange", 4, K);
> Dimension(S);
8
> IsStarAlgebra(S);
true;
> w := K.1;
> s := S.1 * S.2 + w * S.1;
> s;
[   K.1      1      0      0]
[     0      0      0      0]
[     0      0      0      0]
[     0      0      0      0]
> star := Star(S);
> s@star;
[     0      0      0      0]
[     0      0      0      0]
[     0      0    K.1      0]
[     0      0      1      0]
V2.28, 13 July 2023