next | previous | forward | backward | up | index | toc

# integralClosure(...,Strategy=>...) -- control the algorithm used

## Synopsis

• Usage:
integralClosure(R, Strategy=>L)
• Inputs:
• L, a list, of a subset of the following: RadicalCodim1, Radical, AllCodimensions, Vasconcelos, SimplifyFractions, StartWithOneMinor

## Description

Overall, the default options are the best. However, sometimes one of these is dramatically better (or worse!). For the examples here, one doesn't notice much difference.

RadicalCodim1 chooses an alternate, often much faster, sometimes much slower, algorithm for computing the radical of ideals. This will often produce a different presentation for the integral closure. Radical chooses yet another such algorithm.

AllCodimensions tells the algorithm to bypass the computation of the S2-ification, but in each iteration of the algorithm, use the radical of the extended Jacobian ideal from the previous step, instead of using only the codimension 1 components of that. This is useful when for some reason the S2-ification is hard to compute, or if the probabilistic algorithm for computing it fails. In general though, this option slows down the computation for many examples.

StartWithOneMinor tells the algorithm to not compute the entire Jacobian ideal, just find one element in it. This is often a bad choice, unless the ideal is large enough that one can't compute the Jacobian ideal. In the future, we plan on using the FastMinors package to compute part of the Jacobian ideal.

SimplifyFractions changes the fractions to hopefully be simpler. Sometimes it succeeds, yet sometimes it makes the fractions worse. This is because of the manner in which fraction fields work. We are hoping that in the future, less drastic change of fractions will happen by default.

