A homomorphism from module M to module N is simply a matrix that commutes with the action of the algebra on M and N.
The space of homomorphisms from module M to module N.
The space of projective homomorphisms from module M to module N. That is, the space of all homomorphisms that factor through a projective module.
The zero homomorphism from module M to module N.
Given an element x in a module over a basic algebra and a natural number n, the function returns the homomorphism from the nth projective module for the algebra to the module with the property that the idempotent e of the projective module maps to x * e.
Given a sequence X = [x1, ..., xt] of elements in a module M over a basic algebra and a sequence N = [n1, ..., ns] of nonnegative integers, such that n1 + ... + ns = t, the function returns the homomorphism P -> M from the projective module P = ∑j=1s Pjni to M that takes the idempotent e for the ith summand in P to the element xi * e in M. Here Pj denotes the jth projective module for the algebra.
The pushout of the diagramvbox(offinterlineskip halign(hfil()#()hfil&hfil()#()hfil&hfil()#()hfil
M & mapright(f1) & N1
mapdown(f2) & &
N2 & &
))The function returns the module L = (N1 direct-sum N2)/{(f1(m), - f2(m))|m ∈M} and the homomorphisms g1:N1 -> L and g2: N2 -> L such that f1g1 = f2g2.
The pullback of the diagramvbox(offinterlineskip halign(hfil()#()hfil&hfil()#()hfil&hfil()#()hfil
& & M2
& & mapdown(f2)
M1 & mapright(f1) & N
))The function returns the module L = {(m1, m2) ∈M1 direct-sum M2 |f1(m1) = f2(m2)} and the homomorphisms g1:L -> M1 and g2: L -> M2 such that g1f1 = g2f2.
Returns true if the map f is a homomorphism of modules over the algebra.
The domain of f.
The codomain of f.
The kernel of f and the inclusion of the kernel in cs{Domain(f).}
The cokernel of f and the quotient map from cs{Codomain(f)} onto the cokernel.
A projective cover of a module M is a projective module P and a surjective homomorphism φ:P -> M such that P is minimal with respect to the property of having such a surjective homomorphism to M. A projective resolution to n steps of an A-module M is a pair consisting of a complex
Pn mapright(∂n) Pn - 1 -> ... -> P1 mapright(∂1) P0
which is exact except at the ends, and an augmentation homomorphism ε: P0 -> M that is a projective cover of M. In addition, the image of ∂1 must equal the kernel of ε. The resolution is minimal if each Pi is a projective cover of its image in Pi - 1. In this case the ith syzygy module is the image of ∂i.
In the implementation the main function is cs{CompactProjectiveResolution.} This function computes a minimal projective resolution of a given module and stores the minimal amount of information that is necessary to create the boundary maps and the terms of the resolution. It runs relatively fast because it avoids the computation of the terms of the projective resolution as modules over the algebra. Instead the terms in the compact resolution are only vector spaces together with a sequence of types for the projective modules. The other information that is recorded is the sequence of images of the generators for the indecomposable projective modules. That is, for the boundary map
Pn mapright(∂n) Pn - 1
the module Pn isomorphic to direct-sum i = 1m Qi where each Qi is an indecomposable projective module generated by an element ai corresponding to the appropriate idempotent in the basic algebra. The function records the images ∂n(ai) as a sequence of vectors in the vector space of the module Pn - 1.
The projective cover of the module M given as the projective module P, the surjective homomorphism of P onto M, the sequences of inclusion and projection homomorphism of P from and to its indecomposable direct summands and the isomorphism type of P in the form of a list of the number of copies of the projective modules of the algebra of each type that make up P.
The complex giving the minimal projective resolution of the module M out to n steps together with the augmentation homomorphism from the projective cover of M into M. Note that homomorphisms go from left to right so that last term of the complex (in degree 0) is the projective cover of M and the cokernel of the last homomorphism in the complex is M. The complex is constructed from the compact projective resolution of M. The function creates the compact projective resolution if it has not already been computed.
Returns a minimal projective resolution for the module M out to n steps in compact form together with the augmentation map (P0 -> M). The compact form of the resolution is a list of the minimal pieces of information needed to reconstruct the boundary maps in the resolution. That is the boundary map (Pi mapright(∂i) Pi - 1) is recorded as a matrix whose entries are the images of the generators for indecomposable projective modules making up Pi in the indecomposable projective modules making up Pi - 1. If a compact projective resolution has been previously computed to degree m and m < n then the function extends that resolution by n - m steps. If m ≥n the function returns the previously computed compact projective resolution. The function returns a record with the fields:
- (a)
- The list of isomorphism types of the projective modules in the resolution, each given as a sequence of integers giving the number of direct summands of each indecomposable projective in the module (field name BettiNumbers).
- (b)
- The record of the boundary maps (field name ResolutionRecord).
- (c)
- The module M (field name Module).
- (d)
- The augmentation map (field name AugmentationMap).
- (e)
- The type of the resolution, whether projective or injective (field name Typ).
Returns a sequence of the compact projective resolutions of the simple A-modules computed to degree n.
The nth syzygy module of the module M. The module is constructed from the compact projective resolution of M. The compact resolution is constructed if it does not already exist.
The sequence of sequences of dimensions of the homology groups Torj(Si, M) for simple modules Si and module M, to the extent that they have been computed.
> ff := GF(8); > FA<e1,e2,e3,e4,a,b,c,d,f> := FreeAlgebra(ff,9); > rrr := [b*c*f*a*b*d*b,a*b*c*f*a*b*c*f*a*b*c*f*a*b*c*f*a*b*c*f*a*b, > b*d*b*d*b]; > BA := BasicAlgebra(FA,rrr,4,[<1,2>,<2,3>,<3,4>,<3,2>,<4,1>]); > BA; Basic algebra of dimension 296 over GF(2^3) Number of projective modules: 4 Number of generators: 9Now we take the projective resolutions of the simple modules out to 5 steps. We print the type of the projective module at each stage.
> for i := 1 to 4 do
> S := SimpleModule(BA,i);
> prj := CompactProjectiveResolution(S, 5);
> SimpleHomologyDimensions(S);
> end for;
[
[ 0, 0, 10, 0 ],
[ 0, 0, 5, 0 ],
[ 0, 0, 2, 0 ],
[ 0, 0, 1, 0 ],
[ 0, 1, 0, 0 ],
[ 1, 0, 0, 0 ]
]
[
[ 0, 0, 16, 0 ],
[ 0, 0, 8, 0 ],
[ 0, 0, 4, 0 ],
[ 0, 0, 2, 0 ],
[ 0, 0, 1, 0 ],
[ 0, 1, 0, 0 ]
]
[
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 1, 0, 1 ],
[ 0, 0, 1, 0 ]
]
[
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 1, 0, 0, 0 ],
[ 0, 0, 0, 1 ]
]
So we see that the third and fourth simple modules have finite projective
dimension. The projective resolutions of the first and second simple modules
appear to have exponential rates of growth but the terms after the second
term are all direct sums of copies of the third projective module.
> for i := 1 to 4 do > Dimension(Socle(ProjectiveModule(BA,i))); > end for; 12 13 25 12Notice that the socles of the projective modules have very large dimensions so the injective resolutions are probably going to grow at a very rapid rate.
> G := ExtraSpecialGroup(3,1); > F := GF(3); > B := BasicAlgebra(G,F); > B; Basic algebra of dimension 27 over GF(3) Number of projective modules: 1 Number of generators: 4 > s := NonIdempotentGenerators(B)[3];Now check that cs{s} is in the center.
> [s*x eq x*s: x in Generators(B)]; [ true, true, true, true ] > P := ProjectiveModule(B,1); > Q := quo<P|P.1*s^2>; > Q; AModule Q of dimension 18 over GF(3)We need to create the path tree for the projective module of the matrix algebra of the action on cs{Q}. In this case it is an easy exercise because the last 9 element of the basis of the projective module for cs{B} span the submodule that we are factoring out. This can actually be seen from the path tree for the projective module of cs{B}.
> PathTree(B,1); [ <1, 1>, <1, 2>, <2, 2>, <1, 3>, <2, 3>, <3, 3>, <4, 3>, <5, 3>, <6, 3>, <1, 4>, <2, 4>, <3, 4>, <4, 4>, <5, 4>, <6, 4>, <7, 4>, <8, 4>, <9, 4>, <10, 4>, <11, 4>, <12, 4>, <13, 4>, <14, 4>, <15, 4>, <16, 4>, <17, 4>, <18, 4> ]So we get the path tree for the new module by truncation.
> PT := [PathTree(B,1)[j]: j in [1 .. 18]]; > PT; [ <1, 1>, <1, 2>, <2, 2>, <1, 3>, <2, 3>, <3, 3>, <4, 3>, <5, 3>, <6, 3>, <1, 4>, <2, 4>, <3, 4>, <4, 4>, <5, 4>, <6, 4>, <7, 4>, <8, 4>, <9, 4> ]Now form the new basic algebra.
> C := BasicAlgebra([<Action(Q),PT>]); > C; Basic algebra of dimension 18 over GF(3) Number of projective modules: 1 Number of generators: 4 > S := SimpleModule(C,1); > prj := CompactProjectiveResolution(S, 15); > SimpleHomologyDimensions(S); [ 92, 77, 70, 57, 51, 40, 35, 26, 22, 15, 12, 7, 5, 2, 1 ]Now compare this with the projective resolution for the group algebra.
> T := SimpleModule(B,1); > pj2 := CompactProjectiveResolution(T,15); > SimpleHomologyDimensions(T); [ 20, 18, 17, 16, 15, 14, 12, 10, 9, 8, 7, 6, 4, 2, 1 ]