working on primitive basis

aplK.py

@@ -31,7 +31,7 @@ from sage.structure.element import Element
 from sage.structure.richcmp import rich_to_bool, op_EQ, op_NE, op_LT, op_LE, op_GT, op_GE
 from sage.rings.polynomial.polydict import ETuple
 from copy import deepcopy
-
+import itertools
 
 class AplN(DifferentialGCAlgebra_multigraded, UniqueRepresentation):
     """
@@ -520,7 +520,8 @@ class SimplicialAplN(AplN, UniqueRepresentation):
                     mono[n_vars+i] = 0
                     combinations.append(tuple(mono))
             return list(set(combinations))
-
+        
+        """
         def _add_kernel_terms_to_primitive_basis(self, basis):
             new_elements = []
             for e in basis:
@@ -529,17 +530,42 @@ class SimplicialAplN(AplN, UniqueRepresentation):
                 monomial[:n] = n*[0]
                 new_elements.append(tuple(monomial))
             return new_elements
+        """
 
+        def findsubsests(S,m):
+            return set(itertools.combinations(S,m))
+            
+        def _add_kernel_terms_to_primitive_basis(self, tdegree, ydegree):
+            apl = self.parent()
+            N = len(apl.gens())//2
+            ygens = apl.gens()[N+1:] #N+1 because we remove y0 generator
+            listProds = [prod(s) for s in findsubsets(ygens,ydegree)]
+            V = VectorSpace(GF(tdegree),N-1)
+            listCoefs = [tuple([0]+list(v)+N*[0]) for v in V]
+            listPolinomials = [self._get_term(1, c, apl.gens()) for c in listCoefs]
+            cp = cartesian_product([listProds,listPolinomials])
+            elements = [prod(c) for c in cp]
+#            for e in elements:
+#                print(e,flush=True)
+            return [tuple(e.dict().keys())[0] for e in elements]
+            
+        
+        
         def _get_primitive_basis(self):
             """
             Returns a basis of the primitive of 'self'
             """
+            if not self:
+                return []
             basis = []
             p = self.reduce()
             for monomial in p.dict().keys():
                 basis += p._get_primitive_basis_of_a_monomial(monomial)
             basis = list(set(basis))
-            basis += p._add_kernel_terms_to_primitive_basis(basis)
+            #basis += p._add_kernel_terms_to_primitive_basis(basis)
+            t_degree = 2
+            y_degree = p.total_degree()#p.degree()[0]
+            #basis += p._add_kernel_terms_to_primitive_basis(t_degree, y_degree-1)
             basis = list(set(basis))
             terms = []
             apl = self.parent()
@@ -904,7 +930,7 @@ class AlgebraAplK(UniqueRepresentation, Parent):
         def __init__(self, parent, values):
             Element.__init__(self, parent)
             self.elements = self._reduce(values)
-            #self.check()
+            self.check()
 
         def _repr_(self):
             """
@@ -1080,7 +1106,7 @@ class AlgebraAplK(UniqueRepresentation, Parent):
                 degree = -1
                 for e in self.elements.values():
                     if e:
-                        degree = e.degree()[0]
+                        degree = e.total_degree()#e.degree()[0]
                         break
                 return degree
 
@@ -1309,6 +1335,7 @@ class AlgebraAplK(UniqueRepresentation, Parent):
 
         def solve_primitive(self):
             p_basis = self._get_primitive_basis()
+            print("lenght primitive basis: ",len(p_basis))
             d_basis = self._get_differential_basis(p_basis)
             diff_matrix = self._get_differential_matrix(p_basis, d_basis)
             v_dif = self._get_vector_diff_coordinates(d_basis)

test_aplK.py

@@ -1,6 +1,9 @@
 #############################################
 # TEST
+load("aplK.py")
 print("TEST AlgebraAplK")
