diff --git a/aplK.py b/aplK.py index 030e717..221f505 100644 --- a/aplK.py +++ b/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) diff --git a/test_aplK.py b/test_aplK.py index 12e54f3..639e363 100644 --- a/test_aplK.py +++ b/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") + ############################################# diff --git a/test_minimal_model.py b/test_minimal_model.py index 536f2f1..2d1b594 100644 --- a/test_minimal_model.py +++ b/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) diff --git a/test_primitive.py b/test_primitive.py index f4a2093..2c0376d 100644 --- a/test_primitive.py +++ b/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]