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

## Synopsis

• Usage:
extendIdealByNonZeroMinor(n,M,I)
• Inputs:
• I, an ideal, in a polynomial ring over QQ or ZZ/p for p prime
• M, , over the polynomial ring
• n, an integer, the size of the minors to consider
• Optional inputs:
• Strategy => , default value Default, specify which strategy to use when calling randomPoints
• Homogeneous => , default value true, controls if the computations are homogeneous (in calls to randomPoints)
• Verbose (missing documentation) => , 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
• Codimension => ..., default value null, an option to specify the codimension so as not to compute it
• ExtendField => ..., default value true, an option used to specify if extending the finite field is permissable here
• IntersectionAttempts => ..., default value 20, an option which controls how many linear intersections are attempted when looking for rational points
• MaxCoordinatesToReplace => ..., default value 1, The maximum number of coordinates to turn into non-monomial functions when calling {\tt randomCoordinateChange}
• MaxCoordinatesToTrivialize => ..., default value infinity, the number of coordinates to set to random values when doing a linear intersection
• NumThreadsToUse => ..., default value 1, number of threads the the function will use in a brute force search for a point
• PointCheckAttempts => ..., default value 100, Number of times the the function will search for a point
• ProjectionAttempts => ..., default value 30, Number of projection trials using in randomPoints when doing generic projection
• Replacement => ..., default value Binomial, When changing coordinates, whether to replace variables by general degre 1 forms or binomials
• 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 2 2 2 2 + 2y*z - 2z , - 2x z + 2x*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.91354 seconds elapsed i11 : dim J o11 = 1 i12 : i o12 = 5

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 "FastLinAlg".

## Ways to use extendIdealByNonZeroMinor :

• "extendIdealByNonZeroMinor(ZZ,Matrix,Ideal)"

## For the programmer

The object extendIdealByNonZeroMinor is .