Magma - Basic Algebras

Basic Algebras

In the Magma implementation the algebra is given as the sequence of projective modules P₁, ..., P_s together with a path tree for each projective module. A projective module consists of a matrix for each generator a₁, a₂, ..., a_t giving the action of the generator on the vector space of the module. The basis b₁, b₂, ..., b_n for the vector space of P_i is chosen so that each basis element is the image of a basis element of lower index under multiplication by a nonidempotent generator of A. The structure of the basis is recorded in the path tree which is a sequence [<1, i>, <j, k>, ... ] of 2-tuples of length n = Dimension(P_i). The first entry <1, i> indicates that b₁ = b₁ * a_i where a_i is the primitive idempotent in the algebra A such that P_i = A.a_i. Similarly, if entry number k in the path tree is < u, v > then b_k = b_u * a_v where v > s if k > 1.

Creation

The first function for creating a basic algebra is the most basic, in which the user supplies the projective modules and the path trees directly.

BasicAlgebra(Q) : SeqEnum[Tup] -> AlgBas

Given a sequence [Q_i, ..., Q_s] of 2-tuples such that each Q_i = <M_i, T_i> consisting of a module for a matrix algebra M_i and a path tree T_i for M_i, the function creates the basic algebra whose projective modules are the first entries M₁, ..., M_s and the path trees are the corresponding second entries.

The next two functions create a basic algebra from generators and relations. The user must, additionally, specify the quiver with relations, giving the number of idempotents and the beginning and end points of the arrows in the quiver.

BasicAlgebra(F,R,s,P): AlgFr, SeqEnum, RngIntElt, SeqEnum -> AlgBas

Creates the basic algebra given by the presentation. Here F is a free algebra and R is the sequence of relation for the nonidempotent generators of the algebra. If the free algebra F is generated by elements a₁, ..., a_t, the function assumes that a₁, ..., a_s are the mutually orthogonal primitive idempotents and it creates all of the appropriate relations including a₁ + ... + a_s = 1. The nonidempotent generators are then a_{s + 1}, ..., a_t. So ell_k = < i, j > for i, j ≤s means that a_{s + k} = a_i * a_{s + k} * a_j. Each of the relations in R is given as a linear combination of words in the nonidempotent generators a_{s + 1}, ..., a_t ∈F. The sequence P is a sequence of 2-tuples, one for each nonidempotent generator, giving the beginning and ending nodes of the generator. That is, each tuple is the pair of indices of the idempotents which multiply as the identity on the nonidempotent generator on the left and on the right.

BasicAlgebra(F,R) : AlgFr, SeqEnum -> AlgBas

Creates the basic algebra of a local algebra from the presentation of the algebra. Here F is a free algebra whose variable represent the nonidempotent generators and R is the sequence of relations among those variables.

TensorProduct(A, B) : AlgBas, AlgBas-> AlgBas

The tensor product of the basic algebras A and B.

The modular group algebra of a p-group is naturally a basic algebra. The next function create the basic algebra from the group information.

BasicAlgebra(G, k) : GrpPerm, FldFin -> AlgBas

BasicAlgebra(G, k) : GrpPC, FldFin -> AlgBas

BasicAlgebra(G) : GrpPerm -> AlgBass

Given a finite p-group G and a finite field k of characteristic p, returns the group algebra kG in the form of a basic algebra. If no field k is supplied then the prime field of characteristic p is assumed to be the field of coefficients.

Special Basic Algebras

There are several functions that create basic algebras of special interest. The most basic of these creates the basic algebra that is Morita equivalent to a matrix algebra defined over a finite field by first condensing the algebra and then splitting the irreducible modules as needed.

Included among these constructions are the basic algebras of Schur algebras and Hecke algebras over finite fields. The Schur algebras arise in the representation theory of symmetric groups. The Schur algebras have finite global dimension and hence their ext-algebras have finite dimension. By a Hecke algebra, we mean the algebra of endomorphisms of a permutation module of a finite group.

BasicAlgebra(A): AlgMat -> AlgBas

BasicAlgebraOfMatrixAlgebra(A): AlgMat -> AlgBas

This function creates the split basic algebra of the matrix algebra A. The function first produces a presentation and condensed algebra for A. In the event that the field of coefficients k of A is not a splitting field, then the returned basic algebra is defined over the minimal extension of k that is a splitting field for A.

