next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
gfanInterface :: groebnerCone

groebnerCone -- the cone whose interior weight vectors give the given initial ideal

Synopsis

Description

i1 : R = ZZ/32003[symbol a..symbol d]

o1 = R

o1 : PolynomialRing
i2 : inL = {c^4, b*d^2, b*c, b^2*d, b^3}

       4     2        2    3
o2 = {c , b*d , b*c, b d, b }

o2 : List
i3 : L = {c^4-a*d^3, -c^3+b*d^2, b*c-a*d, -a*c^2+b^2*d, b^3-a^2*c}

       4      3     3      2                  2    2    3    2
o3 = {c  - a*d , - c  + b*d , b*c - a*d, - a*c  + b d, b  - a c}

o3 : List
i4 : weightVector(inL,L)

o4 = {8, 8, 3, 1}

o4 : List
i5 : groebnerCone(inL,L)

o5 = (| 0  0  |, | 1  0 |)
      | 0  0  |  | 0  1 |
      | -2 -3 |  | -2 3 |
      | -3 -4 |  | -3 4 |

o5 : Sequence
i6 : I = monomialCurveIdeal(R,{1,3,4})

                        3      2     2    2    3    2
o6 = ideal (b*c - a*d, c  - b*d , a*c  - b d, b  - a c)

o6 : Ideal of R
i7 : time (inLs,Ls) = gfan I
This is the Gfan program for computing Groebner fans and tropical varieties.
Use the command "gfan list" to view all subcommands.
The command "gfan" is deprecate for computing all Groebner bases of an ideal.
Please use subcommand "gfan _bases" instead. Awaiting input. <Ctrl>-D to end.
LP algorithm being used: "cddgmp".
     -- used 0.0193337 seconds

           2          2   2      3          2   2      3          2   2  
o7 = ({{b*d , a*d, a*c , a c}, {c , a*d, a*c , a c}, {c , b*c, a*c , a c,
     ------------------------------------------------------------------------
      3      3        4     2   2      3        3     2     3        2    3  
     a d}, {c , b*c, b , a*c , a c}, {c , b*c, b , a*c }, {c , b*c, b d, b },
     ------------------------------------------------------------------------
         2   2         2        2   2    3            2        2    3     3  
     {b*d , b d, a*d, a c}, {b*d , b d, b , a*d}, {b*d , b*c, b d, b , a*d },
     ------------------------------------------------------------------------
       4     2        2    3         3      2                  2    2      3
     {c , b*d , b*c, b d, b }}, {{- c  + b*d , - b*c + a*d, a*c  - b d, - b 
     ------------------------------------------------------------------------
        2      3      2                  2    2      3    2      3      2 
     + a c}, {c  - b*d , - b*c + a*d, a*c  - b d, - b  + a c}, {c  - b*d ,
     ------------------------------------------------------------------------
                   2    2      3    2      4    3      3      2            
     b*c - a*d, a*c  - b d, - b  + a c, - b  + a d}, {c  - b*d , b*c - a*d,
     ------------------------------------------------------------------------
      4    3      2    2      3    2      3      2              3    2      2
     b  - a d, a*c  - b d, - b  + a c}, {c  - b*d , b*c - a*d, b  - a c, a*c 
     ------------------------------------------------------------------------
        2      3      2                  2    2    3    2        3      2   
     - b d}, {c  - b*d , b*c - a*d, - a*c  + b d, b  - a c}, {- c  + b*d , -
     ------------------------------------------------------------------------
        2    2                   3    2        3      2       2    2    3  
     a*c  + b d, - b*c + a*d, - b  + a c}, {- c  + b*d , - a*c  + b d, b  -
     ------------------------------------------------------------------------
      2                     3      2                  2    2    3    2      4
     a c, - b*c + a*d}, {- c  + b*d , b*c - a*d, - a*c  + b d, b  - a c, - c 
     ------------------------------------------------------------------------
          3     4      3     3      2                  2    2    3    2
     + a*d }, {c  - a*d , - c  + b*d , b*c - a*d, - a*c  + b d, b  - a c}})

o7 : Sequence
i8 : weightVector(inLs#0, Ls#0)

o8 = {1, 1, 4, 6}

o8 : List
i9 : scan(#inLs, i -> print weightVector(inLs#i, Ls#i));
{1, 1, 4, 6}
{1, 1, 4, 5}
{1, 1, 3, 2}
{2, 2, 3, 1}
{4, 4, 3, 1}
{6, 6, 3, 1}
{1, 1, 2, 4}
{2, 2, 1, 2}
{6, 6, 2, 1}
{8, 8, 3, 1}
i10 : scan(#inLs, i -> print groebnerCone(inLs#i, Ls#i));
(| 0 0 |, | 1  0 |)
 | 0 0 |  | 0  1 |
 | 2 1 |  | -2 3 |
 | 3 2 |  | -3 4 |
(| 0 0 |, | 1  0 |)
 | 0 0 |  | 0  1 |
 | 2 1 |  | -2 3 |
 | 3 1 |  | -3 4 |
(| 0 0 |, | 1  0 |)
 | 0 0 |  | 0  1 |
 | 1 1 |  | -2 3 |
 | 0 1 |  | -3 4 |
(| 0 0  |, | 1  0 |)
 | 0 0  |  | 0  1 |
 | 1 0  |  | -2 3 |
 | 0 -1 |  | -3 4 |
(| 0  0  |, | 1  0 |)
 | 0  0  |  | 0  1 |
 | 0  -1 |  | -2 3 |
 | -1 -2 |  | -3 4 |
(| 0  0  |, | 1  0 |)
 | 0  0  |  | 0  1 |
 | -1 -2 |  | -2 3 |
 | -2 -3 |  | -3 4 |
(| 0 0 |, | 1  0 |)
 | 0 0 |  | 0  1 |
 | 1 0 |  | -2 3 |
 | 2 1 |  | -3 4 |
(| 0 0  |, | 1  0 |)
 | 0 0  |  | 0  1 |
 | 0 -1 |  | -2 3 |
 | 1 -1 |  | -3 4 |
(| 0  0  |, | 1  0 |)
 | 0  0  |  | 0  1 |
 | -1 -3 |  | -2 3 |
 | -1 -4 |  | -3 4 |
(| 0  0  |, | 1  0 |)
 | 0  0  |  | 0  1 |
 | -2 -3 |  | -2 3 |
 | -3 -4 |  | -3 4 |

See also

Ways to use groebnerCone :