DirectSummands -- decompositions of graded modules and coherent sheaves

This package implements algorithms for computing indecomposable summands of finitely generated $R$-module $M$ over a $k$-algebra when $M$ is either a homogeneous module over a (multi)graded ring with $k$ a field of arbitrary characteristic, or when $R$ is local and $k$ a field of positive characteristic contained in $\overline{\mathbb F_p}$.

Further, in the graded case, this package enables the computation of indecomposable summands of coherent sheaves on subvarieties of the projective space $\PP^n$ as well as other complete toric varieties, while in the local case it enables the study of germs of inhomogeneous singularities in positive characteristic.

Primary methods:

• directSummands -- compute the direct summands of a module or coherent sheaf
• isIndecomposable -- tests whether a module or coherent sheaf is indecomposable

Supporting methods:

• changeBaseField -- extend scalars for modules, matrices, and coherent sheaves
• generalEndomorphism -- construct a generic degree-zero endomorphism
• findProjectors -- construct projectors on a homogeneous module
• findIdempotents -- construct idempotent endomorphisms
• findSplitInclusion -- construct a split inclusion of one module into another
• isomorphismTally -- group isomorphic modules or sheaves in a list
• tallySummands -- tally a list of modules up to isomorphism
• potentialExtension -- suggest a field extension where splitting may become visible

Featured applications:

• Example: summands of the Frobenius pushforward
• Example: syzygies over Artinian rings
• Example: symbolic diagonalization

The decomposition algorithms are randomized, so repeated runs may sample different endomorphisms. Over a large enough field, this implementation is often capable of completely decomposing a module in a single non-recursive iteration. When a decomposition appears only after extending scalars, the package can suggest or carry out a field extension via potentialExtension and changeBaseField.

The package also (temporarily) includes utilities for working with the Frobenius map in positive characteristic: frobeniusMap, frobeniusRing, frobeniusPullback, frobeniusPushforward, and frobeniusTwist. These make it possible to study decompositions of Frobenius pushforwards of modules and sheaves, which is one of the motivating applications.

As a sample computation, consider the splitting of the Frobenius pushforward of the structure sheaf of an elliptic curve over $\mathbb F_7$ and after base change to $\mathbb F_{49}$.

i1 : R = ZZ/7[x,y,z]/(x^3+y^3+z^3);

i2 : X = Proj R;

i3 : F = frobeniusPushforward(1, OO_X);

i4 : elapsedTime tallySummands summands F
 -- try using changeBaseField with GF 49
 -- try using changeBaseField with GF 49
 -- try using changeBaseField with GF 49
 -- 2.8066s elapsed

o4 = Tally{cokernel {1} | x   -2z -3y -y  0   0   | => 1}
                    {1} | 3z  -y  0   x   2z  -2y |
                    {1} | -3y x   z   -3z 0   0   |
                    {1} | 0   0   -3y y   x   -3z |
                    {1} | -2z 2y  x   0   -z  3y  |
                    {1} | 0   0   -z  -3z -2y x   |
           cokernel {1} | x   -z 2y  3y  0  0   | => 1
                    {1} | -2z 3y 0   x   z  -y  |
                    {1} | 2y  x  -3z 2z  0  0   |
                    {1} | 0   0  2y  -3y x  2z  |
                    {1} | -z  y  x   0   3z -2y |
                    {1} | 0   0  3z  2z  -y x   |
           cokernel {1} | x  3z  y   -2y 0   0  | => 1
                    {1} | -z -2y 0   x   -3z 3y |
                    {1} | y  x   2z  z   0   0  |
                    {1} | 0  0   y   2y  x   z  |
                    {1} | 3z -3y x   0   -2z -y |
                    {1} | 0  0   -2z z   3y  x  |
            1
           R  => 1

o4 : Tally

i5 : elapsedTime tallySummands summands changeBaseField(GF(7, 2), F)
 -- 10.5832s elapsed

o5 = Tally{cokernel {1} | (-2a+1)y x  z       | => 1      }
                    {1} | x        az (-a-3)y |
                    {1} | (2a-2)z  3y x       |
           cokernel {1} | (-3a-2)y x        2z      | => 1
                    {1} | x        (-2a+2)z (2a-1)y |
                    {1} | 3az      -y       x       |
           cokernel {1} | (-a-3)y x    -3z     | => 1
                    {1} | x       -3az (3a+2)y |
                    {1} | (a-1)z  -2y  x       |
           cokernel {1} | (2a-1)y x       z      | => 1
                    {1} | x       (-a+1)z (a+3)y |
                    {1} | -2az    3y      x      |
           cokernel {1} | (3a+2)y  x   2z       | => 1
                    {1} | x        2az (-2a+1)y |
                    {1} | (-3a+3)z -y  x        |
           cokernel {1} | (a+3)y x       -3z      | => 1
                    {1} | x      (3a-3)z (-3a-2)y |
                    {1} | -az    -2y     x        |
           / GF 49[x..z]\1
           |------------|  => 1
           | 3    3    3|
           \x  + y  + z /

o5 : Tally

The authors thank the organizers of the Macaulay2 workshop at AIM, where significant progress on this package was made.

Computing direct sum decompositions, Mallory and Sayrafi, Journal of Symbolic Computation, Volume 133, March–April 2026 [arXiv:2412.19799].