python-sat 1.9.dev10__tar.gz → 1.9.dev12__tar.gz

{python_sat-1.9.dev10/python_sat.egg-info → python_sat-1.9.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev10
+Version: 1.9.dev12
 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.dev10 → python_sat-1.9.dev12}/pysat/__init__.py

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

{python_sat-1.9.dev10 → python_sat-1.9.dev12}/pysat/formula.py

@@ -972,7 +972,7 @@ class Formula(object):
                 return ('identity', type(obj), id(obj))
             return ('obj', type(obj), obj)
 
-        def _formula_key(form):
+        def _formula_key_uncached(form):
             """
                 Get a structural key without a formula's merge flag.
             """
@@ -1001,6 +1001,21 @@ class Formula(object):
             counts = collections.Counter(_formula_key(subform) for subform in form.subformulas)
             return (form.type, frozenset(counts.items()))
 
+        def _formula_key(form):
+            """
+                Get a cached structural key for an immutable formula.
+            """
+
+            if isinstance(form, Formula):
+                key = getattr(form, '_key_cache', None)
+                if key is None:
+                    key = _formula_key_uncached(form)
+                    form._key_cache = key
+
+                return key
+
+            return _formula_key_uncached(form)
+
         def _merged_operands(operands, formula_type):
             """Flatten same-type operands for a merged connective."""
             result = []
@@ -1783,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
@@ -1799,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])

{python_sat-1.9.dev10 → python_sat-1.9.dev12/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev10
+Version: 1.9.dev12
 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.dev10 → python_sat-1.9.dev12}/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,11 @@ 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]])

{python_sat-1.9.dev10 → python_sat-1.9.dev12}/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 == []