######################################################### # Groebner cone computations Coefficients yz-projection # ######################################################### # In order to find all possible combinatorial types of resulting modified 3D-tropical curves with Theta graphs as minimal skeletons, we must compute the Groebner fans of all the coefficients. Afterwards, we intersect the fan with the TypeIICone, check for subdivisions (in "ComputingSubdivisionsCoefficientsyz.sage"), and compute the leading terms for each piece in the subdivision. # This script computes the Groebner Cones for each of the polynomials. # Our calculations are valid when the residue field has characteristic 0. # The necessary date (including the polynomials) is obtained by loading the following file: load("macroslocalJInvariantComputationsAndPrimesWithBadReduction.sage") As = [var("b5"),var("b4"),var("b34"), var("b2")] R = PolynomialRing(QQ,As) K = FractionField(R); oldAs = [var("b5"),var("b4"),var("b3"),var("b34"), var("b2")] oldR = PolynomialRing(QQ,oldAs) oldK = FractionField(oldR); load("coefficientsProjectionyz.sage") # We turn the expressions into polynomials and perform the substitution b3 = b3+b4 mx4 = R(expand(oldR(mx4).substitute(b3=b34+b4))) mx3y = R(expand(oldR(mx3y).substitute(b3=b34+b4))) mx2y2 = R(expand(oldR(mx2y2).substitute(b3=b34+b4))) mxy3 = R(expand(oldR(mxy3).substitute(b3=b34+b4))) my4 = R(expand(oldR(my4).substitute(b3=b34+b4))) mx3 = R(expand(oldR(mx3).substitute(b3=b34+b4))) mx2y = R(expand(oldR(mx2y).substitute(b3=b34+b4))) mxy2 = R(expand(oldR(mxy2).substitute(b3=b34+b4))) my3 = R(expand(oldR(my3).substitute(b3=b34+b4))) mx2 = R(expand(oldR(mx2).substitute(b3=b34+b4))) mxy = R(expand(oldR(mxy).substitute(b3=b34+b4))) my2 = R(expand(oldR(my2).substitute(b3=b34+b4))) mx = R(expand(oldR(mx).substitute(b3=b34+b4))) my = R(expand(oldR(my).substitute(b3=b34+b4))) # We take the product of all the above fans to compute the common refinement of all Groebner cones: allm = mx4*mx3y*mx2y2*mxy3*my4*mx3*mx2y*mxy2*my3*mx2*mxy*my2*mx*my ################################# # Calculations of Groebner cones # ################################# ####### # mx4 # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx4,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx4.sobj") gfm = load("Coefficientsyz/GroebnerFanmx4.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 5, 9, 6] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 2], [0, 1, 4], [0, 2, 3], [0, 3, 4], [1, 2, 3], [1, 3, 4]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx4Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ######## # mx3y # ######## # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx3y,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx3y.sobj") gfm = load("Coefficientsyz/GroebnerFanmx3y.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 6, 11, 7] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, 3, -1, -1], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [1, 3, 4, 5], [2, 3, 5], [2, 4, 5]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx3yDict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ######### # mx2y2 # ######### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx2y2,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx2y2.sobj") gfm = load("Coefficientsyz/GroebnerFanmx2y2.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 5, 9, 6] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, 3, -1, -1], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, 1, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [1, 3, 4], [2, 3, 4]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx2y2Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ######## # mxy3 # ######## # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mxy3,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmxy3.sobj") gfm = load("Coefficientsyz/GroebnerFanmxy3.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 5, 9, 6] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, 3, -1, -1], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, 1, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [1, 3, 4], [2, 3, 4]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmxy3Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # my4 # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(my4,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmy4.sobj") gfm = load("Coefficientsyz/GroebnerFanmy4.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 5, 9, 6] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, 3, -1, -1], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, 1, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [1, 3, 4], [2, 3, 4]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmy4Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # mx3 # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx3,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx3.sobj") gfm = load("Coefficientsyz/GroebnerFanmx3.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 19, 11] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, -1, 1], [0, -1, 1, 0], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3], [5, 1, -3, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 2, 4], [0, 1, 4, 5], [0, 2, 8], [0, 3, 7, 8], [1, 3, 6], [2, 4, 8], [1, 5, 6, 9], [3, 6, 7, 9], [4, 5, 8, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx3Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ######## # mx2y # ######## # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx2y,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx2y.sobj") gfm = load("Coefficientsyz/GroebnerFanmx2y.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 20, 12] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, -1, 1], [0, -1, 1, 0], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 2, 4], [0, 1, 4, 5], [0, 2, 8], [0, 3, 7, 8], [1, 3, 6], [2, 4, 8], [3, 6, 7], [1, 5, 6, 9], [4, 5, 8, 9], [6, 7, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx2yDict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ######## # mxy2 # ######## # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mxy2,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmxy2.sobj") gfm = load("Coefficientsyz/GroebnerFanmxy2.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 20, 12] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, -1, 1], [0, -1, 1, 0], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 2, 4], [0, 1, 4, 5], [0, 2, 8], [0, 3, 7, 8], [1, 3, 6], [2, 4, 8], [3, 6, 7], [1, 5, 6, 9], [4, 5, 8, 9], [6, 7, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmxy2Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # my3 # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(my3,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmy3.sobj") gfm = load("Coefficientsyz/GroebnerFanmy3.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 20, 12] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, -1, 1], [0, -1, 1, 0], [1, -3, 1, 1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3], [0, 2, 4], [0, 1, 4, 5], [0, 2, 8], [0, 3, 7, 8], [1, 3, 6], [2, 4, 8], [3, 6, 7], [1, 5, 6, 9], [4, 5, 8, 9], [6, 7, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmy3Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # mx2 # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx2,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx2.sobj") gfm = load("Coefficientsyz/GroebnerFanmx2.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 7, 15, 10] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, -3, 5, 1], [-3, 1, 1, 1], [-1, -1, -1, 3], [0, -1, 1, 0], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 2], [0, 1, 5], [0, 2, 3], [1, 2, 4], [0, 3, 5], [1, 4, 5], [2, 3, 6], [2, 4, 6], [3, 5, 6], [4, 5, 6]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmx2Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # mxy # ####### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mxy,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmxy.sobj") gfm = load("Coefficientsyz/GroebnerFanmxy.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 21, 13] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, -3, 5, 1], [-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, 1, -1], [0, -1, 1, 0], [1, -3, 5, -3], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3, 4], [0, 1, 2], [0, 2, 5], [0, 3, 5, 6], [1, 2, 7], [1, 4, 7], [3, 4, 6, 8], [4, 7, 8], [2, 5, 9], [2, 7, 9], [5, 6, 9], [6, 8, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmxyDict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ####### # my2 # ###### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(my2,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmy2.sobj") gfm = load("Coefficientsyz/GroebnerFanmy2.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 10, 21, 13] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, -3, 5, 1], [-3, 1, 1, 1], [-1, -1, -1, 3], [-1, -1, 3, -1], [-1, 1, 1, -1], [0, -1, 1, 0], [1, -3, 5, -3], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 3, 4], [0, 1, 2], [0, 2, 5], [0, 3, 5, 6], [1, 2, 7], [1, 4, 7], [3, 4, 6, 8], [4, 7, 8], [2, 5, 9], [2, 7, 9], [5, 6, 9], [6, 8, 9], [7, 8, 9]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmy2Dict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ###### # mx # ###### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(mx,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmx.sobj") gfm = load("Coefficientsyz/GroebnerFanmx.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 6, 12, 8] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [0, -1, 1, 0], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 2], [0, 1, 3], [0, 2, 4], [0, 3, 4], [1, 2, 5], [1, 3, 5], [2, 4, 5], [3, 4, 5]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmxDict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ###### # my # ###### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(my,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFanmy.sobj") gfm = load("Coefficientsyz/GroebnerFanmy.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 6, 12, 8] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, 1, 1, 1], [-1, -1, -1, 3], [0, -1, 1, 0], [1, 1, -3, 1], [1, 1, 1, -3], [3, -1, -1, -1]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 2], [0, 1, 3], [0, 2, 4], [0, 3, 4], [1, 2, 5], [1, 3, 5], [2, 4, 5], [3, 4, 5]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfmyDict.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4} ##################### # Common refinement # ##################### # gfm = GrobnerFanComputations(fromPolynomialsToExtremalMonomials(allm,R)) # We save it: # save(gfm, "Coefficientsyz/GroebnerFansCommonRefinementyz.sobj") gfm = load("Coefficientsyz/GroebnerFansCommonRefinementyz.sobj") # We record the f-vector: # print gfm.f_vector() # [1, 21, 54, 35] # We confirm the dimension of the fan is the expected one: # print gfm.dim() # 4 # We record the coordinates of the rays of the Groebner fan: RaysGFm = gfm.rays() # print RaysGFm # [[-3, -3, 5, 1], [-3, 1, 1, 1], [-1, -5, 3, 3], [-1, -1, -1, 3], [-1, -1, 1, 1], [-1, -1, 3, -1], [-1, 1, -1, 1], [-1, 1, 1, -1], [-1, 3, -1, -1], [0, -1, 1, 0], [0, 1, -1, 0], [1, -3, 1, 1], [1, -3, 5, -3], [1, -1, -1, 1], [1, -1, 1, -1], [1, 1, -3, 1], [1, 1, -1, -1], [1, 1, 1, -3], [3, -5, 3, -1], [3, -1, -1, -1], [5, 1, -3, -3]] # print gfm.lineality_dim() # 1 # We record the maximal cones of the fan. Each cone is described by the indices of the extremal rays spanning these cones. Such indices refer to the list of 76 rays: MaximalConesgfm = gfm.maximal_cones().values()[0] # print MaximalConesgfm # [[0, 1, 4], [0, 1, 5], [0, 2, 4, 9], [1, 3, 4], [1, 3, 6], [1, 5, 7], [1, 7, 8], [1, 6, 8, 10], [0, 5, 9], [2, 3, 4], [2, 3, 11], [3, 6, 15], [5, 7, 17], [7, 8, 17], [2, 9, 11], [5, 9, 12], [6, 10, 15], [8, 10, 16], [3, 11, 13], [5, 12, 17], [3, 13, 15], [8, 16, 17], [10, 15, 16], [12, 14, 17], [9, 11, 18], [9, 12, 14, 18], [11, 13, 19], [13, 15, 19], [14, 17, 19], [11, 18, 19], [14, 18, 19], [15, 16, 20], [16, 17, 20], [15, 19, 20], [17, 19, 20]] # We record the maximal cones in the Groebner Fan as a dictionary of polyhedral objects. The keys coincide with the indices of the maximal cones in the output of the Gfan computation. PolyMaximalConesgfmDict = MaximalCones(gfm) # save(PolyMaximalConesgfmDict, "Coefficientsyz/PolyMaximalConesgfCommonRefinementDictyz.sobj") # set([dim(x) for x in PolyMaximalConesgfmDict.values()]) # {4}