Vasconocelos tells the routine to instead of computing Hom(J,J), to instead compute Hom(J^-1, J^-1). This is usually a more time consuming computation, but it does potentially get to the answer in a smaller number of steps.

 i1 : S = QQ[x,y,z] o1 = S o1 : PolynomialRing i2 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o2 = ideal(x - y z - z - z ) o2 : Ideal of S i3 : R = S/f o3 = R o3 : QuotientRing i4 : time R' = integralClosure R -- used 1.45183s (cpu); 0.974625s (thread); 0s (gc) o4 = R' o4 : QuotientRing i5 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o5 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,1 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,1 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,1 1,1 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+ i6 : icFractions R 3 2 2 4 x y z + z + z o6 = {--, -------------, x, y, z} z x o6 : List
 i7 : S = QQ[x,y,z] o7 = S o7 : PolynomialRing i8 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o8 = ideal(x - y z - z - z ) o8 : Ideal of S i9 : R = S/f o9 = R o9 : QuotientRing i10 : time R' = integralClosure(R, Strategy => Radical) -- used 1.38489s (cpu); 0.921479s (thread); 0s (gc) o10 = R' o10 : QuotientRing i11 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o11 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,1 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,1 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,1 1,1 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+ i12 : icFractions R 3 2 2 4 x y z + z + z o12 = {--, -------------, x, y, z} z x o12 : List
 i13 : S = QQ[x,y,z] o13 = S o13 : PolynomialRing i14 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o14 = ideal(x - y z - z - z ) o14 : Ideal of S i15 : R = S/f o15 = R o15 : QuotientRing i16 : time R' = integralClosure(R, Strategy => AllCodimensions) -- used 1.40304s (cpu); 0.931721s (thread); 0s (gc) o16 = R' o16 : QuotientRing i17 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o17 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,1 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,1 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,1 1,1 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+
 i18 : S = QQ[x,y,z] o18 = S o18 : PolynomialRing i19 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o19 = ideal(x - y z - z - z ) o19 : Ideal of S i20 : R = S/f o20 = R o20 : QuotientRing i21 : time R' = integralClosure(R, Strategy => SimplifyFractions) -- used 1.55326s (cpu); 1.00204s (thread); 0s (gc) o21 = R' o21 : QuotientRing i22 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o22 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,0 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,0 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,0 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,0 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,0 1,0 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+
 i23 : S = QQ[x,y,z] o23 = S o23 : PolynomialRing i24 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o24 = ideal(x - y z - z - z ) o24 : Ideal of S i25 : R = S/f o25 = R o25 : QuotientRing i26 : time R' = integralClosure (R, Strategy => RadicalCodim1) -- used 2.33579s (cpu); 1.41735s (thread); 0s (gc) o26 = R' o26 : QuotientRing i27 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o27 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,1 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,1 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,1 1,1 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+
 i28 : S = QQ[x,y,z] o28 = S o28 : PolynomialRing i29 : f = ideal (x^8-z^6-y^2*z^4-z^3) 8 2 4 6 3 o29 = ideal(x - y z - z - z ) o29 : Ideal of S i30 : R = S/f o30 = R o30 : QuotientRing i31 : time R' = integralClosure (R, Strategy => Vasconcelos) -- used 1.56475s (cpu); 0.994086s (thread); 0s (gc) o31 = R' o31 : QuotientRing i32 : netList (ideal R')_* +------------------------------------------------------------------------+ | 3 | o32 = |w z - x | | 4,0 | +------------------------------------------------------------------------+ | 2 2 4 | |w x - y z - z - z | | 1,1 | +------------------------------------------------------------------------+ | 4 | |w x - w z | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 2 2 3 2 | |w w - x y z - x z - x | | 4,0 1,1 | +------------------------------------------------------------------------+ | 2 3 2 2 6 2 | |w z + w x y z - w + x z | | 4,0 4,0 1,1 | +------------------------------------------------------------------------+ | 2 4 2 2 | |w x + w x y - w y z - w | | 4,0 4,0 1,1 1,1 | +------------------------------------------------------------------------+ | 3 2 3 2 6 4 2 2 4 6 2 3 | |w + w x y + w x z - x*y z - 2x*y z - x*z - 2x*y z - 2x*z - x| | 4,0 4,0 4,0 | +------------------------------------------------------------------------+
 i33 : S = QQ[a,b,c,d] o33 = S o33 : PolynomialRing i34 : f = monomialCurveIdeal(S,{1,3,4}) 3 2 2 2 3 2 o34 = ideal (b*c - a*d, c - b*d , a*c - b d, b - a c) o34 : Ideal of S i35 : R = S/f o35 = R o35 : QuotientRing i36 : time R' = integralClosure R -- used 0.213799s (cpu); 0.132051s (thread); 0s (gc) o36 = R' o36 : QuotientRing i37 : netList (ideal R')_* +-----------+ o37 = |b*c - a*d | +-----------+ | 2 | |w d - c | | 0,0 | +-----------+ |w c - b*d| | 0,0 | +-----------+ |w b - a*c| | 0,0 | +-----------+ | 2 | |w a - b | | 0,0 | +-----------+ | 2 | |w - a*d | | 0,0 | +-----------+

Rational Quartic

 i38 : S = QQ[a,b,c,d] o38 = S o38 : PolynomialRing i39 : I = monomialCurveIdeal(S,{1,3,4}) 3 2 2 2 3 2 o39 = ideal (b*c - a*d, c - b*d , a*c - b d, b - a c) o39 : Ideal of S i40 : R = S/I o40 = R o40 : QuotientRing i41 : time R' = integralClosure(R, Strategy => Radical) -- used 0.359809s (cpu); 0.151255s (thread); 0s (gc) o41 = R' o41 : QuotientRing i42 : icFractions R 2 c o42 = {--, a, b, c, d} d o42 : List
 i43 : S = QQ[a,b,c,d] o43 = S o43 : PolynomialRing i44 : I = monomialCurveIdeal(S,{1,3,4}) 3 2 2 2 3 2 o44 = ideal (b*c - a*d, c - b*d , a*c - b d, b - a c) o44 : Ideal of S i45 : R = S/I o45 = R o45 : QuotientRing i46 : time R' = integralClosure(R, Strategy => AllCodimensions) -- used 0.26671s (cpu); 0.158801s (thread); 0s (gc) o46 = R' o46 : QuotientRing i47 : icFractions R b*d o47 = {---, a, b, c, d} c o47 : List
 i48 : S = QQ[a,b,c,d] o48 = S o48 : PolynomialRing i49 : I = monomialCurveIdeal(S,{1,3,4}) 3 2 2 2 3 2 o49 = ideal (b*c - a*d, c - b*d , a*c - b d, b - a c) o49 : Ideal of S i50 : R = S/I o50 = R o50 : QuotientRing i51 : time R' = integralClosure (R, Strategy => RadicalCodim1) -- used 0.342652s (cpu); 0.146429s (thread); 0s (gc) o51 = R' o51 : QuotientRing i52 : icFractions R 2 c o52 = {--, a, b, c, d} d o52 : List
 i53 : S = QQ[a,b,c,d] o53 = S o53 : PolynomialRing i54 : I = monomialCurveIdeal(S,{1,3,4}) 3 2 2 2 3 2 o54 = ideal (b*c - a*d, c - b*d , a*c - b d, b - a c) o54 : Ideal of S i55 : R = S/I o55 = R o55 : QuotientRing i56 : time R' = integralClosure (R, Strategy => Vasconcelos) -- used 0.226992s (cpu); 0.120762s (thread); 0s (gc) o56 = R' o56 : QuotientRing i57 : icFractions R 2 c o57 = {--, a, b, c, d} d o57 : List

Projected Veronese

 i58 : S' = QQ[symbol a .. symbol f] o58 = S' o58 : PolynomialRing i59 : M' = genericSymmetricMatrix(S',a,3) o59 = | a b c | | b d e | | c e f | 3 3 o59 : Matrix S' <-- S' i60 : I' = minors(2,M') 2 2 o60 = ideal (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - ----------------------------------------------------------------------- 2 c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) o60 : Ideal of S' i61 : center = ideal(b,c,e,a-d,d-f) o61 = ideal (b, c, e, a - d, d - f) o61 : Ideal of S' i62 : S = QQ[a,b,c,d,e] o62 = S o62 : PolynomialRing i63 : p = map(S'/I',S,gens center) S' o63 = map (------------------------------------------------------------------------------------------------------------------, S, {b, c, e, a - d, d - f}) 2 2 2 (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) S' o63 : RingMap ------------------------------------------------------------------------------------------------------------------ <-- S 2 2 2 (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) i64 : I = kernel p 2 2 2 2 2 2 2 3 2 o64 = ideal (a d - b d - b e + c e - d e - d*e , b c - c - a*b*d + c*d + ----------------------------------------------------------------------- 2 3 2 3 2 c*d*e, a c - c - a*b*d + c*d - a*b*e + c*d*e, b - b*c - a*c*d + ----------------------------------------------------------------------- 2 2 2 2 3 2 b*d*e, a*b - a*c - b*c*d, a b - b*c - a*c*d - a*c*e, a - a*c - ----------------------------------------------------------------------- 2 b*c*d - b*c*e - a*d*e - a*e ) o64 : Ideal of S i65 : betti res I 0 1 2 3 4 o65 = total: 1 7 10 5 1 0: 1 . . . . 1: . . . . . 2: . 7 10 5 1 o65 : BettiTally i66 : R = S/I o66 = R o66 : QuotientRing i67 : time R' = integralClosure(R, Strategy => Radical) -- used 0.402015s (cpu); 0.201865s (thread); 0s (gc) o67 = R' o67 : QuotientRing i68 : icFractions R 2 2 b - c o68 = {-------, a, b, c, d, e} d o68 : List
 i69 : S' = QQ[a..f] o69 = S' o69 : PolynomialRing i70 : M' = genericSymmetricMatrix(S',a,3) o70 = | a b c | | b d e | | c e f | 3 3 o70 : Matrix S' <-- S' i71 : I' = minors(2,M') 2 2 o71 = ideal (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - ----------------------------------------------------------------------- 2 c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) o71 : Ideal of S' i72 : center = ideal(b,e,a-d,d-f) o72 = ideal (b, e, a - d, d - f) o72 : Ideal of S' i73 : S = QQ[a,b,d,e] o73 = S o73 : PolynomialRing i74 : p = map(S'/I',S,gens center) S' o74 = map (------------------------------------------------------------------------------------------------------------------, S, {b, e, a - d, d - f}) 2 2 2 (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) S' o74 : RingMap ------------------------------------------------------------------------------------------------------------------ <-- S 2 2 2 (- b + a*d, - b*c + a*e, - c*d + b*e, - b*c + a*e, - c + a*f, - c*e + b*f, - c*d + b*e, - c*e + b*f, - e + d*f) i75 : I = kernel p 4 2 2 4 2 2 2 2 2 2 o75 = ideal(a - 2a b + b - b d - a d*e - b d*e - a e ) o75 : Ideal of S i76 : betti res I 0 1 o76 = total: 1 1 0: 1 . 1: . . 2: . . 3: . 1 o76 : BettiTally i77 : R = S/I o77 = R o77 : QuotientRing i78 : time R' = integralClosure(R, Strategy => Radical) -- used 0.809052s (cpu); 0.595682s (thread); 0s (gc) o78 = R' o78 : QuotientRing i79 : icFractions R 2 2 2 3 2 a - b a b - b + b*d + b*d*e o79 = {-------, -----------------------, a, b, d, e} d + e a*d + a*e o79 : List
 i80 : S = QQ[a,b,d,e] o80 = S o80 : PolynomialRing i81 : R = S/sub(I,S) o81 = R o81 : QuotientRing i82 : time R' = integralClosure(R, Strategy => AllCodimensions) -- used 0.698441s (cpu); 0.56842s (thread); 0s (gc) o82 = R' o82 : QuotientRing i83 : icFractions R 2 2 2 3 2 a - b a b - b + b*d + b*d*e o83 = {-------, -----------------------, a, b, d, e} d + e a*d + a*e o83 : List
 i84 : S = QQ[a,b,d,e] o84 = S o84 : PolynomialRing i85 : R = S/sub(I,S) o85 = R o85 : QuotientRing i86 : time R' = integralClosure (R, Strategy => RadicalCodim1, Verbosity => 1) [jacobian time .00395809 sec #minors 4] integral closure nvars 4 numgens 1 is S2 codim 1 codimJ 2 [step 0: time .366038 sec #fractions 6] [step 1: -- used 0.758191s (cpu); 0.511725s (thread); 0s (gc) time .382851 sec #fractions 6] o86 = R' o86 : QuotientRing i87 : icFractions R 2 2 2 3 2 a - b a b - b + b*d + b*d*e o87 = {-------, -----------------------, a, b, d, e} d + e a*d + a*e o87 : List
 i88 : S = QQ[a,b,d,e] o88 = S o88 : PolynomialRing i89 : R = S/sub(I,S) o89 = R o89 : QuotientRing i90 : time R' = integralClosure (R, Strategy => Vasconcelos, Verbosity => 1) [jacobian time 0 sec #minors 4] integral closure nvars 4 numgens 1 is S2 codim 1 codimJ 2 [step 0: time .168642 sec #fractions 6] [step 1: -- used 0.569177s (cpu); 0.459534s (thread); 0s (gc) time .396533 sec #fractions 6] o90 = R' o90 : QuotientRing i91 : icFractions R 2 2 2 3 2 a - b a b - b + b*d + b*d*e o91 = {-------, -----------------------, a, b, d, e} d + e a*d + a*e o91 : List

