Macaulay2 » Documentation
Packages » CompleteIntersectionResolutions :: makeModule
next | previous | forward | backward | up | index | toc

# makeModule -- makes a Module out of a collection of modules and maps

- Usage:
    `M = makeModule(H,E,phi)`
- Inputs:
  - H, a hash table, graded components that are modules, to make into as single module
  - E, a matrix, Matrix of variables whose action will defined
  - phi, a hash table, maps between the graded components that will be the action of the variables in E
- Outputs:
  - M, a module, graded modules whose components are given by H

## Description

The Hashtable H should have consecutive integer keys i_0..i_0, say, with values H#i that are modules over a ring SE whose variables include the elements of E. E: \oplus SE^{d_i} \to SE^1 is a matrix of c variables from SE H is a hashTable of m pairs {i, t_i}, where the t_i are RE-modules, and the i are consecutive integer. phi is a hash-table of homogeneous maps phi#{j,i}: H#i**F_j\to H#(i+1) where F_j = source (E_{j} = matrix {{e_j}}). Thus the maps p#{j,i} = (E_j || -phi#{j,i}): t_i**F_j \to t_i++t_{(i+1)}, are homogeneous. The script returns M = \oplus_i T_ as an SE-module, computed as the quotient of P := \oplus T_i obtained by factoring out the sum of the images of the maps p#{j,i}

The Hashtable phi has keys of the form {j,i} where j runs from 0 to c-1, i and i+1 are keys of H, and phi#{j,i} is the map from (source E_{i})**H#i to H#(i+1) that will be identified with the action of E_{j}.

The script is used in both the singly graded case, for example in exteriorTorModule(ff,M) and in the bigraded case, for example in exteriorTorModule(ff,M,N).

In the following we use makeModule to construct by hand a free module of rank 1 over the exterior algebra on x,y, starting with the construction of a module over a bihomogeneous ring.

    i1 : SE = ZZ/101[a,b,c,x,y,Degrees=>toList(3:{1,0})|toList(2:{1,1}), SkewCommutative=>{x,y}]

    o1 = SE

    o1 : PolynomialRing, 2 skew commutative variable(s)

    i2 : RE = SE/ideal"a2,b2,c2"

    o2 = RE

    o2 : QuotientRing

    i3 : T = hashTable {{0,RE^1},{1,RE^{2:{ -1,-1}}}, {2,RE^{{ -2,-2}}}}

                          1
    o3 = HashTable{0 => RE }
                          2
                   1 => RE
                          1
                   2 => RE

    o3 : HashTable

    i4 : E = matrix{{x,y}}

    o4 = | x y |

                  1       2
    o4 : Matrix RE  <-- RE

    i5 : F=apply(2, j-> source E_{j})

            1    1
    o5 = {RE , RE }

    o5 : List

    i6 : phi = hashTable{ {{0,0}, map(T#1, F_0**T#0, T#1_{0})},{{1,0}, map(T#1, F_1**T#0, T#1_{1})},{{0,1}, map(T#2, F_0**T#1, T#1^{1})}, {{1,1}, -map(T#2, F_1**T#1, T#1^{0})}}

    o6 = HashTable{{0, 0} => {1, 1} | 1 |   }
                             {1, 1} | 0 |
                   {0, 1} => {2, 2} | 0 1 |
                   {1, 0} => {1, 1} | 0 |
                             {1, 1} | 1 |
                   {1, 1} => {2, 2} | -1 0 |

    o6 : HashTable

    i7 : apply(keys phi, k->isHomogeneous phi#k)

    o7 = {true, true, true, true}

    o7 : List

    i8 : X = makeModule(T,E,phi)

    o8 = cokernel {0, 0} | -x 0  0  -y 0  0  |
                  {1, 1} | 1  -x 0  0  -y 0  |
                  {1, 1} | 0  0  -x 1  0  -y |
                  {2, 2} | 0  0  1  0  -1 0  |

                                  4
    o8 : RE-module, quotient of RE

    i9 : isHomogeneous X

    o9 = true

    i10 : q = map(ZZ/101[x,y, SkewCommutative => true, DegreeMap => d->{d_1}], ring X, {3:0,x,y})

                ZZ
    o10 = map (---[x..y], RE, {0, 0, 0, x, y})
               101

                   ZZ
    o10 : RingMap ---[x..y] <-- RE
                  101

    i11 : prune coker q presentation X

            ZZ       1
    o11 = (---[x..y])
           101

           ZZ
    o11 : ---[x..y]-module, free
          101

## See also

- exteriorHomologyModule -- Make the homology of a complex into a module over an exterior algebra
- exteriorTorModule -- Tor as a module over an exterior algebra or bigraded algebra
- exteriorExtModule -- Ext(M,k) or Ext(M,N) as a module over an exterior algebra

## Ways to use makeModule:

- `makeModule(HashTable,Matrix,HashTable)`

## For the programmer

The object makeModule is a method function.

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/CompleteIntersectionResolutions.m2:2759:0.