python-sat 1.8.dev18__tar.gz → 1.8.dev19__tar.gz

{python-sat-1.8.dev18/python_sat.egg-info → python_sat-1.8.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev18
+Version: 1.8.dev19
 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.8.dev18 → python_sat-1.8.dev19}/examples/bica.py

@@ -51,7 +51,7 @@
     navigation to determine the Southern Celestial Pole.)
 
     .. [1] Alexey Ignatiev, Alessandro Previti, Joao Marques-Silva.
-        *SAT-Based Formula Simplification*. SAT 2015. pp. 287-298
+        *SAT-Based Formula Simplification*. SAT 2015. pp. 287-298
 
     .. [2] Willard V. Quine. *The Problem of Simplifying Truth Functions*.
         American Mathematical Monthly 59(8). 1952. pp. 521-531
@@ -262,10 +262,10 @@ class Bica:
 
     """
 
-    def __init__(self, formula, negated=None, target='cnf', psolver='g3',
+    def __init__(self, formula, negated=None, target='cnf', psolver='cd19',
                  padapt=False, pdcalls=False, pexhaust=False, pminz=False,
                  ppuresat=False, psearch='lin', punsorted=False, ptrim=False,
-                 osolver='g3', oadapt=False, odcalls=False, oexhaust=False,
+                 osolver='mgh', oadapt=False, odcalls=False, oexhaust=False,
                  ominz=False, onodisj=False, opuresat=False, ounsorted=False,
                  otrim=False, weighted=False, verbose=0):
         """
@@ -538,7 +538,7 @@ def parse_options():
     ominz = False
     nodisj = False
     psolver = 'cd19'
-    osolver = 'cd19'
+    osolver = 'mgh'
     ppuresat = False
     opuresat = False
     punsorted = False
@@ -638,7 +638,7 @@ def usage():
     print('        -s, --psolver              SAT solver to use [Primer]')
     print('                                   Available values: cd, cd15, cd19, g3, g41, g42, lgl, mcb, mcm, mpl, m22, mc, mg3, mgh (default = cd19)')
     print('        -S, --osolver              SAT solver to use [OptUx]')
-    print('                                   Available values: cd, cd15, cd19, g3, g41, g42, lgl, mcb, mcm, mpl, m22, mc, mg3, mgh (default = cd19)')
+    print('                                   Available values: cd, cd15, cd19, g3, g41, g42, lgl, mcb, mcm, mpl, m22, mc, mg3, mgh (default = mgh)')
     print('        -t, --ptrim=<int>          How many times to trim unsatisfiable cores [Primer]')
     print('                                   Available values: [0 .. INT_MAX] (default = 0)')
     print('        -T, --otrim=<int>          How many times to trim unsatisfiable cores [OptUx]')

{python-sat-1.8.dev18 → python_sat-1.8.dev19}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 8, 'dev', 18)
+VERSION = (1, 8, 'dev', 19)
 
 
 # PEP440 Format

{python-sat-1.8.dev18 → python_sat-1.8.dev19}/pysat/formula.py

@@ -879,45 +879,26 @@ class Formula(object):
             if type(collection) in (tuple, list, set):
                 collection = tuple(filter(lambda x: x or x == False, collection))
 
-                if len(collection) > 1:
-                    if _hashable(collection):
-                        # it is a hashable iterable; it is better to sort it
-                        items.append((prefix, repr(sorted(collection, key=lambda x: hash(x)))))
+                for item in collection:
+                    if isinstance(item, Iterable):
+                        items.extend(_flatten(item, prefix=prefix))
                     else:
-                        for i, item in enumerate(collection):
-                            if _hashable(item):
-                                # it is a hashable iterable; it is better to sort it
-                                if isinstance(item, Iterable):
-                                    item = sorted(item, key=lambda x: hash(x))
-
-                                items.append((prefix, repr(item)))
-                            elif isinstance(item, Iterable):
-                                items.extend(_flatten(item, prefix=prefix))
-                            else:
-                                raise FormulaError('No key can be computed for this formula object')
-                elif collection:
-                    items.extend(_flatten(collection[0], prefix=prefix))
+                        items.append((prefix, item))
 
             # next, checking if it is a dictionary
             elif isinstance(collection, dict):
                 for key in collection.keys():
                     value = collection[key]
                     new_key = prefix + sep + key if prefix else key
