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

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

Synopsis

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

Ways to use makeModule:

For the programmer

The object makeModule is a method function.