MatrixFactorizations -- A package for creating and computing objects in the category of ZZ/d-graded factorizations, such as matrix factorizations

Description

A ZZ/d-graded factorization F of a ring element f is a ZZ/d-graded complex of free R-modules equipped with a degree -1 (mod d) endomorphism $\text{d}^F$ such that $(\text{d}^F)^d = f * id_F$. In practice, a ZZdFactorization may be visualized as a sequence of R-module maps:

$$F_0 \leftarrow F_1 \leftarrow \cdots \leftarrow F_{d-1}$$

with the caveat that $d^F_0 : F_0 \to F_{d-1}$, since one should count degree modulo d. Any 2-periodic complex may be reinterpretted as a ZZ/2-graded factorization of 0, and likewise a matrix factorization of a ring element f is equivalently a ZZ/2-graded factorization of f. Because of their similarity with complexes, much of the functionality and syntax for this package closely resembles the Complexes package, with some key differences.

Firstly, the output string of a ZZdFactorization and ZZdFactorizationMap is meant to illustrate the periodic nature of a ZZ/d-graded factorization.

i1 : S = ZZ/101[a..c];

i2 : K = koszulMF({a,b,c}, a^2 + b^2 + c^2)

      4      4      4
o2 = S  <-- S  <-- S
                    
     0      1      0

o2 : ZZdFactorization

i3 : diffs = K.dd

          4                      4
o3 = 1 : S  <------------------ S  : 0
               | c 0  b  a  |
               | 0 c  a  -b |
               | b a  -c 0  |
               | a -b 0  -c |

          4                      4
     0 : S  <------------------ S  : 1
               | c 0  b  a  |
               | 0 c  a  -b |
               | b a  -c 0  |
               | a -b 0  -c |

o3 : ZZdFactorizationMap

i4 : K.dd^2

          4                                               4
o4 = 0 : S  <------------------------------------------- S  : 0
               | a2+b2+c2 0        0        0        |
               | 0        a2+b2+c2 0        0        |
               | 0        0        a2+b2+c2 0        |
               | 0        0        0        a2+b2+c2 |

          4                                               4
     1 : S  <------------------------------------------- S  : 1
               | a2+b2+c2 0        0        0        |
               | 0        a2+b2+c2 0        0        |
               | 0        0        a2+b2+c2 0        |
               | 0        0        0        a2+b2+c2 |

o4 : ZZdFactorizationMap

A ZZ/d-graded factorization does not have a concentration, but instead has a period. The period is a very important invariant, since almost all of the methods implemented depend on the period of the factorization, and will give legitimately different outputs as the period varies.

i5 : period K

o5 = 2

i6 : K' = linearMF(a^3 + b^3 + c^3, t) --we have to adjoin a root of unity t

     /   S[t]   \9     /   S[t]   \9     /   S[t]   \9     /   S[t]   \9
o6 = |----------|  <-- |----------|  <-- |----------|  <-- |----------|
     | 2        |      | 2        |      | 2        |      | 2        |
     \t  + t + 1/      \t  + t + 1/      \t  + t + 1/      \t  + t + 1/
                                                            
     0                 1                 2                 0

o6 : ZZdFactorization

i7 : period K'

o7 = 3

i8 : diffs' = K'.dd

         /   S[t]   \9                                                          /   S[t]   \9
o8 = 2 : |----------|  <------------------------------------------------------- |----------|  : 0
         | 2        |     {0, 3} | c 0  0     b  a  0     0     0     0     |   | 2        |
         \t  + t + 1/     {0, 3} | 0 c  0     0  bt a     0     0     0     |   \t  + t + 1/
                          {0, 3} | 0 0  c     a  0  -bt-b 0     0     0     |
                          {0, 3} | 0 0  0     ct 0  0     b     a     0     |
                          {0, 3} | 0 0  0     0  ct 0     0     bt    a     |
                          {0, 3} | 0 0  0     0  0  ct    a     0     -bt-b |
                          {0, 3} | b a  0     0  0  0     -ct-c 0     0     |
                          {0, 3} | 0 bt a     0  0  0     0     -ct-c 0     |
                          {0, 3} | a 0  -bt-b 0  0  0     0     0     -ct-c |

         /   S[t]   \9                                                          /   S[t]   \9
     0 : |----------|  <------------------------------------------------------- |----------|  : 1
         | 2        |     {0, 3} | c 0  0     b  a  0     0     0     0     |   | 2        |
         \t  + t + 1/     {0, 3} | 0 c  0     0  bt a     0     0     0     |   \t  + t + 1/
                          {0, 3} | 0 0  c     a  0  -bt-b 0     0     0     |
                          {0, 3} | 0 0  0     ct 0  0     b     a     0     |
                          {0, 3} | 0 0  0     0  ct 0     0     bt    a     |
                          {0, 3} | 0 0  0     0  0  ct    a     0     -bt-b |
                          {0, 3} | b a  0     0  0  0     -ct-c 0     0     |
                          {0, 3} | 0 bt a     0  0  0     0     -ct-c 0     |
                          {0, 3} | a 0  -bt-b 0  0  0     0     0     -ct-c |

         /   S[t]   \9                                                          /   S[t]   \9
     1 : |----------|  <------------------------------------------------------- |----------|  : 2
         | 2        |     {0, 3} | c 0  0     b  a  0     0     0     0     |   | 2        |
         \t  + t + 1/     {0, 3} | 0 c  0     0  bt a     0     0     0     |   \t  + t + 1/
                          {0, 3} | 0 0  c     a  0  -bt-b 0     0     0     |
                          {0, 3} | 0 0  0     ct 0  0     b     a     0     |
                          {0, 3} | 0 0  0     0  ct 0     0     bt    a     |
                          {0, 3} | 0 0  0     0  0  ct    a     0     -bt-b |
                          {0, 3} | b a  0     0  0  0     -ct-c 0     0     |
                          {0, 3} | 0 bt a     0  0  0     0     -ct-c 0     |
                          {0, 3} | a 0  -bt-b 0  0  0     0     0     -ct-c |