-                    if value and _hashable(value):
-                        # it is a hashable iterable; it is better to sort it
-                        if isinstance(value, Iterable):
-                            value = sorted(value, key=lambda x: hash(x))
-
-                        items.append((new_key, repr(value)))
-                    elif isinstance(value, Iterable):
-                        if value:
-                            items.extend(_flatten(value, new_key, sep=sep))
+                    if isinstance(value, Iterable) and value:
+                        items.extend(_flatten(value, prefix=new_key, sep=sep))
                     else:
-                        raise FormulaError('No key can be computed for this formula object')
+
+                        items.append((new_key, value))
 
             # finally, it is a simple non-empty object
             elif collection or collection == False:
-                items.append((prefix, repr(collection)))
+                items.append((prefix, collection))
 
             return items
 
@@ -929,46 +910,68 @@ class Formula(object):
                 args[0] = tuple(args[0][1:])
 
         # flattening all the inputs
-        key = _flatten(args) + _flatten(kwargs)
-
-        # we can arguments with but also without keywords:
-        if len(key) == 2 and key[0][0] == '':
-            # there are two components in the key and the first one is unnamed
-            # this can happen for Atom or Neg and it so we name it accordingly
-            key[0] = ('object' if key[1][1] == repr(FormulaType.ATOM) else 'subformula', key[0][1])
-        elif len(key) == 3 and key[2][1] == repr(FormulaType.IMPL):
-            if key[0][0] == '' and key[1][0] == '':
-                key[0] = ('left', key[0][1])
-                key[1] = ('right', key[1][1])
-            elif key[1][0] == 'left':
-                key[0] = ('right', key[0][1])
-            elif key[1][0] == 'right':
-                key[0] = ('left', key[0][1])
-        elif len(key) == 4 and key[3][1] == repr(FormulaType.ITE):
-            # dealing with ITE triples - the most complicated case
-            if key[0][0] == '' and key[1][0] == '' and key[2][0] == '':
-                key[0] = ('cond', key[0][1])
-                key[1] = ('cons1', key[1][1])
-                key[2] = ('cons2',  key[2][1])
-            elif key[0][0] == key[1][0] == '':
-                if key[2][0] == 'cond':
-                    key[0] = ('cons1', key[0][1])
-                    key[1] = ('cons2', key[1][1])
-                elif key[2][0] == 'cons1':
-                    key[0] = ('cond',  key[0][1])
-                    key[1] = ('cons2', key[1][1])
-                elif key[2][0] == 'cons2':
-                    key[0] = ('cond',  key[0][1])
-                    key[1] = ('cons1', key[1][1])
-            elif key[0] == '':
-                if 'cond' not in (key[1][0], key[2][0]):
-                    key[0] = ('cond', key[0][0])
-                elif 'cons1' not in (key[1][0], key[2][0]):
-                    key[0] = ('cons1', key[0][0])
-                elif 'cons2' not in (key[1][0], key[2][0]):
-                    key[0] = ('cons2', key[0][0])
-
-        return tuple(sorted(key))
+        items = _flatten(args) + _flatten(kwargs)
+        ftype, subfs, extra = None, [], []
+
+        # ignoring everything except subformulas and the type
+        for item in items:
+            if item[0] == 'type':
+                ftype = item
+            elif item[0] != 'merge':
+                subfs.append(item)
+            else:
+                extra = [('merge', repr(item[1]))]
+
+        # the ugly part:
+        # reconstructing the key pairs, depending on the type of Formula
+        if ftype[1] == FormulaType.ATOM:
+            assert len(subfs) == 1, 'A single object is required for an Atom formula'
+            subfs[0] = ('object', repr(subfs[0][1]))
+        elif ftype[1] == FormulaType.NEG:
+            assert len(subfs) == 1, 'A single subformula is required for a Neg formula'
+            subfs[0] = ('subformula', id(subfs[0][1]))
+        elif ftype[1] == FormulaType.IMPL:
+            assert len(subfs) == 2, 'Two subformulas are required for an Implies formula'
+            if subfs[0][0] == '' and subfs[1][0] == '':
+                subfs[0] = ('left', id(subfs[0][1]))
+                subfs[1] = ('right', id(subfs[1][1]))
+            elif subfs[1][0] == 'left':
+                subfs[0] = ('right', id(subfs[0][1]))
+            elif subfs[1][0] == 'right':
+                subfs[0] = ('left', id(subfs[0][1]))
+        elif ftype[1] == FormulaType.ITE:
+            assert len(subfs) == 3, 'Three subformulas are required for an ITE formula'
+            if subfs[0][0] == '' and subfs[1][0] == '' and subfs[2][0] == '':
+                subfs[0] = ('cond', id(subfs[0][1]))
+                subfs[1] = ('cons1', id(subfs[1][1]))
+                subfs[2] = ('cons2',  id(subfs[2][1]))
+            elif subfs[0][0] == subfs[1][0] == '':
+                if subfs[2][0] == 'cond':
+                    subfs[0] = ('cons1', id(subfs[0][1]))
+                    subfs[1] = ('cons2', id(subfs[1][1]))
+                elif subfs[2][0] == 'cons1':
+                    subfs[0] = ('cond',  id(subfs[0][1]))
+                    subfs[1] = ('cons2', id(subfs[1][1]))
+                elif subfs[2][0] == 'cons2':
+                    subfs[0] = ('cond',  id(subfs[0][1]))
+                    subfs[1] = ('cons1', id(subfs[1][1]))
+            elif subfs[0] == '':
+                if 'cond' not in (subfs[1][0], subfs[2][0]):
+                    subfs[0] = ('cond', id(subfs[0][0]))
+                elif 'cons1' not in (subfs[1][0], subfs[2][0]):
+                    subfs[0] = ('cons1', id(subfs[0][0]))
+                elif 'cons2' not in (subfs[1][0], subfs[2][0]):
+                    subfs[0] = ('cons2', id(subfs[0][0]))
+        else:
+            # these are commutative connectives; we need to sort the arguments
+            assert len(subfs) >= 1, 'At least one subformula is required for an And/Equals/Or/XOr formula'
+            subfs = sorted(map(lambda p: (p[0], repr(id(p[1]))), subfs))
+
+            if not extra:
+                extra = [('merge', repr(False))]
+
+        # the key is a string combining all the parts
+        return ' '.join([f'{repr(p[0])}:{repr(p[1])}' for p in [ftype] + subfs + extra])
 
     def __hash__(self):
         """
@@ -1126,7 +1129,7 @@ class Formula(object):
             b)``.
         """
 