One can give several of these options together. Although note that only one of AllCodimensions, RadicalCodim1, Radical will be used.

 i92 : S = QQ[a,b,d,e] o92 = S o92 : PolynomialRing i93 : R = S/sub(I,S) o93 = R o93 : QuotientRing i94 : time R' = integralClosure (R, Strategy => {Vasconcelos, StartWithOneMinor}, Verbosity => 1) [jacobian time .00368502 sec #minors 1] integral closure nvars 4 numgens 1 is S2 codim 1 codimJ 2 [step 0: time .403466 sec #fractions 6] [step 1: -- used 1.3598s (cpu); 1.03912s (thread); 0s (gc) time .942387 sec #fractions 6] o94 = R' o94 : QuotientRing i95 : icFractions R 2 2 2 2 3 2 2a - 2b - d*e - e a b - b + b*d + b*d*e o95 = {--------------------, -----------------------, a, b, d, e} d + e a*d + a*e o95 : List i96 : ideal R' 2 2 2 o96 = ideal (w d + w e - 2a + 2b + d*e + e , w b - 2w a + 2b*d + 0,0 0,0 0,0 0,1 ----------------------------------------------------------------------- 2 2 2 b*e, w a - 2w b - a*e, 2w + w e - 2a + 2d*e + e , w w + 0,0 0,1 0,1 0,0 0,0 0,1 ----------------------------------------------------------------------- 2 2 2 w e - 2a*b, w - 4b - e ) 0,1 0,0 o96 : Ideal of QQ[w ..w , a..b, d..e] 0,0 0,1

