Macaulay2 » Documentation
Packages » RandomPoints :: extendIdealByNonZeroMinor
next | previous | forward | backward | up | index | toc

# extendIdealByNonZeroMinor -- extends the ideal to aid finding singular locus

- Usage:
    `extendIdealByNonZeroMinor(n,M,I)`
- Inputs:
  - I, an ideal, in a polynomial ring over QQ or ZZ/p for p prime
  - M, a matrix, over the polynomial ring
  - n, an integer, the size of the minors to consider
- Optional inputs:
  - Strategy => a symbol, default value Default, specify which strategy to use when calling randomPoints
  - Homogeneous => a Boolean value, default value false, controls if the computations are homogeneous (in calls to randomPoints)
  - Verbose => a Boolean value, default value false, turns on or off verbose output
  - MinorPointAttempts => an integer, default value 5, how many points to check the rank of the matrix at
  - DimensionFunction => a function, default value dim, specify a custom dimension function, such as the default dimViaBezout or the Macaulay2 function dim
  - DecompositionStrategy => ..., default value null, control how ideals of points are factored into minimal primes
  - ExtendField => ..., default value true, an option used to specify if extending the finite field is permissible here
  - NumThreadsToUse => ..., default value 1, number of threads that the function will use in a brute force search for a point
  - PointCheckAttempts => ..., default value 0, Number of times that the function will search for a point
  - Replacement => ..., default value Binomial, When changing coordinates, whether to replace variables by general degree 1 forms, binomials, etc.
- Outputs:
  - an ideal, the original ideal extended by the determinant of the non vanishing minor found

## Description

This function finds a submatrix of size $n\times n$ using findANonZeroMinor; it extracts the last entry of the output, finds its determinant and adds it to the ideal $I$, thus extending $I$.

    i1 : R = ZZ/5[x,y,z];

    i2 : I = ideal(random(3,R)-2, random(2,R));

    o2 : Ideal of R

    i3 : M = jacobian(I);

                 3      2
    o3 : Matrix R  <-- R

    i4 : extendIdealByNonZeroMinor(2,M,I, Strategy => LinearIntersection)

                    3       2     3    2     2        2       2     3
    o4 = ideal (- 2x  - 2x*y  - 2y  + x z - y z + 2x*z  - 2y*z  - 2z  - 2, - 2x*z
         ------------------------------------------------------------------------
                    2    3     2       2    3     2             2       2      2
         + 2y*z - 2z , 2x  - 2x y - x*y  + y  + 2x z - x*y*z + y z + x*z  + y*z )

    o4 : Ideal of R

One use for this function can be in showing a certain rings are R1 (regular in codimension 1). Consider the following example which is R1 where computing the dimension of the singular locus takes around 30 seconds as there are 15500 minors of size $4 \times 4$ in the associated $7 \times 12$ Jacobian matrix. However, we can use this function to quickly find interesting minors.

    i5 : T = ZZ/101[x1,x2,x3,x4,x5,x6,x7];

    i6 : I =  ideal(x5*x6-x4*x7,x1*x6-x2*x7,x5^2-x1*x7,x4*x5-x2*x7,x4^2-x2*x6,x1*x4-x2*x5,x2*x3^3*x5+3*x2*x3^2*x7+8*x2^2*x5+3*x3*x4*x7-8*x4*x7+x6*x7,x1*x3^3*x5+3*x1*x3^2*x7+8*x1*x2*x5+3*x3*x5*x7-8*x5*x7+x7^2,x2*x3^3*x4+3*x2*x3^2*x6+8*x2^2*x4+3*x3*x4*x6-8*x4*x6+x6^2,x2^2*x3^3+3*x2*x3^2*x4+8*x2^3+3*x2*x3*x6-8*x2*x6+x4*x6,x1*x2*x3^3+3*x2*x3^2*x5+8*x1*x2^2+3*x2*x3*x7-8*x2*x7+x4*x7,x1^2*x3^3+3*x1*x3^2*x5+8*x1^2*x2+3*x1*x3*x7-8*x1*x7+x5*x7);

    o6 : Ideal of T

    i7 : M = jacobian I;

                 7      12
    o7 : Matrix T  <-- T

    i8 : i = 0;

    i9 : J = I;

    o9 : Ideal of T

    i10 : elapsedTime(while (i < 10) and dim J > 1 do (i = i+1; J = extendIdealByNonZeroMinor(4, M, J)) );
     -- 1.93959s elapsed

    i11 : dim J

    o11 = 1

    i12 : i

    o12 = 4

In this particular example, there tend to be about 5 associated primes when adding the first minor to J, and so one would expect about 5 steps as each minor computed most likely will eliminate one of those primes.

There is some similar functionality obtained via heuristics (as opposed to actually finding rational points) in the package "FastMinors".

## See also

- findANonZeroMinor -- finds a non-vanishing minor at some randomly chosen point

## Ways to use extendIdealByNonZeroMinor:

- `extendIdealByNonZeroMinor(ZZ,Matrix,Ideal)`

## For the programmer

The object extendIdealByNonZeroMinor is a method function with options.

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