-        return XOr(self, other)
+        return XOr(self, other, merge=True)
 
     def __ixor__(self, other):
         """
@@ -1135,7 +1138,7 @@ class Formula(object):
             ``a`` to a new object ``XOr(a, b)``.
         """
 
-        return XOr(self, other)
+        return XOr(self, other, merge=True)
 
     def __iter__(self):
         """
@@ -1547,7 +1550,7 @@ class And(Formula):
             "And[And[Atom('x'), Atom('y')], Atom('z')]"
             >>> repr(a2)
             "And[Atom('x'), Atom('y'), Atom('z')]"
-            >>> repr(a2)
+            >>> repr(a3)
             "And[Atom('x'), Atom('y'), Atom('z')]"
             >>>
             >>> id(a1) == id(a2)
@@ -2648,8 +2651,9 @@ class XOr(Formula):
     def __init__(self, *args, **kwargs):
         """
             Initialiser. Expects a list of arguments signifying the operands
-            of the equivalence. Additionally, a user may set a keyword
-            argument ``merge=True``, which will enable merging sub-operands.
+            of the exclusive disjunction. Additionally, a user may set a
+            keyword argument ``merge=True``, which will enable merging
+            sub-operands.
         """
 
         super(XOr, self).__init__(type=FormulaType.XOR)
@@ -2663,7 +2667,7 @@ class XOr(Formula):
             self.merged = False
 
         if len(self.subformulas) < 2:
-            raise FormulaError('Equivalence requires at least 2 arguments')
+            raise FormulaError('XOr requires at least 2 arguments')
 
     def __del__(self):
         """