## Further information

• Default value: {}
• Function: integralClosure -- integral closure of an ideal or a domain
• Option key: Strategy -- an optional argument

## Caveat

The list of strategies may change in the future!

## Functions with optional argument named Strategy :

• annihilator(...,Strategy=>...) -- see annihilator -- the annihilator ideal
• associatedPrimes(...,Strategy=>...) -- see associatedPrimes -- find associated primes
• basis(...,Strategy=>...) -- see basis -- basis or generating set of all or part of a ring, ideal or module
• canonicalBundle(...,Strategy=>...) (missing documentation)
• mingens(...,Strategy=>...) -- see Complement -- a Strategy option value
• trim(...,Strategy=>...) -- see Complement -- a Strategy option value
• compose(Module,Module,Module,Strategy=>...) -- see compose -- composition as a pairing on Hom-modules
• cotangentSheaf(...,Strategy=>...) (missing documentation)
• determinant(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
• dual(ChainComplex,Strategy=>...) (missing documentation)
• dual(Matrix,Strategy=>...) (missing documentation)
• dual(MonomialIdeal,List,Strategy=>...) -- see dual(MonomialIdeal,Strategy=>...)
• dual(MonomialIdeal,RingElement,Strategy=>...) -- see dual(MonomialIdeal,Strategy=>...)
• dual(MonomialIdeal,Strategy=>...)
• dual(SheafMap,Strategy=>...) (missing documentation)
• End(...,Strategy=>...) -- see End -- module of endomorphisms
• exteriorPower(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
• gb(...,Strategy=>...) -- see gb -- compute a Gröbner basis
• gcdLLL(...,Strategy=>...) (missing documentation)
• GF(...,Strategy=>...) -- see GF -- make a finite field
• groebnerBasis(...,Strategy=>...) -- see groebnerBasis -- Gröbner basis, as a matrix
• hermite(...,Strategy=>...) (missing documentation)
• Hom(...,Strategy=>...) -- see Hom -- module of homomorphisms
• homomorphism'(...,Strategy=>...) -- see homomorphism' -- get the element of Hom from a homomorphism
• hooks(...,Strategy=>...) -- see hooks -- list hooks attached to a key
• idealizer(...,Strategy=>...) -- see idealizer -- compute Hom(I,I) as a quotient ring
• integralClosure(...,Strategy=>...) -- control the algorithm used
• intersect(Ideal,Ideal,Strategy=>...) -- see intersect(Ideal,Ideal) -- compute an intersection of a sequence of ideals or modules
• intersect(Module,Module,Strategy=>...) -- see intersect(Ideal,Ideal) -- compute an intersection of a sequence of ideals or modules
• intersectInP(...,Strategy=>...) -- see intersectInP(...,BasisElementLimit=>...) -- Option for intersectInP
• isPrimary(...,Strategy=>...) -- see isPrimary -- determine whether a submodule is primary
• isPrime(Ideal,Strategy=>...) -- see isPrime(Ideal) -- whether an ideal is prime
• LLL(...,Strategy=>...) -- choose among different algorithms
• localize(...,Strategy=>...) -- see localize -- localize an ideal at a prime ideal
• match(...,Strategy=>...) -- see match -- regular expression matching
• decompose(Ideal,Strategy=>...) -- see minimalPrimes -- minimal primes of an ideal
• minimalPrimes(...,Strategy=>...) -- see minimalPrimes -- minimal primes of an ideal
• minors(...,Strategy=>...) -- choose between Bareiss, Cofactor and Dynamic algorithms
• parallelApply(...,Strategy=>...) -- see parallelApply -- apply a function to each element in parallel
• primaryComponent(...,Strategy=>...) -- see primaryComponent -- find a primary component corresponding to an associated prime
• pushForward(...,Strategy=>...) (missing documentation)
• quotient(...,Strategy=>...)
• radicalContainment(...,Strategy=>...) -- see radicalContainment -- whether an element is contained in the radical of an ideal
• analyticSpread(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• distinguished(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• isLinearType(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• isReduction(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• minimalReduction(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• multiplicity(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• normalCone(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• reesAlgebra(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• specialFiber(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• specialFiberIdeal(...,Strategy=>...) -- see reesIdeal(...,Strategy=>...) -- Choose a strategy for the saturation step
• regSeqInIdeal(...,Strategy=>...) -- see regSeqInIdeal -- a regular sequence contained in an ideal
• resolution(...,Strategy=>...)
• saturate(...,Strategy=>...)
• sheafHom(...,Strategy=>...) (missing documentation)
• primaryDecomposition(...,Strategy=>...) -- see strategies for computing primary decomposition
• syz(...,Strategy=>...) -- see syz(Matrix) -- compute the syzygy matrix
• tangentCone(...,Strategy=>...) -- see tangentCone(Ideal)
• tangentSheaf(...,Strategy=>...) (missing documentation)