minimalBetti -- minimal betti numbers of (the mininimal 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 polynomifal 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=>...)
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
 -- 6.26653 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)
 -- 2.63627 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.0643921 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)
 -- 4.83128 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

Released in M2 1.9.1, still experimental. 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.