Modified __init__() functions for both classes

src/sage/matroids/chow_ring_ideal.py

@@ -1,11 +1,9 @@
-#from sage.all import *
-#from sage.rings.ideal import Ideal_generic
 from sage.rings.polynomial.multi_polynomial_ideal import MPolynomialIdeal
 from sage.matroids.matroid import Matroid
 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.morphism import _tensor_product_ring
+
 
 class ChowRingIdeal(MPolynomialIdeal):
     def __init__(self, M, R):
@@ -18,28 +16,27 @@ def __init__(self, M, R):
         for i,F in enumerate(self.flats):
             for x in F:
                 flats_containing[x].append(i)
-        self.flat_generator = dict()
+
+        names = ['A{}'.format(''.join(str(x) for x in sorted(F, key=cmp_elements_key))) for F in self.flats]
+
         try:
-            names = ['A{}'.format(''.join(str(x) for x in sorted(F, key=cmp_elements_key))) for F in self.flats]
-            self.poly_ring = PolynomialRing(R, names) #self.ring
-            for F in self.flats:
-                for i in range(len(self.poly_ring.gens())):
-                    self.flat_generator[F] = self.poly_ring.gens()[i] #change self.names to self.flat_generator
+            poly_ring = PolynomialRing(R, names) #self.ring
         except ValueError: # variables are not proper names
-            self.poly_ring = PolynomialRing(R, 'A', len(self.flats))
-            for i in range(len(self.flats)):
-                self.flat_generator[self.flats[i]] = self.poly_ring.gens()[i]
+            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()
+
         Q = [gens[i] * gens[i+j+1] for i,F in enumerate(self.flats)
             for j,G in enumerate(self.flats[i+1:]) if not (F < G or G < F)]
         L = [sum(gens[i] for i in flats_containing[x])
             - sum(gens[i] for i in flats_containing[y])
             for j,x in enumerate(E) for y in E[j+1:]]
-        self.gens = Q + L
 
 
-        MPolynomialIdeal.__init__(self, self.poly_ring, self.gens)
+        MPolynomialIdeal.__init__(self, poly_ring, Q + L)
 
     def _repr_(self):
         return "Chow ring ideal of {}".format(self._matroid)
@@ -67,13 +64,11 @@ def groebner_basis(self):
 
 
     def matroid(self):
-        return Matroid(self._matroid)
+        return self._matroid
 
     def flat_generator(self):
         return dict(self.flat_generator)
 
-#get matroid method, called matroid, returning the matroid
-#get names
 
 
 class AugmentedChowRingIdeal(MPolynomialIdeal):
@@ -90,28 +85,28 @@ 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]
-        self.poly_ring = PolynomialRing(R, 'A', len(E) + len(self.flats))
-        gens = self.poly_ring.gens()
+        poly_ring = PolynomialRing(R, 'A', len(E) + len(self.flats))
+        gens = poly_ring.gens()
         for i,x in enumerate(E):
                 self.flats_generator[x] = gens[i]
         for i,F in enumerate(self.flats):
             self.flats_generator[F] = gens[len(E) + i]
 
-        print(gens)
-
+
+        le = len(E)
         Q = list()
         for i,F in enumerate(self.flats):
             for j,G in enumerate(self.flats):
                     if not (F < G or G < F):
-                        print(type(gens[len(E)+i] * gens[len(E)+i+j+1]))
-                        Q.append(gens[len(E)+i] * gens[len(E)+i+j+1])
+                        #print(type(gens[le+i] * gens[le+i+j+1]))
+                        Q.append(gens[le+i] * gens[le+j])
 
         for j,F in enumerate(self.flats):
             for k,x in enumerate(E):
                 if F not in flats_containing[x]:
-                    print(type(gens[k]*gens[len(E)+j]))
-                    Q.append(gens[k]*gens[len(E)+j])
-        print("this is Q", Q)
+                    #print(type(gens[k]*gens[len(E)+j]))
+                    Q.append(gens[k]*gens[le+j])
+        #print("this is Q", Q)
 
 
 
@@ -121,17 +116,30 @@ 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 = 0
+            term = poly_ring.zero()
             for j,F in enumerate(self.flats):
                 if F not in flats_containing[x]:
-                    term += gens[len(E)+j]
-        L.append(gens[i] - term)
-        self.gens = Q + L
-        MPolynomialIdeal.__init__(self, self.poly_ring, self.gens, coerce=False)
+                    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)
 
-    def _repr_short(self): #use single underscore
+    def _repr_(self): #use single underscore
         return "Augmented Chow ring ideal of {}".format(self._matroid)
 
+    def matroid(self):
+        return self._matroid
+
+    def flat_generator(self):
+        return self.flat_generator
+
+
+
+
 
     def groebner_basis(self, atom_free=False):
         #list returned or iterator returned? - neither - polynomial_sequence_generic object