BasicAlgebraOfEndomorphismAlgebra(M): ModRng -> AlgBas

Returns the split basic algebra of the endomorphism ring of the module M. In the event that the field of coefficients of M is not a splitting field for M, then the field is extended and the basic algebra is defined over the minimal extension needed to split M.

BasicAlgebraOfHeckeAlgebra(G, H, F): GrpPerm, GrpPerm, FldFin) -> AlgBas

BasicAlgebraOfHeckeAlgebra(G, H, F): GrpPC, GrpPC, FldFin -> AlgBas

BasicAlgebraOfHeckeAlgebra(G, H, F): GrpAb, GrpAb, FldFin -> AlgBas

Returns the basic algebra of the Hecke algebra which is the algebra of endomorphisms of the permutation module over G with point stabilizer H and field of coefficients F. In the event that F is not a splitting field then the field F is extended to a splitting field which is the field of coefficients of the returned basic algebra.

BasicAlgebraOfSchurAlgebra(n, r, F): RngIntElt, RngIntElt, FldFin -> AlgBas

Creates the basic algebra of the Schur algebra S(n, r) over the field F. The Schur algebra is the algebra of endomorphisms of the module over the symmetric group Sym(r) that is the tensor product of r copies of a vector space V over F of dimension n, the group Sym(r) acting by permuting the r copies.

BasicAlgebraOfGroupAlgebra(G,F): GrpPerm, FldFin -> AlgBas

BasicAlgebraOfGroupAlgebra(G,F): GrpPC, FldFin -> AlgBas

BasicAlgebraOfGroupAlgebra(G,F): GrpAb, FldFin -> AlgBas

The function returns the basic algebra of the group algebra of G with coefficients in the field F. The function requires the creation of the projective indecomposable FG-modules. In the event that the field F is not a splitting field for the irreducible FG-modules then the base ring of the returned algebra is the minimal extension of F that is necessary to get a splitting field.

BasicAlgebra(S) : SeqEnum -> AlgBas

Returns the basic algebra of the action algebra on the module which is the direct sum of the modules in the sequence S. In the event that the irreducible composition factors of the modules in S are not absolutely irreducible, then the returned basic algebra is defined over the splitting field for the irreducible modules.

BasicAlgebraOfBlockAlgebra(S) : SeqEnum -> AlgBas

Returns the basic algebra of the block algebra, the projective modules of which are given in the sequence S. In the event that the irreducible composition factors of the modules in S are not absolutely irreducible, then the returned basic algebra is defined over the splitting field for the irreducible modules.

BasicAlgebraOfPrincipalBlock(G,k) : GrpPerm, FldFin -> AlgBas

Returns the basic algebra of the principal block of the group algebra of G. If the simple modules in the principal kG block are all absolutely simple, then the ordering of the projective modules for the returned basic algebra is exactly the same as the ordering of the projectives modules in the principal block returned by the function IndecomposableProjectives. Otherwise, the base ring of the returned basic algebra is the least extension of k necessary to split the simple modules in the principal block and the simple modules of the returned algebra are ordered by increasing dimension of the corresponding simple modules of kG.

BasicAlgebraOfExtAlgebra(A) : AlgBas -> AlgBas

The function returns the basic algebra from a computed ext-algebra which is Ext_A^*(S, S), where S is the direct sum of the irreducible A-modules, of the basic algebra A. If no ext-algebra for A has been computed or if the exalgebra is not verified to be finite dimensional then an error is returned.

BasicAlgebraOfExtAlgebra(A, n) : AlgBas, RngIntElt -> AlgBas

The function returns the basic algebra for the ext-algebra, which is Ext_A^*(S, S), where S is the direct sum of the irreducible A-modules, of A computed to n steps. If no ext-algebra for A to n steps has been computed then it will be computed. If the ext-algebra is not verified to be finite dimensional by the computation, then an error is returned.

BasicAlgebraOfExtAlgebra(A) : Rec -> AlgBas

The function creates the basic algebra from a computed ext-algebra. The input ext is the output of the ExtAlgebra function. If the ext-algebra is not verified to be finite dimensional by the computation, then an error is returned.

OppositeAlgebra(B) : AlgBas -> AlgBas

