minimalBetti -- minimal betti numbers of (the minimal free resolution of) a homogeneous ideal or module

Synopsis

Usage:

B = minimalBetti I

B = minimalBetti(I, DegreeLimit=>d, LengthLimit=>len, Weights=>h)
Inputs:
- I, an ideal, a module, or a monomial ideal, a homogeneous ideal or module in a singly graded polynomial ring or skew commuting polynomial ring over a finite prime field
Optional inputs:
- DegreeLimit => an integer, default value null, if given, only compute enough to determine the Betti diagram up to and including the row labelled d
- LengthLimit => an integer, default value infinity, if given, only compute enough to determine the Betti diagram up to and including the column labelled len
- Weights => a list, default value null, see betti(...,Weights=>...)
- ParallelizeByDegree => a Boolean value, default value false, Use additional parallelism to compute different (homological degree, internal degree) pairs in parallel when possible. To control parallelism, see parallelism in engine computations
Outputs:
- a Betti tally,

Description

Given a singly-graded module, this function computes the minimal betti numbers of the module. If the input is an ideal $I \subset S$, it computes the minimal betti numbers of $S^1/I$.

The algorithm used is based on the FastNonminimal algorithm, except that the complex is not constructed, resulting in a smaller memory footprint and often reduced computation time.

i1 : I = Grassmannian(1,6, CoefficientRing => ZZ/101);

               ZZ
o1 : Ideal of ---[p   ..p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   ]
              101  0,1   0,2   1,2   0,3   1,3   2,3   0,4   1,4   2,4   3,4   0,5   1,5   2,5   3,5   4,5   0,6   1,6   2,6   3,6   4,6   5,6

i2 : S = ring I

o2 = S

o2 : PolynomialRing

i3 : elapsedTime C = minimalBetti I
 -- 2.07185 seconds elapsed

            0  1   2   3   4    5   6   7   8  9 10
o3 = total: 1 35 140 385 819 1080 819 385 140 35  1
         0: 1  .   .   .   .    .   .   .   .  .  .
         1: . 35 140 189  84    .   .   .   .  .  .
         2: .  .   . 196 735 1080 735 196   .  .  .
         3: .  .   .   .   .    .  84 189 140 35  .
         4: .  .   .   .   .    .   .   .   .  .  1

o3 : BettiTally

One can compute smaller parts of the Betti table, by using DegreeLimit and/or LengthLimit.

i4 : I = ideal I_*;

o4 : Ideal of S

i5 : elapsedTime C = minimalBetti(I, DegreeLimit=>2)
 -- 0.906768 seconds elapsed

            0  1   2   3   4    5   6   7
o5 = total: 1 35 140 385 819 1080 735 196
         0: 1  .   .   .   .    .   .   .
         1: . 35 140 189  84    .   .   .
         2: .  .   . 196 735 1080 735 196

o5 : BettiTally

i6 : I = ideal I_*;

o6 : Ideal of S

i7 : elapsedTime C = minimalBetti(I, DegreeLimit=>1, LengthLimit=>5)
 -- 0.0286379 seconds elapsed

            0  1   2   3  4
o7 = total: 1 35 140 189 84
         0: 1  .   .   .  .
         1: . 35 140 189 84

o7 : BettiTally

i8 : I = ideal I_*;

o8 : Ideal of S

i9 : elapsedTime C = minimalBetti(I, LengthLimit=>5)
 -- 1.4969 seconds elapsed

            0  1   2   3   4    5
o9 = total: 1 35 140 385 819 1080
         0: 1  .   .   .   .    .
         1: . 35 140 189  84    .
         2: .  .   . 196 735 1080

o9 : BettiTally

This function computes only as much of the non-minimal resolution as needed to compute the desired Betti numbers. Further calls will generally not recompute previously computed parts of the resolution, except that if you ask for a longer resolution than previously, it currently will recompute the resolution. This behavior might change in later releases.

If one has already computed the non-minimal free resolution using FastNonminimal, then one can use betti(...,Minimize=>...), except that it doesn't currently have support for DegreeLimit and LengthLimit, and probably still computes more than is needed (it is still experimental).

Caveat

Only works over finite prime field. If the ideal or module is a non-homogeneous or multi-homogeneous object, then this function will result in an error.

Ways to use minimalBetti :

minimalBetti(Ideal)
minimalBetti(Module)
minimalBetti(MonomialIdeal)

For the programmer

The object minimalBetti is a method function with options.