Macaulay2 » Documentation
Packages » MultigradedImplicitization :: componentsOfKernel
next | previous | forward | backward | up | index | toc

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

- 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)$
  - UseMatroid => a Boolean value, default value true, use the jacobian of $F$ to detect if a homogeneous component may contain polynomials in the kernel.
  - UseInterpolation => a Boolean value, default value false, use interpolation instead of symbolically computing polynomials in each homogeneous component.
  - CoefficientRing => a ring, default value ZZ/32003, the ground field which is used to sample points from $V(\ker(F))$
  - Verbose => a Boolean value, default value true, display detailed output
- 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)
    warning: computation begun over finite field. resulting polynomials may not lie in the ideal
    computing total degree: 1
    number of monomials = 6
    number of distinct multidegrees = 6
     -- .00217632s elapsed
    computing total degree: 2
    number of monomials = 21
    number of distinct multidegrees = 18
     -- .0100349s elapsed

    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$.

## Caveat

If the option UseInterpolation is set to true then interpolateComponent is used to compute polynomials in each homogeneous component instead of computeComponent which is the default. In this case, the resulting polynomials are no longer guaranteed to be in $\ker(F)$ but instead belong to the ideal with high probability. Setting this option to true will often significantly speed up computation, especially when computing high degree polynomials in the kernel of dense polynomial maps.

## Ways to use componentsOfKernel:

- `componentsOfKernel(Number,RingMap)`

## For the programmer

The object componentsOfKernel is a method function with options.

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