componentsOfKernel -- Finds all minimal generators up to a given total degree in the kernel of a ring map

Synopsis

Usage:

componentsOfKernel(d, F)
Inputs:
- d, a list, the total degree at which to stop computing generators
- F, a ring map,
Optional inputs:
- Grading => a matrix, default value null, a matrix whose columns give a homogeneous multigrading on $\ker(F)$
- UseMatroidSpeedup => a Boolean value, default value true, if true, then the jacobian of $F$ is used to detect if it is possible for kernel element to exist in a homogeneous component. If the jacobian does not drop rank, then that component cannot contain kernel generators and is skipped.
Outputs:
- a mutable hash table, A mutable hashtable whose keys correspond to all homogeneous components of $\ker(F)$ and values correspond to generators in $\ker(F)$ with those components

Description

Computes all minimal generators of $\ker(F)$ which are of total degree at most d.

i1 : A = matrix {{1,1,1,0,0,0}, {0,0,0,1,1,1}, {1,0,0,1,0,0}, {0,1,0,0,1,0}, {0,0,1,0,0,1}}

o1 = | 1 1 1 0 0 0 |
     | 0 0 0 1 1 1 |
     | 1 0 0 1 0 0 |
     | 0 1 0 0 1 0 |
     | 0 0 1 0 0 1 |

              5       6
o1 : Matrix ZZ  <-- ZZ

i2 : R = QQ[x_(1,1)..x_(2,3)];

i3 : S = QQ[t_1..t_2, s_1..s_3];

i4 : F = map(S, R, {t_1*s_1, t_1*s_2, t_1*s_3, t_2*s_1, t_2*s_2, t_2*s_3})

o4 = map (S, R, {t s , t s , t s , t s , t s , t s })
                  1 1   1 2   1 3   2 1   2 2   2 3

o4 : RingMap S <-- R

i5 : peek componentsOfKernel(2, F)

o5 = MutableHashTable{{0, 1, 0, 0, 1} => {}                   }
                      {0, 1, 0, 1, 0} => {}
                      {0, 1, 1, 0, 0} => {}
                      {0, 2, 0, 0, 2} => {}
                      {0, 2, 0, 1, 1} => {}
                      {0, 2, 0, 2, 0} => {}
                      {0, 2, 1, 0, 1} => {}
                      {0, 2, 1, 1, 0} => {}
                      {0, 2, 2, 0, 0} => {}
                      {1, 0, 0, 0, 1} => {}
                      {1, 0, 0, 1, 0} => {}
                      {1, 0, 1, 0, 0} => {}
                      {1, 1, 0, 0, 2} => {}
                      {1, 1, 0, 1, 1} => {x   x    - x   x   }
                                           1,3 2,2    1,2 2,3
                      {1, 1, 0, 2, 0} => {}
                      {1, 1, 1, 0, 1} => {x   x    - x   x   }
                                           1,3 2,1    1,1 2,3
                      {1, 1, 1, 1, 0} => {x   x    - x   x   }
                                           1,2 2,1    1,1 2,2
                      {1, 1, 2, 0, 0} => {}
                      {2, 0, 0, 0, 2} => {}
                      {2, 0, 0, 1, 1} => {}
                      {2, 0, 0, 2, 0} => {}
                      {2, 0, 1, 0, 1} => {}
                      {2, 0, 1, 1, 0} => {}
                      {2, 0, 2, 0, 0} => {}

If a grading in which $\ker(F)$ is homogeneous is already known or a specific grading is desired then the option Grading can be used to specify this. In this case the columns of the matrix Grading are automatically used to grade the source of $F$.

Ways to use componentsOfKernel:

componentsOfKernel(Number,RingMap)

For the programmer

The object componentsOfKernel is a method function with options.