o8 : ZZdFactorizationMap

i9 : (diffs')^3

         /   S[t]   \9                                                                                                  /   S[t]   \9
o9 = 0 : |----------|  <----------------------------------------------------------------------------------------------- |----------|  : 0
         | 2        |     {0, 3} | a3+b3+c3 0        0        0        0        0        0        0        0        |   | 2        |
         \t  + t + 1/     {0, 3} | 0        a3+b3+c3 0        0        0        0        0        0        0        |   \t  + t + 1/
                          {0, 3} | 0        0        a3+b3+c3 0        0        0        0        0        0        |
                          {0, 3} | 0        0        0        a3+b3+c3 0        0        0        0        0        |
                          {0, 3} | 0        0        0        0        a3+b3+c3 0        0        0        0        |
                          {0, 3} | 0        0        0        0        0        a3+b3+c3 0        0        0        |
                          {0, 3} | 0        0        0        0        0        0        a3+b3+c3 0        0        |
                          {0, 3} | 0        0        0        0        0        0        0        a3+b3+c3 0        |
                          {0, 3} | 0        0        0        0        0        0        0        0        a3+b3+c3 |

         /   S[t]   \9                                                                                                  /   S[t]   \9
     1 : |----------|  <----------------------------------------------------------------------------------------------- |----------|  : 1
         | 2        |     {0, 3} | a3+b3+c3 0        0        0        0        0        0        0        0        |   | 2        |
         \t  + t + 1/     {0, 3} | 0        a3+b3+c3 0        0        0        0        0        0        0        |   \t  + t + 1/
                          {0, 3} | 0        0        a3+b3+c3 0        0        0        0        0        0        |
                          {0, 3} | 0        0        0        a3+b3+c3 0        0        0        0        0        |
                          {0, 3} | 0        0        0        0        a3+b3+c3 0        0        0        0        |
                          {0, 3} | 0        0        0        0        0        a3+b3+c3 0        0        0        |
                          {0, 3} | 0        0        0        0        0        0        a3+b3+c3 0        0        |
                          {0, 3} | 0        0        0        0        0        0        0        a3+b3+c3 0        |
                          {0, 3} | 0        0        0        0        0        0        0        0        a3+b3+c3 |

         /   S[t]   \9                                                                                                  /   S[t]   \9
     2 : |----------|  <----------------------------------------------------------------------------------------------- |----------|  : 2
         | 2        |     {0, 3} | a3+b3+c3 0        0        0        0        0        0        0        0        |   | 2        |
         \t  + t + 1/     {0, 3} | 0        a3+b3+c3 0        0        0        0        0        0        0        |   \t  + t + 1/
                          {0, 3} | 0        0        a3+b3+c3 0        0        0        0        0        0        |
                          {0, 3} | 0        0        0        a3+b3+c3 0        0        0        0        0        |
                          {0, 3} | 0        0        0        0        a3+b3+c3 0        0        0        0        |
                          {0, 3} | 0        0        0        0        0        a3+b3+c3 0        0        0        |
                          {0, 3} | 0        0        0        0        0        0        a3+b3+c3 0        0        |
                          {0, 3} | 0        0        0        0        0        0        0        a3+b3+c3 0        |
                          {0, 3} | 0        0        0        0        0        0        0        0        a3+b3+c3 |

o9 : ZZdFactorizationMap

As seen in the above, many constructions of factorizations with periods $>2$ require the user to adjoin or specify a primitive root of unity. For an in-depth discussion on all the methods implemented for accomplishing this, see adjoinRoot.

Finally, every factorization (assuming it is well-defined) has an associated potential, which is the polynomial $f$ such that all $d$-fold compositions of the differentials are equal to $f$ times the identity. This potential can be accessed as follows:

i10 : potential K

       2    2    2
o10 = a  + b  + c

o10 : S

i11 : isdFactorization K

              2    2    2
o11 = (true, a  + b  + c )

o11 : Sequence

i12 : potential K'

       3    3    3
o12 = a  + b  + c

         S[t]
o12 : ----------
       2
      t  + t + 1

i13 : isdFactorization K'

              3    3    3
o13 = (true, a  + b  + c )

o13 : Sequence

Much of the syntax and functionality of the types ZZdFactorization and ZZdFactorizationMap are based on current functionalities for the analogous objects in the Complexes package, so there should be essentially no learning curve for users already familiar with working with chain complexes.

Authors

Version

This documentation describes version 0.1 of MatrixFactorizations, released August 13, 2025.

Citation

If you have used this package in your research, please cite it as follows:

@misc{MatrixFactorizationsSource,
  title = {{MatrixFactorizations: computing with matrix factorizations of different lengths. Version~0.1}},
  author = {David Favero and Sasha Pevzner and Timothy Tribone and Keller VandeBogert},
  howpublished = {A \emph{Macaulay2} package available at
    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}
}

Exports

Types
- ZZdFactorization -- the class of all ZZ/d-graded factorizations
- ZZdFactorizationMap -- the class of all maps between ZZ/d-graded factorizations
Functions and commands
- adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjointFactorization -- Constructs matrix factorization of a determinant of a matrix
- branchedToMF -- Converts a maximal Cohen-Macaulay module over a d-fold branched cover into a d-fold factorization
- collapseMF -- Converts a d-fold factorization into a (d-1)-fold factorization by composing the kth differential with the (k+1)th differential
- eulerMF -- Construct a Koszul matrix factorization with respect to the Jacobian ideal
- Fold -- Convert any complex or complex map into a ZZ/d-graded factorization (or map) for a fixed integer d
- fullCollapse -- Converts a d-fold factorization into a 2-fold factorization
- higherHomotopyFactorization -- Constructs the matrix factorization associated with a system of higher homotopies
- injectiveCover -- Constructs the injective hull of a d-fold matrix factorization
- isdFactorization -- Checks if the differentials of a factorization compose to a scalar multiple of the identity
- isFactorizationMorphism -- see isFactorizationMorphism(ZZdFactorizationMap) -- whether a ZZdFactorizationMap is a morphism of factorizations
- isZZdComplex -- Checks if the differentials of a factorization compose to 0
- koszulMF -- Construct a Koszul matrix factorization from an ideal and a polynomial
- linearMF -- Constructs a Koszul d-fold factorization of a homogeneous element of degree d
- monomialMF -- Construct a trivial d-fold factorization of a monomial
- mooreMF -- Constructs the matrix factorization of the Moore matrix and its adjoint
- period -- the period of a ZZ/d-graded factorization or map
- potential -- Outputs the polynomial $f$ such that the dth power of the differentials is equal to $ f \cdot \text{id}$
- projectiveCover -- Constructs the projective cover of a d-fold matrix factorization
- randomFactorizationMap -- a random map of ZZ/d-graded factorizations
- randomLinearMF -- Generates a linear d-fold factorization of a random degree d polynomial
- randomTailMF -- Construct a matrix factorization from a high syzygy of a random module over a hypersurface
- rk1MCM2gen -- Construct every possible rank 1, 2-generated maximal Cohen-Macaulay module over the cubic Fermat hypersurface in 4 variables
- suspension -- Constructs the suspension of a d-fold factorization
- tailMF -- Generate a ZZdFactorization from a module over a hypersurface ring
- toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- zeroOutDegrees -- see toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- trivialMF -- Constructs the trivial matrix factorization of an element f
- unfold -- Converts a factorization into a complex
- ZZdfactorization -- make a ZZ/d-graded factorization
Methods
- adjoinRoot(ZZ,Ring,RingElement) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjoinRoot(ZZ,Ring,Symbol) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjoinRoot(ZZdFactorization,RingElement) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjoinRoot(ZZdFactorization,Symbol) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjoinRoot(ZZdFactorizationMap,RingElement) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjoinRoot(ZZdFactorizationMap,Symbol) -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- adjointFactorization(Matrix) -- see adjointFactorization -- Constructs matrix factorization of a determinant of a matrix
- - ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- Number * ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- Number + ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- Number - ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- RingElement * ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- RingElement + ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- RingElement - ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap * Number -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap * RingElement -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap + Number -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap + RingElement -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap + ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap - Number -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap - RingElement -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- ZZdFactorizationMap - ZZdFactorizationMap -- see arithmetic with ZZ/d-graded factorization maps -- perform arithmetic operations on ZZ/d-graded factorization maps
- basis(List,ZZdFactorization) (missing documentation)
- basis(ZZ,ZZdFactorization) (missing documentation)
- branchedToMF(Matrix) -- see branchedToMF -- Converts a maximal Cohen-Macaulay module over a d-fold branched cover into a d-fold factorization
- branchedToMF(Matrix,Ring) -- see branchedToMF -- Converts a maximal Cohen-Macaulay module over a d-fold branched cover into a d-fold factorization
- branchedToMF(Module) -- see branchedToMF -- Converts a maximal Cohen-Macaulay module over a d-fold branched cover into a d-fold factorization
- branchedToMF(Module,Ring) -- see branchedToMF -- Converts a maximal Cohen-Macaulay module over a d-fold branched cover into a d-fold factorization
- coimage(ZZdFactorizationMap) -- make the coimage of a map of ZZ/d-graded factorizations
- cokernel(ZZdFactorizationMap) -- make the cokernel of a map of ZZ/d-graded factorizations
- collapseMF(ZZdFactorization,ZZ) -- see collapseMF -- Converts a d-fold factorization into a (d-1)-fold factorization by composing the kth differential with the (k+1)th differential
- Complex ** ZZdFactorizationMap -- see ComplexMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations, obtained by first folding the relevant complex map
- ComplexMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations, obtained by first folding the relevant complex map
- ZZdFactorizationMap ** Complex -- see ComplexMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations, obtained by first folding the relevant complex map
- ZZdFactorizationMap ** ComplexMap -- see ComplexMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations, obtained by first folding the relevant complex map
- components(ZZdFactorization) -- list the components of a direct sum
- components(ZZdFactorizationMap) -- list the components of a direct sum
- cone(ZZdFactorizationMap) -- make the mapping cone of a morphism of ZZ/d-graded factorizations
- degree(ZZdFactorizationMap) -- get the degree of a map of ZZ/d-graded factorizations
- Symbol ^ ZZdFactorization -- see differential of a ZZ/d-graded factorization -- get the maps between the terms in a ZZ/d-graded factorization
- directSum(ZZdFactorization) -- direct sum of ZZ/d-graded factorizations
- ZZdFactorization ++ ZZdFactorization -- see directSum(ZZdFactorization) -- direct sum of ZZ/d-graded factorizations
- dual(ZZdFactorization) -- make the dual of a ZZ/d-graded factorization
- dual(ZZdFactorization,RingElement) -- see dual(ZZdFactorization) -- make the dual of a ZZ/d-graded factorization
- dual(ZZdFactorization,Symbol) -- see dual(ZZdFactorization) -- make the dual of a ZZ/d-graded factorization
- dual(ZZdFactorizationMap) -- the dual of a map of ZZ/d-graded factorizations
- dual(ZZdFactorizationMap,RingElement) -- the dual of a map of ZZ/d-graded factorizations
- dual(ZZdFactorizationMap,Symbol) -- see dual(ZZdFactorizationMap,RingElement) -- the dual of a map of ZZ/d-graded factorizations
- euler(ZZdFactorization) -- Calculates the Euler characteristic of a ZZdFactorization
- eulerMF(RingElement) -- see eulerMF -- Construct a Koszul matrix factorization with respect to the Jacobian ideal
- expression(ZZdFactorizationMap) (missing documentation)
- extend(ZZdFactorization,ZZdFactorization,Matrix) (missing documentation)
- extend(ZZdFactorization,ZZdFactorization,Matrix,Sequence) (missing documentation)
- Fold(Complex,ZZ) -- see Fold -- Convert any complex or complex map into a ZZ/d-graded factorization (or map) for a fixed integer d
- Fold(ComplexMap,ZZ) -- see Fold -- Convert any complex or complex map into a ZZ/d-graded factorization (or map) for a fixed integer d
- fullCollapse(ZZdFactorization,ZZ,ZZ) -- see fullCollapse -- Converts a d-fold factorization into a 2-fold factorization
- gradedModule(ZZdFactorization) -- a new ZZ/d-graded factorization in which the differential is zero
- HH ZZdFactorization -- homology of a ZZ/d-graded factorization
- HH ZZdFactorizationMap -- induced map on homology or cohomology
- HH^ZZ ZZdFactorizationMap -- see HH ZZdFactorizationMap -- induced map on homology or cohomology
- HH_ZZ ZZdFactorizationMap -- see HH ZZdFactorizationMap -- induced map on homology or cohomology
- HH_ZZ ZZdFactorization -- homology or cohomology module of a ZZ/d-graded factorization
- HH_ZZ(ZZ,ZZdFactorization) -- see HH_ZZ ZZdFactorization -- homology or cohomology module of a ZZ/d-graded factorization
- higherHomotopyFactorization(List,Complex) -- see higherHomotopyFactorization -- Constructs the matrix factorization associated with a system of higher homotopies
- higherHomotopyFactorization(RingElement,Complex) -- see higherHomotopyFactorization -- Constructs the matrix factorization associated with a system of higher homotopies
- Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(Complex,ZZdFactorization,RingElement) -- see Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(Complex,ZZdFactorization,Symbol) -- see Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(ZZdFactorization,Complex) -- see Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(ZZdFactorization,Complex,RingElement) -- see Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(ZZdFactorization,Complex,Symbol) -- see Hom(Complex,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization formed by folding the complex, then taking the ZZ/d-graded Hom factorization
- Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(ComplexMap,ZZdFactorizationMap,RingElement) -- see Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(ComplexMap,ZZdFactorizationMap,Symbol) -- see Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(ZZdFactorizationMap,ComplexMap) -- see Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(ZZdFactorizationMap,ComplexMap,RingElement) -- see Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(ZZdFactorizationMap,ComplexMap,Symbol) -- see Hom(ComplexMap,ZZdFactorizationMap) -- the map of factorizations between Hom factorizations formed by first folding the relevant complex map
- Hom(Module,ZZdFactorization) -- see Hom(ZZdFactorization,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(Ring,ZZdFactorization) -- see Hom(ZZdFactorization,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,Module) -- see Hom(ZZdFactorization,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,Ring) -- see Hom(ZZdFactorization,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,ZZdFactorization) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,Module,RingElement) -- see Hom(ZZdFactorization,ZZdFactorization,Symbol) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,Module,Symbol) -- see Hom(ZZdFactorization,ZZdFactorization,Symbol) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,ZZdFactorization,RingElement) -- see Hom(ZZdFactorization,ZZdFactorization,Symbol) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(ZZdFactorization,ZZdFactorization,Symbol) -- the ZZ/d-graded homomorphism factorization between two ZZ/d-graded factorizations
- Hom(Matrix,ZZdFactorization) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(Matrix,ZZdFactorizationMap) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(Module,ZZdFactorizationMap) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(Ring,ZZdFactorizationMap) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,Matrix) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,ZZdFactorizationMap) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Matrix) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Module) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Ring) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorization) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorizationMap) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,Matrix,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,Matrix,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,ZZdFactorizationMap,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorization,ZZdFactorizationMap,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Matrix,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Matrix,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Module,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Module,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Ring,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,Ring,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorization,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorization,Symbol) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorizationMap,RingElement) -- see Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- Hom(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) -- the map of factorizations between Hom complexes
- homomorphism'(ZZdFactorizationMap) -- get the element of Hom from a map of factorizations
- homomorphism(ZZ,Matrix,ZZdFactorization) -- get the homomorphism from an element of Hom
- homomorphism(ZZdFactorizationMap) -- get the homomorphism from an element of Hom
- image(ZZdFactorizationMap) -- make the image of a map of ZZ/d-graded factorizations
- inducedMap(ZZdFactorization,ZZdFactorization) -- make the map of ZZ/d-graded factorizations induced at each term by the identity map
- inducedMap(ZZdFactorization,ZZdFactorization,ZZdFactorizationMap) (missing documentation)
- injectiveCover(ZZdFactorization) -- see injectiveCover -- Constructs the injective hull of a d-fold matrix factorization
- isCommutative(ZZdFactorizationMap) -- whether a ZZ/d-graded factorization map commutes with the differentials
- isdFactorization(ZZdFactorization) -- see isdFactorization -- Checks if the differentials of a factorization compose to a scalar multiple of the identity
- isFactorizationMorphism(ZZdFactorizationMap) -- whether a ZZdFactorizationMap is a morphism of factorizations
- isFree(ZZdFactorization) -- whether a ZZ/d-graded factorization consists of free modules
- isHomogeneous(ZZdFactorizationMap) -- whether a map of ZZ/d-graded factorizations is homogeneous
- isNullHomotopic(ZZdFactorizationMap) -- whether a map of ZZ/d-graded factorizations is null-homotopic
- isNullHomotopyOf(ZZdFactorizationMap,ZZdFactorizationMap) -- whether the first map of ZZ/d-graded factorizations is a null homotopy for the second
- isQuasiIsomorphism(ZZdFactorizationMap) -- whether a map of ZZ/d-graded factorizations is a quasi-isomorphism
- isShortExactSequence(ZZdFactorizationMap,ZZdFactorizationMap) -- whether a pair of ZZ/d-graded factorization maps forms a short exact sequence
- isWellDefined(ZZdFactorization) -- whether a ZZ/d-graded factorization is well-defined
- isWellDefined(ZZdFactorizationMap) -- whether a map of ZZ/d-graded factorizations is well-defined
- isZZdComplex(ZZdFactorization) -- see isZZdComplex -- Checks if the differentials of a factorization compose to 0
- kernel(ZZdFactorizationMap) -- make the kernel of a map of ZZ/d-graded factorizations
- koszulMF(Ideal,RingElement) -- see koszulMF -- Construct a Koszul matrix factorization from an ideal and a polynomial
- koszulMF(List,RingElement) -- see koszulMF -- Construct a Koszul matrix factorization from an ideal and a polynomial
- koszulMF(RingElement) -- see koszulMF -- Construct a Koszul matrix factorization from an ideal and a polynomial
- linearMF(RingElement) -- see linearMF -- Constructs a Koszul d-fold factorization of a homogeneous element of degree d
- linearMF(RingElement,RingElement) -- see linearMF -- Constructs a Koszul d-fold factorization of a homogeneous element of degree d
- linearMF(RingElement,Symbol) -- see linearMF -- Constructs a Koszul d-fold factorization of a homogeneous element of degree d
- map(ZZdFactorization,ZZdFactorization,Function) (missing documentation)
- map(ZZdFactorization,ZZdFactorization,HashTable) -- make a map of ZZ/d-graded factorizations
- map(ZZdFactorization,ZZdFactorization,List) (missing documentation)
- map(ZZdFactorization,ZZdFactorization,ZZ) -- make the zero map or identity between ZZ/d-graded factorizations
- map(ZZdFactorization,ZZdFactorization,ZZdFactorizationMap) -- make a new map of ZZ/d-graded factorizations from an existing one (for inducing maps)
- minimalPresentation(ZZdFactorization) -- minimal presentation of all terms in a ZZ/d-graded factorization
- minimalPresentation(ZZdFactorizationMap) -- see minimalPresentation(ZZdFactorization) -- minimal presentation of all terms in a ZZ/d-graded factorization
- prune(ZZdFactorization) -- see minimalPresentation(ZZdFactorization) -- minimal presentation of all terms in a ZZ/d-graded factorization
- prune(ZZdFactorizationMap) -- see minimalPresentation(ZZdFactorization) -- minimal presentation of all terms in a ZZ/d-graded factorization
- monomialMF(RingElement) -- see monomialMF -- Construct a trivial d-fold factorization of a monomial
- mooreMF(ZZ) -- see mooreMF -- Constructs the matrix factorization of the Moore matrix and its adjoint
- net(ZZdFactorization) (missing documentation)
- net(ZZdFactorizationMap) (missing documentation)
- nullHomotopy(ZZdFactorizationMap) -- a map which is a candidate for being a null homotopy
- period(ZZdFactorization) -- see period -- the period of a ZZ/d-graded factorization or map
- period(ZZdFactorizationMap) -- see period -- the period of a ZZ/d-graded factorization or map
- potential(ZZdFactorization) -- see potential -- Outputs the polynomial $f$ such that the dth power of the differentials is equal to $ f \cdot \text{id}$
- projectiveCover(ZZdFactorization) -- see projectiveCover -- Constructs the projective cover of a d-fold matrix factorization
- randomFactorizationMap(ZZdFactorization,ZZdFactorization) -- see randomFactorizationMap -- a random map of ZZ/d-graded factorizations
- randomLinearMF(ZZ,Ring) -- see randomLinearMF -- Generates a linear d-fold factorization of a random degree d polynomial
- randomLinearMF(ZZ,Ring,RingElement) -- see randomLinearMF -- Generates a linear d-fold factorization of a random degree d polynomial
- randomLinearMF(ZZ,Ring,Symbol) -- see randomLinearMF -- Generates a linear d-fold factorization of a random degree d polynomial
- randomTailMF(RingElement) -- see randomTailMF -- Construct a matrix factorization from a high syzygy of a random module over a hypersurface
- randomTailMF(RingElement,ZZ,ZZ) -- see randomTailMF -- Construct a matrix factorization from a high syzygy of a random module over a hypersurface
- randomTailMF(RingElement,ZZ,ZZ,ZZ) -- see randomTailMF -- Construct a matrix factorization from a high syzygy of a random module over a hypersurface
- ring(ZZdFactorization) -- access the ring of a ZZ/d-graded factorization or a factorization map
- ring(ZZdFactorizationMap) -- see ring(ZZdFactorization) -- access the ring of a ZZ/d-graded factorization or a factorization map
- Ring ** ZZdFactorization -- see RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- tensor(RingMap,ZZdFactorization) -- see RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- tensor(ZZdFactorization,RingMap) -- see RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- ZZdFactorization ** Ring -- see RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- ZZdFactorization ** RingMap -- see RingMap ** ZZdFactorization -- tensor a ZZ/d-graded factorization along a ring map
- Ring ** ZZdFactorizationMap -- see RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- tensor(RingMap,ZZdFactorizationMap) -- see RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- tensor(ZZdFactorizationMap,RingMap) -- see RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- ZZdFactorizationMap ** Ring -- see RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- ZZdFactorizationMap ** RingMap -- see RingMap ** ZZdFactorizationMap -- tensor a map of ZZ/d-graded factorizations along a ring map
- RingMap ZZdFactorization -- apply a ring map
- RingMap ZZdFactorizationMap -- apply a ring map to a map of ZZ/d-graded factorizations
- rk1MCM2gen(List) -- see rk1MCM2gen -- Construct every possible rank 1, 2-generated maximal Cohen-Macaulay module over the cubic Fermat hypersurface in 4 variables
- rk1MCM2gen(List,ZZ) -- see rk1MCM2gen -- Construct every possible rank 1, 2-generated maximal Cohen-Macaulay module over the cubic Fermat hypersurface in 4 variables
- source(ZZdFactorizationMap) -- get the source of a map of ZZ/d-graded factorizations
- support(ZZdFactorization) (missing documentation)
- suspension(ZZ,ZZdFactorization) -- see suspension -- Constructs the suspension of a d-fold factorization
- suspension(ZZdFactorization) -- see suspension -- Constructs the suspension of a d-fold factorization
- suspension(ZZdFactorizationMap) -- see suspension -- Constructs the suspension of a d-fold factorization
- tailMF(Ideal) -- see tailMF -- Generate a ZZdFactorization from a module over a hypersurface ring
- tailMF(Module) -- see tailMF -- Generate a ZZdFactorization from a module over a hypersurface ring
- target(ZZdFactorizationMap) -- get the target of a map of ZZ/d-graded factorizations
- tensor(ZZdFactorization,ZZdFactorization,RingElement) (missing documentation)
- tensor(ZZdFactorization,ZZdFactorization,Symbol) (missing documentation)
- tensor(ZZdFactorizationMap,ZZdFactorizationMap,RingElement) (missing documentation)
- tensor(ZZdFactorizationMap,ZZdFactorizationMap,Symbol) (missing documentation)
- tensorAssociativity(ZZdFactorization,ZZdFactorization,ZZdFactorization) -- make the canonical isomorphism arising from associativity
- tensorCommutativity(ZZdFactorization,ZZdFactorization) -- make the canonical isomorphism arising from commutativity of the tensor product operation
- toBranchedCover(ZZdFactorization,RingElement) -- see toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- toBranchedCover(ZZdFactorization,Symbol) -- see toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- zeroOutDegrees(Ring) -- see toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- zeroOutDegrees(ZZdFactorization) -- see toBranchedCover -- Converts a d-fold matrix factorization into a maximal Cohen-Macaulay module over a d-fold branched cover of the potential
- trivialMF(Module,RingElement) -- see trivialMF -- Constructs the trivial matrix factorization of an element f
- trivialMF(ZZ,Module,RingElement) -- see trivialMF -- Constructs the trivial matrix factorization of an element f
- trivialMF(ZZ,ZZ,Module,RingElement) -- see trivialMF -- Constructs the trivial matrix factorization of an element f
- trivialMF(ZZ,ZZ,Module,ZZ) -- see trivialMF -- Constructs the trivial matrix factorization of an element f
- truncate(List,ZZdFactorization) (missing documentation)
- truncate(ZZ,ZZdFactorization) (missing documentation)
- unfold(ZZdFactorization,List) -- see unfold -- Converts a factorization into a complex
- unfold(ZZdFactorization,ZZ) -- see unfold -- Converts a factorization into a complex
- unfold(ZZdFactorizationMap,List) -- see unfold -- Converts a factorization into a complex
- unfold(ZZdFactorizationMap,ZZ) -- see unfold -- Converts a factorization into a complex
- ZZdfactorization(List) -- see ZZdfactorization -- make a ZZ/d-graded factorization
- Matrix ** ZZdFactorization -- see ZZdFactorization ** Matrix -- create the tensor product of a ZZ/d-graded factorization and a map of modules
- ZZdFactorization ** Matrix -- create the tensor product of a ZZ/d-graded factorization and a map of modules
- Complex ** ZZdFactorization -- see ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- Module ** ZZdFactorization -- see ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- tensor(ZZdFactorization,ZZdFactorization) -- see ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- ZZdFactorization ** Complex -- see ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- ZZdFactorization ** Module -- see ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- ZZdFactorization ** ZZdFactorization -- tensor product of ZZ/d-graded factorizations
- ZZ == ZZdFactorization -- see ZZdFactorization == ZZdFactorization -- whether two ZZ/d-graded factorizations are equal
- ZZdFactorization == ZZ -- see ZZdFactorization == ZZdFactorization -- whether two ZZ/d-graded factorizations are equal
- ZZdFactorization == ZZdFactorization -- whether two ZZ/d-graded factorizations are equal
- ZZdFactorization ^ Array -- see ZZdFactorization _ Array -- the canonical inclusion or projection map of a direct sum
- ZZdFactorization _ Array -- the canonical inclusion or projection map of a direct sum
- ZZdFactorization ^ ZZ -- see ZZdFactorization _ ZZ -- access individual object in a ZZ/d-graded factorization
- ZZdFactorization _ ZZ -- access individual object in a ZZ/d-graded factorization
- ZZdFactorization Array -- shift a ZZ/d-graded factorization or map of ZZ/d-graded factorizations
- ZZdFactorizationMap Array -- see ZZdFactorization Array -- shift a ZZ/d-graded factorization or map of ZZ/d-graded factorizations
- ZZdfactorization(HashTable) -- make a ZZ/d-graded factorization
- ZZdfactorization(Ideal,ZZ) -- see ZZdfactorization(Module,ZZ) -- convert a module/ring/ideal into a ZZ/d-graded factorization for specified period d
- ZZdfactorization(Module,ZZ) -- convert a module/ring/ideal into a ZZ/d-graded factorization for specified period d
- ZZdfactorization(Ring,ZZ) -- see ZZdfactorization(Module,ZZ) -- convert a module/ring/ideal into a ZZ/d-graded factorization for specified period d
- ZZdfactorization(ZZdFactorization) -- make a ZZ/d-graded factorization with shifted base; used for permuting the modules without adding signs
- ZZdFactorizationMap * ZZdFactorizationMap -- composition of homomorphisms of ZZ/d-graded factorizations
- Module ** ZZdFactorizationMap -- see ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- tensor(ZZdFactorizationMap,ZZdFactorizationMap) -- see ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- ZZdFactorization ** ZZdFactorizationMap -- see ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- ZZdFactorizationMap ** Module -- see ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- ZZdFactorizationMap ** ZZdFactorization -- see ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- ZZdFactorizationMap ** ZZdFactorizationMap -- the map of ZZ/d-graded factorizations between tensor factorizations
- directSum(ZZdFactorizationMap) -- see ZZdFactorizationMap ++ ZZdFactorizationMap -- direct sum of ZZ/d-graded factorization maps
- ZZdFactorizationMap ++ ZZdFactorizationMap -- direct sum of ZZ/d-graded factorization maps
- RingElement == ZZdFactorizationMap -- see ZZdFactorizationMap == ZZdFactorizationMap -- whether two ZZ/d-graded factorization maps are equal
- ZZ == ZZdFactorizationMap -- see ZZdFactorizationMap == ZZdFactorizationMap -- whether two ZZ/d-graded factorization maps are equal
- ZZdFactorizationMap == RingElement -- see ZZdFactorizationMap == ZZdFactorizationMap -- whether two ZZ/d-graded factorization maps are equal
- ZZdFactorizationMap == ZZ -- see ZZdFactorizationMap == ZZdFactorizationMap -- whether two ZZ/d-graded factorization maps are equal
- ZZdFactorizationMap == ZZdFactorizationMap -- whether two ZZ/d-graded factorization maps are equal
- ZZdFactorizationMap ^ Array -- the composition with the canonical inclusion or projection map
- ZZdFactorizationMap _ Array -- see ZZdFactorizationMap ^ Array -- the composition with the canonical inclusion or projection map
- ZZdFactorizationMap ^ ZZ -- the n-fold composition
- ZZdFactorizationMap _ ZZ -- access individual matrices in a ZZ/d-graded factorization map
- ZZdFactorizationMap | ZZdFactorizationMap -- join or concatenate maps horizontally
- ZZdFactorizationMap || ZZdFactorizationMap -- join or concatenate maps vertically
Symbols
- RootOfUnity -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- rootOfUnity -- see adjoinRoot -- Adjoin a root of unity to the underlying object input
- WellDefined (missing documentation)

For the programmer

The object MatrixFactorizations is a package, defined in MatrixFactorizations.m2, with auxiliary files in MatrixFactorizations/.

The source of this document is in MatrixFactorizations/MatrixFactorizationsDOC.m2:57:0.