+
+"""
 S = SimplicialComplex([[0,1,2]],is_mutable=False)
 A = AlgebraAplK(S)
 print("Test check if the assignation is valid")
@@ -17,7 +20,56 @@ p12 = t0+3*t1
 s2 = SimplicialAlgebraplN(2)
 s2.inject_variables()
 p012 = 2-t1+t2
-values = {(0,): p0, (1,): p1, (2,): p2, (0,1): p01, (0,2): p02, (1,2): p12,  (0,1,2): p012}
+#values = {(0,): p0, (1,): p1, (2,): p2, (0,1): p01, (0,2): p02, (1,2): p12,  (0,1,2): p012}
 e1 = A._element_constructor_(values)
-e1
+"""
+S = SimplicialComplex([[0,1,2,3]],is_mutable=False)
+A = AlgebraAplK(S)
+s3 = SimplicialAlgebraplN(3)
+s3.inject_variables()
+p0123 = (t1**2)*y1+t3*y0+y2+t1*y2+t2*y1
+s2 = SimplicialAlgebraplN(2)
+s2.inject_variables()
+p012 = p0123.face(3)
+p013 = p0123.face(2)
+p023 = p0123.face(1)
+p123 = p0123.face(0)
+s1 = SimplicialAlgebraplN(1)
+s1.inject_variables()
+p01 = p012.face(2)
+p02 = p012.face(1)
+p03 = p013.face(1)
+p12 = p012.face(0)
+p13 = p013.face(0)
+p23 = p123.face(0)
+s0 = SimplicialAlgebraplN(0)
+s0.inject_variables()
+p0 = p01.face(1)
+p1 = p01.face(0)
+p2 = p12.face(0)
+p3 = p03.face(0)
+
+values = {(0,): p0, (1,): p1, (2,): p2, (3,):p3,
+          (0,1): p01, (0,2): p02, (0,3): p03, (1,2): p12,  (1,3): p13, (2,3): p23,
+          (0,1,2): p012, (0,1,3):p013, (0,2,3): p023, (1,2,3):p123,
+          (0,1,2,3):p0123}
+e1 = A._element_constructor_(values)
+de1 = e1.differential()
+
+"""
+for k in de1.elements.keys():
+    e = de1.elements[k]
+    print(k, e)
+    if e:
+        print(e.total_degree())
+"""
+e2 = de1.solve_primitive()
+print("de1: ",de1)
+print("e2: ",e2)
+
+if e1.differential() == e2.differential():
+    print("the differentials of e1 and e2 are equal")
+else:
+    print("the differentials are different")
+
 #############################################

test_minimal_model.py

@@ -3,10 +3,12 @@ load('aplK.py')
 load('minimalModel.py')
 #######################################################
 # TESTS
-S1 = simplicial_complexes.Sphere(2)
-S2 = simplicial_complexes.Sphere(3)
-S = S1.wedge(S2, is_mutable=False)
-#S = simplicial_complexes.K3Surface()
+#S1 = simplicial_complexes.Sphere(3)
+#S2 = simplicial_complexes.Sphere(3)
+#S = S1.wedge(S2, is_mutable=False)
+#S = simplicial_complexes.KleinBottle().suspension()
+#S.set_immutable()
+S = simplicial_complexes.K3Surface()
 #print("Complejo simplicial")
 #print(S.facets())
 #######################################################
@@ -16,5 +18,5 @@ S = S1.wedge(S2, is_mutable=False)
 #######################################################
 # S = simplicial_complexes.ProjectivePlane().wedge(simplicial_complexes.Sphere(2), is_mutable=False)
 #######################################################
-[sullivan_model, model_morphism, cohomology_correspondence] = minimal_model(S, max_depth=10, max_dim=12)
+[sullivan_model, model_morphism, cohomology_correspondence] = minimal_model(S, max_depth=10, max_dim=5)
 print(sullivan_model)

test_primitive.py

@@ -84,6 +84,6 @@ listProds = [prod(s) for s in findsubsets(ygens,degree)]
 V = VectorSpace(GF(degree),N-1)
 listCoefs = [tuple([0]+list(v)+N*[0]) for v in V]
 listPolinomials = [p._get_term(1, c, parent.gens()) for c in listCoefs]
-cp = cartesian_product([lista,listPolinomials])
+cp = cartesian_product([listProds,listPolinomials])
 elements = [prod(c) for c in cp]