python-sat 1.9.dev11__tar.gz → 1.9.dev13__tar.gz

{python_sat-1.9.dev11/python_sat.egg-info → python_sat-1.9.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev11
+Version: 1.9.dev13
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

{python_sat-1.9.dev11 → python_sat-1.9.dev13}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 9, 'dev', 11)
+VERSION = (1, 9, 'dev', 13)
 
 
 # PEP440 Format

{python_sat-1.9.dev11 → python_sat-1.9.dev13}/pysat/formula.py

@@ -1798,10 +1798,10 @@ class And(Formula):
             the subformulas expanding self's list of clauses and also
             populates self's clauses with unit clauses, each containing the
             auxiliary "name" of the corresponding subformula, thus
-            representing their conjunction. However, nested :class:`And` and
-            :class:`CNF` formulas are expanded without introducing
-            intermediate Boolean names - instead, they contribute their
-            clausal representations to the list of self's clauses unchanged.
+            representing their conjunction. However, :class:`CNF` formulas
+            are expanded without introducing an intermediate Boolean name -
+            instead, they contribute their clausal representations to the
+            list of self's clauses unchanged.
 
             If ``name_required`` is set to ``True``, the method introduces one
             name for the complete conjunction and encodes the equivalence
@@ -1814,13 +1814,13 @@ class And(Formula):
         save_clauses = bool(self.clauses)
 
         if not self.clauses:
-            # recursively collect a clausal representation; nested `And` and
-            # `CNF` objects are conjunctions already, so they do not need a
-            # Boolean name at this level.
+            # recursively collect a clausal representation; CNF objects are
+            # already clausal, so they do not need a Boolean name at this
+            # level
             for sub in self.subformulas:
-                if type(sub) in (And, CNF):
+                if type(sub) is CNF:
                     sub._clausify(name_required=False)
-                    self.clauses.extend(clause.copy() for clause in sub.clauses)
+                    self.clauses.extend(cl.copy() for cl in sub.clauses)
                 else:
                     sub._clausify(name_required=True)
                     self.clauses.append([sub.name])
@@ -2994,8 +2994,10 @@ class XOr(Formula):
                 f2 = Formula._vpool[Formula._context].obj(n2)
                 final = XOr(f1, f2)
 
-                final.name = Formula._vpool[Formula._context].id(final)
-                self.name = final.name
+                # the new name will be shared between the n-ary XOr and the
+                # final binary XOr
+                self.name = Formula._vpool[Formula._context].id(self)
+                final.name = self.name
             else:
                 self.name = Formula._vpool[Formula._context].id(self)
                 final = None

{python_sat-1.9.dev11 → python_sat-1.9.dev13/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev11
+Version: 1.9.dev13
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

{python_sat-1.9.dev11 → python_sat-1.9.dev13}/tests/test_clausification.py

@@ -1,4 +1,4 @@
-from pysat.formula import Atom, Formula, And, Or, Neg, XOr
+from pysat.formula import Atom, Formula, And, CNF, Or, Neg, XOr
 
 
 def compare(a, b):
@@ -37,6 +37,23 @@ def test_clausification():
     f = And(Atom('1'), Atom('2'))
     compare(list(f), [[1], [2]])
 
-    # nested conjunctions are inherited directly by the outer conjunction
+    # nested conjunctions retain their own auxiliary name
     g = And(f, Atom('3'))
-    compare(list(g), [[1], [2], [3]])
+    compare(list(g), [[1, -3], [2, -3], [3, -1, -2], [3], [4]])
+
+    # CNF operands are inherited directly by the outer conjunction
+    Formula.cleanup()
+    h = And(CNF(from_clauses=[[1, 2], [-1, 3]]), Atom('4'))
+    compare(list(h), [[1, 2], [-1, 3], [4]])
+
+
+def test_nary_xor_name_is_registered():
+    Formula.cleanup()
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+    xor = XOr(x, y, z)
+    formula = And(xor, Atom('w'))
+    formula.clausify()
+
+    vpool = Formula.export_vpool()
+    assert vpool.id(xor) == xor.name
+    assert vpool.obj(xor.name) is xor

{python_sat-1.9.dev11 → python_sat-1.9.dev13}/tests/test_formula_unique.py

@@ -62,10 +62,34 @@ def test_ite_uniqueness():
 def test_cnf_as_and_subformula():
     Formula.cleanup()
     cnf = CNF(from_clauses=[[-1, 2], [3]])
-    formula = And(And(cnf, Atom(4)), Atom(5))
+    subf = And(cnf, Atom(4))
+    form = And(subf, Atom(5))
+
+    # the CNF is flattened into its immediate And operand, while the
+    # unmerged nested And retains its own auxiliary name
+    assert list(form) == [[1, 6], [-2, 6], [-1, 2, -6],
+                             [6, -7], [3, -7], [4, -7],
+                             [7, -6, -3, -4], [7], [5]]
+    assert form.name is None
+    assert subf.name == 7
+    assert cnf.name is None
+    assert cnf.encoded == []
+
 
-    assert list(formula) == [[-1, 2], [3], [4], [5]]
-    assert formula.name is None
+def test_merged_and_with_cnf_subformula():
+    Formula.cleanup()
+    cnf = CNF(from_clauses=[[-1, 2], [3]])
+    subf = And(cnf, Atom(4))
+    form = And(subf, Atom(5), merge=True)
+
+    # Merging removes the nested And boundary. When the merged formula is
+    # used as a subformula, it therefore gets exactly one gate name.
+    assert list(Or(form, Atom(6))) == [[1, 7], [-2, 7], [-1, 2, -7],
+                                       [7, -8], [3, -8], [4, -8],
+                                       [5, -8], [8, -7, -3, -4, -5],
+                                       [8, 6]]
+    assert form.name == 8
+    assert subf.name is None
     assert cnf.name is None
     assert cnf.encoded == []