Modified groebner_basis() method for both classes

Author: 25shriya

src/sage/matroids/chow_ring_ideal.py

@@ -3,6 +3,7 @@
 from sage.matroids.utilities import cmp_elements_key
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from sage.sets.set import Set
+from sage.rings.polynomial.multi_polynomial_sequence import PolynomialSequence
 
 
 class ChowRingIdeal(MPolynomialIdeal):
@@ -20,13 +21,13 @@ def __init__(self, M, R):
         names = ['A{}'.format(''.join(str(x) for x in sorted(F, key=cmp_elements_key))) for F in self.flats]
 
         try:
-            poly_ring = PolynomialRing(R, names) #self.ring
+            self.poly_ring = PolynomialRing(R, names) #self.ring
         except ValueError: # variables are not proper names
-            poly_ring = PolynomialRing(R, 'A', len(self.flats))
+            self.poly_ring = PolynomialRing(R, 'A', len(self.flats))
 
 
-        gens = poly_ring.gens()
-        self.flat_generator = dict(zip(self.flats, gens))
+        gens = self.poly_ring.gens()
+        self.flats_generator = dict(zip(self.flats, gens))
 
 
         Q = [gens[i] * gens[i+j+1] for i,F in enumerate(self.flats)
@@ -36,38 +37,39 @@ def __init__(self, M, R):
             for j,x in enumerate(E) for y in E[j+1:]]
 
 
-        MPolynomialIdeal.__init__(self, poly_ring, Q + L)
+        MPolynomialIdeal.__init__(self, self.poly_ring, Q + L)
 
     def _repr_(self):
         return "Chow ring ideal of {}".format(self._matroid)
 
     def groebner_basis(self):  
         gb = list()
         for F in self.flats:
-            for G in self.flats: #write from F not G
+            for G in self.flats: 
                 if not (F < G or G < F):
-                    gb.append(self.names[F]*self.names[G])
+                    gb.append(self.flats_generator[F]*self.flats_generator[G])
                 elif Set(F).is_empty():
-                    term = 0
+                    term = self.poly_ring.zero()
                     for H in self.flats:
                         if H < F:
-                            term += self.names[H]
+                            term += self.flats_generator[H]
                     gb.append(term**self._matroid.rank(Set(G)))
                 elif F < G:
-                    term = 0
+                    term = self.poly_ring.zero()
                     for H in self.flats:
                         if H < F:
-                            term += self.names[H]
+                            term += self.flats_generator[H]
                         gb.append(term**(self._matroid.rank(Set(G))-self._matroid.rank(Set(F))))
 
-        return gb        
+        g_basis = PolynomialSequence(self.poly_ring, [gb])
+        return g_basis
 
 
     def matroid(self):
         return self._matroid
 
-    def flat_generator(self):
-        return dict(self.flat_generator)
+    def flats_generator(self):
+        return dict(self.flats_generator)
 
 
 
@@ -85,8 +87,8 @@ def __init__(self, M, R):
         self.flats_generator = dict()
         #names_groundset = ['A{}'.format(''.join(str(x))) for x in E]
         #names_flats = ['B{}'.format(''.join(str(x) for x in sorted(F, key=cmp_elements_key))) for F in self.flats]
-        poly_ring = PolynomialRing(R, 'A', len(E) + len(self.flats))
-        gens = poly_ring.gens()
+        self.poly_ring = PolynomialRing(R, 'A', len(E) + len(self.flats))
+        gens = self.poly_ring.gens()
         for i,x in enumerate(E):
                 self.flats_generator[x] = gens[i]
         for i,F in enumerate(self.flats):
@@ -116,17 +118,13 @@ def __init__(self, M, R):
         #Q.append([gens[i]*gens[len(E)+j] for i,x in enumerate(E) for j,F in enumerate(self.flats) if F not in flats_containing[x]])
         L = list()
         for i,x in enumerate(E):
-            term = poly_ring.zero()
+            term = self.poly_ring.zero()
             for j,F in enumerate(self.flats):
                 if F not in flats_containing[x]:
                     term += gens[le+j]
             L.append(gens[i] - term)
 
-        for g in Q:
-            print(g, g.parent())
-        for g in L:
-            print(g, g.parent())
-        MPolynomialIdeal.__init__(self, poly_ring, Q + L)
+        MPolynomialIdeal.__init__(self, self.poly_ring, Q + L)
 
     def _repr_(self): #use single underscore
         return "Augmented Chow ring ideal of {}".format(self._matroid)
@@ -135,14 +133,13 @@ def matroid(self):
         return self._matroid
 
     def flat_generator(self):
-        return self.flat_generator
+        return self.flats_generator
 
 
 
 
 
     def groebner_basis(self, atom_free=False):
-        #list returned or iterator returned? - neither - polynomial_sequence_generic object
         gb = []
         flats = self.flats
         if Set([]) in flats:
@@ -151,48 +148,49 @@ def groebner_basis(self, atom_free=False):
             for F in flats:
                 for G in flats:
                     if not (F > G or G > F):
-                        gb.append(self.names[F]*self.names[G])
+                        gb.append(self.flats_generator[F]*self.flats_generator[G])
                     elif F < G:
-                        term = 0
+                        term = self.poly_ring.zero()
                         for H in self.flats:
                             if H < F:
-                                term += self.names[H]
-                        gb.append(self.names[F]*(term**self._matroid.rank(Set(G)))*
+                                term += self.flats_generator[H]
+                        gb.append(self.flats_generator[F]*(term**self._matroid.rank(Set(G)))*
                                 (term**(self._matroid.rank(Set(G))-self._matroid.rank(Set(F)))))
 
         else:
             E = list(self._matroid.groundset())
             for i in E:
                 for F in flats:
                     for G in flats:
-                        term = 0
+                        term = self.poly_ring.zero()
                         for H in flats:
                             if i in Set(H):
-                                term += self.names[H]
-                        gb.append(self.names[i] + term)
+                                term += self.flats_generator[H]
+                        gb.append(self.flats_generator[i] + term)
 
                         if i in Set(F):
-                            term = 0
+                            term = self.poly_ring.zero()
                             for H in flats:
                                 if H < F:
-                                    term += self.names[H]
-                            gb.append(self.names[i]*(term**self._matroid.rank(Set(G)))*
+                                    term += self.flats_generator[H]
+                            gb.append(self.flats_generator[i]*(term**self._matroid.rank(Set(G)))*
                                 (term**(self._matroid.rank(Set(G))-self._matroid.rank(Set(F)))))
 
                         elif not i in Set(F):
-                            gb.append(self.names[i]*self.names[F])
+                            gb.append(self.flats_generator[i]*self.flats_generator[F])
 
                         elif not (F < G or G < F):
-                            gb.append(self.names[F]*self.names[G])
+                            gb.append(self.flats_generator[F]*self.flats_generator[G])
 
                         elif F < G:
-                            term = 0
+                            term = self.poly_ring.zero()
                             for H in flats:
                                 if H < F:
-                                    term += self.names[H]
+                                    term += self.flats_generator[H]
                             gb.append(term**(self._matroid.rank(Set(G))-self._matroid.rank(Set(F))))
 
-        return gb
+        g_basis = PolynomialSequence(self.poly_ring, [gb])
+        return g_basis