# minimalBetti(Ideal) -- 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)
• Function: minimalBetti
• Inputs:
• I, an ideal, or , 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 null, if given, only compute enough to determine the Betti diagram up to and including the column labelled len
• Outputs:

## Description

Given a singly-graded module, this function computes the minimal betti numbers of the module. If the input is an ideal I ⊂S, it computes the minimal betti numbers of S1/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 -- 5.73419 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.58965 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.102555 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.86622 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.