The opposite algebra of the basic algebra B. The opposite algebra of B is the algebra with the same set of elements and the same addition but with multiplication * given by a * b = ba for a and b in A.

Example `AlgBas_GroupAlgebra (H94E1)`

We form the basic algebra of the group algebra of the alternating group on 6 letters in characteristic 2.

> G := AlternatingGroup(6);
> A := BasicAlgebraOfGroupAlgebra(G, GF(2));
> A;
Basic algebra of dimension 36 over GF(2^2)
Number of projective modules: 5
Number of generators: 9

Note that the field of coefficients has been extended in order to split the irreducible G-modules. A great deal of information on the nature of the group algebra and its basic algebra can be obtained from analysis such as the following.

> [Dimension(ProjectiveModule(A,i)): i in [1 .. 5]];
[ 9, 9, 16, 1, 1 ]
> prj := CompactProjectiveResolutionsOfAllSimpleModules(A,8);
> [x`BettiNumbers:x in prj];
[
    [
        [ 1, 0, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 1, 0, 0, 0, 0 ]
    ],
    [
        [ 0, 1, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 0, 1, 0, 0, 0 ],
        [ 0, 1, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 0, 1, 0, 0, 0 ],
        [ 0, 1, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 0, 1, 0, 0, 0 ]
    ],
    [
        [ 0, 0, 3, 0, 0 ],
        [ 1, 1, 2, 0, 0 ],
        [ 0, 0, 3, 0, 0 ],
        [ 0, 0, 2, 0, 0 ],
        [ 1, 1, 1, 0, 0 ],
        [ 0, 0, 2, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 1, 1, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ]
    ],
    [
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 1, 0 ]
    ],
    [
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 1 ]
    ]
]

So we see that the last two simple modules are projective and hence in the group algebra FG, they represent blocks of defect 0. From the information on the Betti numbers we observe that the first two simple modules have periodic projective resolutions. Thus the third simple module for the basic algebra corresponds to the trivial FG-module, which we know is neither projective nor periodic.

Example `AlgBas_SchurAlgebra (H94E2)`

We construct the Schur algebra S(3, 7) with coefficients in a field of characteristic 2.

> A := BasicAlgebraOfSchurAlgebra(3,6,GF(2));
> A;
Basic algebra of dimension 58 over GF(2)
Number of projective modules: 7
Number of generators: 21

It is known that A has finite global dimension, hence its ext-algebra has finite dimension.

> B := BasicAlgebraOfExtAlgebra(A,10);
> B;
Basic algebra of dimension 56 over GF(2)
Number of projective modules: 7
Number of generators: 25

We check to see if the ext-algebra of B might have finite dimension.

> SumOfBettiNumbersOfSimpleModules(B,5);
600
> SumOfBettiNumbersOfSimpleModules(B,6);
1334
> SumOfBettiNumbersOfSimpleModules(B,7);
3008

The sum of the Betti number would be the dimension of the ext-algebra computed to the indicated degree. It would appear that the ext-algebra is infinite dimensional. Just to check, we look at a particular simple module, chosen randomly.

> CompactProjectiveResolution(SimpleModule(B,4),10)`BettiNumbers;
[
    [ 8, 0, 81, 3, 61, 69, 55 ],
    [ 3, 0, 36, 1, 26, 30, 24 ],
    [ 1, 0, 16, 1, 11, 13, 10 ],
    [ 1, 0, 7, 1, 5, 5, 4 ],
    [ 1, 0, 3, 1, 2, 2, 1 ],
    [ 1, 0, 1, 0, 1, 1, 0 ],
    [ 0, 0, 0, 0, 1, 1, 0 ],
    [ 0, 0, 0, 0, 1, 0, 1 ],
    [ 0, 0, 0, 1, 0, 1, 0 ],
    [ 1, 0, 0, 0, 0, 0, 1 ],
    [ 0, 0, 0, 1, 0, 0, 0 ]
]

Thus we have strong evidence that the fourth simple module has infinite projective dimension. In that case, the ext-algebra of B is not finite dimensional.

Now we consider the same example except in characteristic 3.

> A := BasicAlgebraOfSchurAlgebra(3,6,GF(3));
> A;
Basic algebra of dimension 48 over GF(3)
Number of projective modules: 7
Number of generators: 21
> B := BasicAlgebraOfExtAlgebra(A,10);
> B;
Basic algebra of dimension 98 over GF(3)
Number of projective modules: 7
Number of generators: 21
> SumOfBettiNumbersOfSimpleModules(B,5);
48
> SumOfBettiNumbersOfSimpleModules(B,6);
48

So we see that the algebra B has global dimension at most 5. We can compute its ext-algebra.

> C := BasicAlgebraOfExtAlgebra(B,10);
> C;
Basic algebra of dimension 48 over GF(3)
Number of projective modules: 7
Number of generators: 21
> D := BasicAlgebraOfExtAlgebra(C,10);
> D;
Basic algebra of dimension 98 over GF(3)
Number of projective modules: 7
Number of generators: 21

This provides evidence that A is isomorphic to its double ext-algebra. This would suggest that A might be a Koszul algebra.

A Database of Basic Algebras

A small library of basic algebras for the p-modular group algebras of some of the smaller groups that are catalogued in Atlas is provided. This library will be referred to as the Basic Algebras for Atlas Groups database. For each group G included in the library and each prime p dividing the order of G, the basic algebra for each p-block of the group algebra K[G] is stored. A second library contains the basic algebras of a small collection of Schur algebras S(n, r) and will be referred to as the Basic Algebras for Schur Algebras database.

BasicAlgebraFromGroup(A, p, b) : MonStgElt, RngIntElt, RngIntElt -> AlgBas

This function reconstructs from a library the basic algebra of the block number b of the group algebra K[G] where K is a field of characteristic p and G is the finite group with Atlas name A. Block number 1 is always the principal block.

BasicAlgebraGroupNames() : -> SetIndx

This intrinsic returns the names of the basic algebras that are stored in the Basic Algebras for Atlas Groups database.

BasicAlgebraFromSchur(n, r, p) : RngIntElt, RngIntElt, RngIntElt -> AlgBas

Let n and r be positive integers and p a prime such that the triple is the name of a basic algebra in the Basic Algebras for Schur Algebras database. This intrinsic retrieves a basic algebra for the Schur algebra S(n, r) from the database.

Example `AlgBas_BasicDatabase (H94E3)`

We retrieve the basic algebra for the principal 5-block of Atlas Group 2A8 from the Basic Algebras for Atlas Groups database.

> A := BasicAlgebraFromGroup("2A8", 5, 1);
> A;
Basic algebra of dimension 14 over GF(5)
Number of projective modules: 4
Number of generators: 10
>
> [ Dimension(ProjectiveModule(A, i)) : i in [1..4] ];
[ 3, 4, 3, 4 ]

For some groups not all basic algebras are stored. Thus for the sporadic group McL only the algebras for the principal blocks for p = 2, 3, 5 are currently in the database.

> A := BasicAlgebraFromGroup("McL", 2, 1);
> A;
Basic algebra of dimension 1004 over GF(2)
Number of projective modules: 8
Number of generators: 28
>
>  [ Dimension(ProjectiveModule(A, i)) : i in [1..8] ];
[ 152, 280, 100, 128, 128, 64, 64, 88 ]
>
> A := BasicAlgebraFromGroup("McL", 3, 1);
> A;
Basic algebra of dimension 6284 over GF(3^2)
Number of projective modules: 10
Number of generators: 42
>
> [ Dimension(ProjectiveModule(A, i)) : i in [1..10] ];
[ 1274, 857, 657, 657, 876, 1127, 194, 194, 252, 196 ]
>
> A := BasicAlgebraFromGroup("McL", 5, 1);
> A;
Basic algebra of dimension 788 over GF(5^2)
Number of projective modules: 12
Number of generators: 42
>
>  [ Dimension(ProjectiveModule(A, i)) : i in [1..12] ];
[ 64, 122, 46, 15, 117, 104, 104, 67, 67, 52, 15, 15 ]

Access Functions

These functions return basic information, underlying structures and elements of the given basic algebras.

B . i : AlgBas, RngIntElt -> AlgBasElt

The i^th element in the standard basis for the underlying vector space of the algebra B.

BaseRing(B) : AlgBas -> Rng

CoefficientRing(B) : AlgBas -> Rng

Given an algebra B over a field k the function returns k.

VectorSpace(B) : AlgBas -> ModTupFld

KSpace(B) : AlgBas -> ModTupFld

The underlying k-vector space of the algebra B. The space is the direct sum of the underlying vector space of the indecomposable projective modules.

Dimension(B) : AlgBas -> RngIntElt

The dimension of the underlying vector space of the algebra B.

Basis(B) : AlgBas -> SeqEnum

A basis of the underlying vector space of the algebra B.

Generators(B) : AlgBas -> SeqEnum

The generators of the algebra B as a sequence of elements in the underlying vector space of the algebra B.

IdempotentGenerators(B) : AlgBas -> SeqEnum

The sequence of mutually orthogonal idempotent generators of the basic algebra B as elements in the underlying vector space of B.

IdempotentPositions(B) : AlgBas -> SeqEnum

The sequence N = [n₁, ..., n_s] such that B.n₁, ..., B.n_s are the mutually orthogonal idempotent generators of the algebra B.

NonIdempotentGenerators(B) : AlgBas -> SeqEnum

The sequence of nonidempotent generators of the basic algebra B as elements in the underlying vector space of the algebra B.

Random(B) : AlgBas -> AlgBasElt

A random element of the algebra B as an element of the underlying vector space of B.

NumberOfProjectives(B) : AlgBas -> RngIntElt

The number of nonisomorphic indecomposable projective modules in the basic algebra B.

NumberOfGenerators(B) : AlgBas -> RngIntElt

Ngens(B) : AlgBas -> RngIntElt

The number of generators (idempotent and nonidempotent) of the basic algebra B.

DimensionsOfProjectiveModules(B) : AlgBas -> SeqEnum

The sequence of the dimensions of the projective modules of the basic algebra B.

DimensionsOfInjectiveModules(B) : AlgBas -> SeqEnum

The sequence of the dimensions of the injective modules of the basic algebra B.

Elementary Operations

a + b : AlgBasElt, AlgBasElt -> AlgBasElt

The sum of the two elements a and b.

a * b : AlgBasElt, AlgBasElt -> AlgBasElt

The product of the two elements a and b.

a ^ n : AlgBasElt, RngIntElt -> AlgBasElt

The n^th power of the element a.

Example `AlgBas_BasicAlgebras (H94E4)`

We create the basic algebra of the quiver with three nodes and three arrows over the field with 7 elements. The first arrow (cs a) goes from node 1 to node 2, the second (cs b) from node 2 to node 1, and (cs c) from node 2 to node 3. The arrows satisfy the relation that (cs a * cs b)³ = 0.

> ff := GF(7);
> FA<e1,e2,e3,a,b,c> := FreeAlgebra(ff,6);
> rrr := [a*b*a*b*a*b];
> D := BasicAlgebra(FA,rrr,3,[<1,2>,<2,1>,<2,3>]);
> D;
Basic algebra of dimension 21 over GF(7)
Number of projective modules: 3
Number of generators: 6

> DimensionsOfProjectiveModules(D);
[ 9, 11, 1 ]
> DimensionsOfInjectiveModules(D);
[ 6, 7, 8 ]

So we can see that the algebra is not self-injective.

Now we can check the nilpotence degree of the radical of cs D. The radical of cs{D} is generated by the nonidempotent generators.

> S := NonIdempotentGenerators(D);
> S;
[ (0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0), (0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 
0 0 0 0 0), (0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0) ]
> S2 := [x*y:x in S, y in S|x*y ne 0];
> #S2;
3
> S3 := [x*y:x in S2, y in S|x*y ne 0];
> #S3;
3
> S4 := [x*y:x in S3, y in S|x*y ne 0];
> #S4;
3
> S5 := [x*y:x in S4, y in S|x*y ne 0];
> #S5;
3
> S6 := [x*y:x in S5, y in S|x*y ne 0];
> #S6;
2
> S7 := [x*y:x in S6, y in S|x*y ne 0];
> #S7;
1
> S8 := [x*y:x in S7, y in S|x*y ne 0];
> #S8;
0

Example `AlgBas_BasicAlgebras-2 (H94E5)`

First we create the basic algebra for the symmetric group S₃ over the field GF(3)

> FA<e1,e2,a,b> := FreeAlgebra(GF(3),4);
> MM:= [a*b*a, b*a*b];
> BS3 := BasicAlgebra(FA, MM, 2, [<1,2>,<2,1>]);
> BS3;
Basic algebra of dimension 6 over GF(3)
Number of projective modules: 2
Number of generators: 4
> DimensionsOfProjectiveModules(BS3);
[ 3, 3 ]

Next we create the basic algebra for the cyclic group of order 3.

> gg := CyclicGroup(3);
> BC3 := BasicAlgebra(gg,GF(3));
> BC3;
Basic algebra of dimension 3 over GF(3)
Number of projective modules: 1
Number of generators: 2

We create the basic algebra for the direct product C₃ x S₃.

> A := TensorProduct(BS3,BC3);
> A;
Basic algebra of dimension 18 over GF(3)
Number of projective modules: 2
Number of generators: 6
> DimensionsOfProjectiveModules(A);
[ 9, 9 ]

Example `AlgBas_BasicAlgebras-3 (H94E6)`

We create the basic algebra for A₄ over a field with 2 elements. The group algebra has two nonisomorphic projective modules. We define the basic algebra by constructing the matrix algebra for the projective modules and the path trees and entering this data into the BasicAlgebra function.

Note that the matrices are sparse so we will define them by specifying the nonzero rows.

> ff := GF(2);
> MM6 := MatrixAlgebra(ff,6);
> e11 := MM6!0;
> e12 := MM6!0;
> VV6 := VectorSpace(GF(2),6);
> BB6 := Basis(VV6);
> e11[1]  := BB6[1];
> e11[3]  := BB6[3];
> e11[4]  := BB6[4];
> e11[6]  := BB6[6];
> e12[2]  := BB6[2];
> e12[5]  := BB6[5];
> a1 := MM6!0;
> b1 := MM6!0;
> c1 := MM6!0;
> d1 := MM6!0;
> a1[1] := BB6[2];
> b1[1] := BB6[3];
> c1[2] := BB6[4];
> a1[3] := BB6[5];
> b1[4] := BB6[6];
> c1[5] := BB6[6];
> A1 := sub< MM6 | [e11, e12, a1, b1, c1, d1] >;
> T1 := [ <1,1>, <1,3>, <1,4>, <2,5>, <3,3>, <4,4>];
> 
> VV5 := VectorSpace(ff,5);
> BB5 := Basis(VV5);
> MM5 := MatrixAlgebra(ff,5);
> e21 := MM5!0;
> e22 := MM5!0;
> e22[1]  := BB5[1];
> e22[3]  := BB5[3];
> e22[5]  := BB5[5];
> e21[2]  := BB5[2];
> e21[4]  := BB5[4];
> a2 := MM5!0;
> b2 := MM5!0;
> c2 := MM5!0;
> d2 := MM5!0;
> f2 := MM5!0;
> g2 := MM5!0;
> c2[1] := BB5[2];
> d2[1] := BB5[3];
> b2[2] := BB5[4];
> d2[3] := BB5[5];
> a2[4] := BB5[5];
> A2 := sub< MM5 | [e21, e22, a2, b2, c2, d2] >;
> T2 := [<1,2>, <1,5>, <1,6>, <2,4>, <3,6>];
> 
> C := BasicAlgebra( [<A1, T1>, <A2, T2>] );
> C;
Basic algebra of dimension 11 over GF(2)
Number of projective modules: 2
Number of generators: 6
> DimensionsOfProjectiveModules(C);
[ 6, 5 ]
> DimensionsOfInjectiveModules(C);
[ 6, 5 ]

Boolean Functions

A basic algebra in Magma is a sequence of matrix algebras, each with a path tree. When a basic algebra is created by entering such a sequence, Magma does not check to see if all of the properties of a basic algebra are satisfied, as this is an expensive operation. The following two function check to see if the properties of a basic algebra are satisfied.

IsDimensionCompatible(B) : AlgBas -> Bool

Returns true if the dimension of a basic algebra is the same as the dimension of the matrix algebra of its action on itself. If false then the algebra is not a basic algebra.

IsPathTree(B) : AlgBas -> Bool

Returns true if the basis elements of the projective modules in the basic algebra are determined by the path tree. If false, then the algebra is not a true basic algebra.