Consider a polynomial ring, S, in N variables. Consider the family of saturated ideals, I⊂S, satisfying the following constraints. (Note: hS/I will denote the hilbert function of S/I, and Δ will denote the difference operator. (i.e. ΔhS/I(d)=hS/I(d)-hS/I(d-1).)
The functions G, F, g, f, and p are arguments to the method. In the case where a value is not given, the corresponding constraint is removed (i.e. made the trivial constraint). Note: if p is not specified F and G must be equal for large degrees.
maxBettiNumbers returns the upper bound for the total Betti numbers of the ideals along with other information. A complete description of the output can be found under MaxBetti.
Almost lexsegment ideals have the largest total Betti numbers out of all saturated ideals with a given Hilbert function. The function almostLexIdeal is useful to obtain the ideals with maximal Betti numbers.
The following is an example in 6 variables where we fix the Hilbert polynomial to be 2d+10, and look at the Betti tables of the ideals that realize the maximum total Betti numbers.
i1 : QQ[d]; |
i2 : result = maxBettiNumbers(6, HilbertPolynomial => 2*d+10,
ResultsCount => "All")
o2 = MaxBetti{BettiUpperBound => {18, 51, 60, 33, 7} }
HilbertFunctions => {{1, 6, 14, 16} }
{{1, 6, 12, 16, 18}}
isRealizable => true
MaximalBettiNumbers => {{18, 51, 60, 33, 7}}
MaximumBettiSum => 169
o2 : MaxBetti
|
i3 : almostLexBetti_6 \ toList result.HilbertFunctions
0 1 2 3 4 5 0 1 2 3 4 5
o3 = {total: 1 18 51 60 33 7, total: 1 18 51 60 33 7}
0: 1 . . . . . 0: 1 . . . . .
1: . 7 13 11 5 1 1: . 9 20 20 10 2
2: . 11 38 49 28 6 2: . 6 20 25 14 3
3: . 3 11 15 9 2
o3 : List
|
Restricting to ideals with at least one linear element gives us a different result.
i4 : result = maxBettiNumbers(6, HilbertPolynomial => 2*d+10,
HilbertFunctionUpperBound => {,5}, ResultsCount => "All")
o4 = MaxBetti{BettiUpperBound => {16, 48, 59, 33, 7} }
HilbertFunctions => {{1, 5, 14, 16}}
isRealizable => true
MaximalBettiNumbers => {{16, 48, 59, 33, 7}}
MaximumBettiSum => 163
o4 : MaxBetti
|
i5 : I = almostLexIdeal(QQ[x_1..x_6], first result.HilbertFunctions)
2 2 2 2 3 2 2
o5 = ideal (x , x , x x , x x x , x x x , x x , x x x , x x , x , x x , x x ,
1 2 2 3 2 3 4 2 3 5 2 4 2 4 5 2 5 3 3 4 3 5
------------------------------------------------------------------------
2 2 3 2
x x , x x x , x x , x , x x )
3 4 3 4 5 3 5 4 4 5
o5 : Ideal of QQ[x , x , x , x , x , x ]
1 2 3 4 5 6
|
i6 : betti res I
0 1 2 3 4 5
o6 = total: 1 16 48 59 33 7
0: 1 1 . . . .
1: . 1 1 . . .
2: . 14 47 59 33 7
o6 : BettiTally
|
i7 : hilbertPolynomial(I, Projective=>false) o7 = 2i + 10 o7 : QQ[i] |
i8 : (0..6)/(d->hilbertFunction(d,I)) o8 = (1, 5, 14, 16, 18, 20, 22) o8 : Sequence |
In most situations, there is an ideal in the family that realizes this upper bound. However, there are situations where this is not true. This method indicates this with the key isRealizable. However, there is always an ideal that gives the maximum sum of the total Betti numbers. This maximum is given by the key MaximumBettiSum. The following example in 5 variables shows this phenomenon. In it we fix the Hilbert polynomial to be 5d+11, and we restrict ΔhS/I(d)≥8 for d=3,4.
i9 : result = maxBettiNumbers(5, HilbertDifferenceLowerBound => {,,,8,8},
HilbertPolynomial => 5*d+11);
|
i10 : sum result.BettiUpperBound o10 = 98 |
i11 : result.MaximumBettiSum -- This doesn't match the previous sum. o11 = 97 |
i12 : result.isRealizable -- As a result, this is false. o12 = false |
Because the inputs can be incomplete or absent, maxBettiNumbers assumes the following default values for the missing information.
More details can be found under maxBettiNumbers(..., HilbertFunctionLowerBound => ...). In the case where the inputs result in constraints that are impossible or invalid, an error is thrown.
In addition to upper bounds for the total Betti numbers, this function can optionally output Hilbert functions with maximal total Betti numbers. This is specified with the optional argument ResultsCount. More details can be found under maxBettiNumbers(..., ResultsCount => ...).
There are two different algorithms that get used: the Simplified algorithm, which is faster, but is not guarenteed to give sharp bounds, and the Complete algorithm, which always gives sharp bounds. The optional argument Algorithm allows the selection of the algorithm. A more complete description can be found under maxBettiNumbers(..., Algorithm => ...).
We will consider an example where S is the polynomial ring in 5 variables. This example has only maximal total Betti Numbers, and not maximum total Betti numbers. Also, the Simplified and Complete algorithms give different results. Both of these are somewhat unusual, but give an illuminating example. We will choose the following constraints:
Since we will be using these constraints in several examples, we will first define a few variables to reduce repetition.
i13 : N = 5; |
i14 : g = HilbertDifferenceLowerBound => {,,,8,8,5,5};
|
i15 : G = HilbertFunctionLowerBound => {,,,,,,41};
|
i16 : F = HilbertFunctionUpperBound => {,,,,,,41};
|
i17 : p = HilbertPolynomial => 49; |
We find that (23, 54, 47, 14) is the upper bound for the total Betti numbers of all saturated ideals with these constraints. Additionally, the maximum for the sum of the Betti numbers is 137. Note that because 23 + 54 + 47 + 14 = 138, there is no single ideal with total Betti numbers of (23, 54, 47, 14).
i18 : maxBettiNumbers(N,p,g,G,F)
o18 = MaxBetti{BettiUpperBound => {23, 54, 47, 14}}
isRealizable => false
MaximumBettiSum => 137
o18 : MaxBetti
|
If we want the Hilbert function of an ideal with maximal total Betti numbers, we can pass ResultsCount=>"One" as an option. Note, this gives an ideal with the maximum for the sum of the Betti numbers.
i19 : maxBettiNumbers(N,p,g,G,F, ResultsCount=>"One")
o19 = MaxBetti{BettiUpperBound => {23, 54, 47, 14} }
HilbertFunctions => {{1, 5, 11, 21, 30, 36, 41, 46, 49, 49}}
isRealizable => false
MaximumBettiSum => 137
o19 : MaxBetti
|
If we want the Hilbert function of all ideals that have the maximum sum of the Betti numbers, we can pass ResultsCount=>"AllMaxBettiSum" as an option.
i20 : maxBettiNumbers(N,p,g,G,F, ResultsCount=>"AllMaxBettiSum")
o20 = MaxBetti{BettiUpperBound => {23, 54, 47, 14} }
HilbertFunctions => {{1, 5, 11, 21, 30, 36, 41, 42, 43, 44, 45, 46, 47, 48, 49, 49}}
{{1, 5, 11, 21, 30, 36, 41, 43, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 46, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 49, 49} }
isRealizable => false
MaximumBettiSum => 137
o20 : MaxBetti
|
Finally, if we want the Hilbert function of all ideals that have maximal total Betti numbers, we can pass ResultsCount=>"All" as an option. In addition to returning the upper bound and Hilbert functions, the maximal total Betti numbers of (23, 54, 45, 13) and (22, 54, 47, 14) are also returned.
i21 : maxBettiNumbers(N,p,g,G,F, ResultsCount=>"All")
o21 = MaxBetti{BettiUpperBound => {23, 54, 47, 14} }
HilbertFunctions => {{1, 5, 15, 23, 31, 36, 41, 42, 43, 44, 45, 46, 47, 48, 49, 49}}
{{1, 5, 11, 21, 30, 36, 41, 42, 43, 44, 45, 46, 47, 48, 49, 49}}
{{1, 5, 15, 23, 31, 36, 41, 43, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 43, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 45, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 43, 45, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 44, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 45, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 43, 45, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 43, 45, 47, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 44, 46, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 46, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 44, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 45, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 46, 47, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 47, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 44, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 44, 47, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 45, 47, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 47, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 45, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 46, 48, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 48, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 45, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 45, 49, 49} }
{{1, 5, 15, 23, 31, 36, 41, 46, 49, 49} }
{{1, 5, 11, 21, 30, 36, 41, 46, 49, 49} }
isRealizable => false
MaximalBettiNumbers => {{23, 54, 45, 13}}
{{22, 54, 47, 14}}
MaximumBettiSum => 137
o21 : MaxBetti
|
Because we are setting an upper bound of hS/I(6) ≤41, the Simplified algorithm will not give sharp bounds. As a result, the Complete algorithm is automatically chosen instead. However, we can force the use of a different one. In this case, if we specify Algorithm=>"Simplified", we get an upper bound that is, necessarily, larger. Additionally, we are given a Hilbert function that appears to be valid, but is not the Hilbert function of any saturated ideal.
i22 : maxBettiNumbers(N,p,g,G,F, Algorithm=>"Simplified", ResultsCount=>"One")
o22 = MaxBetti{BettiUpperBound => {24, 57, 50, 15} }
HilbertFunctions => {{1, 5, 11, 21, 30, 36, 41, 49, 49}}
isRealizable => false
MaximumBettiSum => 145
o22 : MaxBetti
|
We can compare the speed of the two algorithms with an example of fixing the Hilbert polynomial to be 3d2-6d+175 in a ring with 6 variables. Because there is no upper bound for hS/I, both algorithms give valid results, and smallest possible upper bounds.
i23 : p = HilbertPolynomial => 3*d^2-6*d+175;
i24 : first timing maxBettiNumbers(6, p,
Algorithm=>"Simplified", ResultsCount=>"None")
o24 = 5.908441668
o24 : RR (of precision 53)
i25 : first timing maxBettiNumbers(6, p,
Algorithm=>"Simplified", ResultsCount=>"All")
o25 = 7.467646269
o25 : RR (of precision 53)
i26 : first timing maxBettiNumbers(6, p,
Algorithm=>"Complete", ResultsCount=>"None")
o26 = 21.462211888
o26 : RR (of precision 53)
i27 : first timing maxBettiNumbers(6, p,
Algorithm=>"Complete", ResultsCount=>"All")
o27 = 28.756055662
o27 : RR (of precision 53)
|
If Algorithm=>"Simplified" is forced, this may not return valid Hilbert functions for some inputs.