{python-sat-1.8.dev18 → python_sat-1.8.dev19/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev18
+Version: 1.8.dev19
 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.8.dev19/tests/test_formula_unique.py

@@ -0,0 +1,101 @@
+from pysat.formula import *
+from itertools import permutations
+
+def test_atom_uniqueness():
+    x1, x2 = Atom('x'), Atom(object='x')  # same atom
+    z = Atom('z')                  # a different atom
+
+    assert x1 is x2, 'Atoms should be the same object'
+    assert x1 is not z, 'Atoms should be different objects'
+
+def test_2and_uniqueness():
+    x1, x2 = Atom('x'), Atom('x')  # same atom
+    y = Atom('y')                  # a different atom
+
+    a = And(x1, y)
+    b = And(y, x1)
+    c = And(x2, y)
+    d = And(y, x2)
+
+    assert id(a) == id(b) == id(c) == id(d), 'All 2-and\'s should be the same object'
+
+def test_3and_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = And(x, y, z)
+
+    for comb in permutations([x, y, z]):
+        assert And(*comb) is a, 'All 3-and\'s should be the same object'
+        assert And(comb) is a, 'All 3-and\'s should be the same object'
+
+def test_3or_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = Or(x, y, z)
+
+    for comb in permutations([x, y, z]):
+        assert Or(*comb) is a, 'All 3-and\'s should be the same object'
+        assert Or(comb) is a, 'All 3-and\'s should be the same object'
+
+def test_impl_uniqueness():
+    x, y = Atom('x'), Atom('y')
+
+    a = x >> y
+    b = y >> x
+
+    a2 = Implies(x, y)
+
+    assert a is a2, 'Non-unique implication is detected'
+    assert a is not b, 'Implication is not commutative'
+
+def test_ite_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = ITE(x, y, z)
+
+    for comb in permutations([x, y, z]):
+        if comb == (x, y, z):
+            continue
+
+        assert ITE(*comb) is not a, 'ITE is not commutative'
+
+def test_xor_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = XOr(x, y, z, merge=True)
+    b = XOr(x, y, z, merge=False)
+
+    for comb in permutations([x, y, z]):
+        assert XOr(*comb, merge=True) is a, 'All 3-xor\'s should be the same object'
+
+    for comb in permutations([x, y, z]):
+        assert XOr(*comb, merge=False) is b, 'All 3-xor\'s should be the same object'
+        assert XOr(*comb) is b, 'All 3-xor\'s should be the same object'
+
+def test_equals_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = Equals(x, y, z, merge=True)
+    b = Equals(x, y, z, merge=False)
+
+    for comb in permutations([x, y, z]):
+        assert Equals(*comb, merge=True) is a, 'All 3-equality\'s should be the same object'
+
+    for comb in permutations([x, y, z]):
+        assert Equals(*comb, merge=False) is b, 'All 3-equality\'s should be the same object'
+        assert Equals(*comb) is b, 'All 3-equality\'s should be the same object'
+
+def test_complex():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    f1 = XOr(x, y, z, merge=False)
+    g1 = Or(f1, z, x, merge=True)
+    h1 = And(y, g1, x, merge=True)
+
+    f2 = XOr(z, y, x, merge=False)
+    g2 = Or(x, f2, z, merge=True)
+    h2 = And(x, g2, y, merge=True)
+
+    assert f1 is f2, 'Complex uniqueness fail: step 1'
+    assert g1 is g2, 'Complex uniqueness fail: step 2'
+    assert h1 is h2, 'Complex uniqueness fail: step 3'

python-sat-1.8.dev18/tests/test_formula_unique.py

@@ -1,38 +0,0 @@
-from pysat.formula import *
-from itertools import permutations
-
-def test_atom_uniqueness():
-    x1, x2 = Atom('x'), Atom('x')  # same atom
-    z = Atom('z')                  # a different atom
-
-    assert x1 is x2, 'Atoms should be the same object'
-    assert x1 is not z, 'Atoms should be different objects'
-
-def test_2and_uniqueness():
-    x1, x2 = Atom('x'), Atom('x')  # same atom
-    y = Atom('y')                  # a different atom
-
-    a = And(x1, y)
-    b = And(y, x1)
-    c = And(x2, y)
-    d = And(y, x2)
-
-    assert id(a) == id(b) == id(c) == id(d), 'All 2-and\'s should be the same object'
-
-def test_3and_uniqueness():
-    x, y, z = Atom('x'), Atom('y'), Atom('z')
-
-    a = And(x, y, z)
-
-    for comb in permutations([x, y, z]):
-        assert And(*comb) is a, 'All 3-and\'s should be the same object'
-        assert And(comb) is a, 'All 3-and\'s should be the same object'
-
-def test_3or_uniqueness():
-    x, y, z = Atom('x'), Atom('y'), Atom('z')
-
-    a = Or(x, y, z)
-
-    for comb in permutations([x, y, z]):
-        assert Or(*comb) is a, 'All 3-and\'s should be the same object'
-        assert Or(comb) is a, 'All 3-and\'s should be the same object'