clingexplaid 1.2.0__tar.gz → 1.2.2__tar.gz

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clingexplaid
-Version: 1.2.0
+Version: 1.2.2
 Summary: Tools to aid the development of explanation systems using clingo
 Author-email: Hannes Weichelt <hweichelt@uni-potsdam.de>, Susana Hahn <susuhahnml@yahoo.com.mx>
 Maintainer-email: Hannes Weichelt <hweichelt@uni-potsdam.de>

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/src/clingexplaid/mus/core_computer.py

@@ -2,9 +2,11 @@
 MUS Module: Core Computer to get Minimal Unsatisfiable Subsets
 """
 
+import asyncio
 import warnings
+from dataclasses import dataclass
 from itertools import chain, combinations
-from typing import Dict, Generator, List, Optional, Set, Tuple
+from typing import Dict, Generator, Iterable, Iterator, List, Optional, Set, Tuple, Union
 
 import clingo
 
@@ -12,6 +14,17 @@ from ..utils import get_solver_literal_lookup
 from ..utils.types import Assumption, AssumptionSet, SymbolSet
 
 
+@dataclass
+class UnsatisfiableSubset:
+    """Container class for unsatisfiable subsets"""
+
+    assumptions: Set[Assumption]
+    minimal: bool = False
+
+    def __iter__(self) -> Iterator[Union[tuple[clingo.Symbol, bool], int]]:
+        return self.assumptions.__iter__()
+
+
 class CoreComputer:
     """
     A container class that allows for a passed program_string and assumption_set to compute a minimal unsatisfiable
@@ -22,7 +35,9 @@ class CoreComputer:
         self.control = control
         self.assumption_set = assumption_set
         self.literal_lookup = get_solver_literal_lookup(control=self.control)
-        self.minimal: Optional[AssumptionSet] = None
+        self.minimal: Optional[UnsatisfiableSubset] = None
+        self._assumptions_minimal: Set[Assumption] = set()
+        self._assumptions_removed: Set[Assumption] = set()
 
     def _solve(self, assumptions: Optional[AssumptionSet] = None) -> Tuple[bool, SymbolSet, SymbolSet]:
         """
@@ -38,7 +53,7 @@ class CoreComputer:
 
         return satisfiable, set(model), core
 
-    def _compute_single_minimal(self, assumptions: Optional[AssumptionSet] = None) -> AssumptionSet:
+    async def _compute_single_minimal(self, assumptions: Optional[AssumptionSet] = None) -> UnsatisfiableSubset:
         """
         Function to compute a single minimal unsatisfiable subset from the passed set of assumptions and the program of
         the CoreComputer. If there is no minimal unsatisfiable subset, since for example the program with assumptions
@@ -48,6 +63,9 @@ class CoreComputer:
         if assumptions is None:
             assumptions = self.assumption_set
 
+        # Reset progress set
+        self._assumptions_minimal = set()
+
         # check that the assumption set isn't empty
         if not assumptions:
             warnings.warn("A minimal unsatisfiable subset cannot be computed on an empty assumption set")
@@ -56,37 +74,62 @@ class CoreComputer:
         # rest of the algorithm and return an empty set.
         satisfiable, _, _ = self._solve(assumptions=assumptions)
         if satisfiable:
-            return set()
+            return UnsatisfiableSubset(set())
 
-        mus_members: Set[Assumption] = set()
         working_set = set(assumptions)
 
         for assumption in assumptions:
             # remove the current assumption from the working set
             working_set.remove(assumption)
 
-            satisfiable, _, _ = self._solve(assumptions=working_set.union(mus_members))
+            satisfiable, _, _ = self._solve(assumptions=working_set.union(self._assumptions_minimal))
             # if the working set now becomes satisfiable without the assumption it is added to the mus_members
             if satisfiable:
-                mus_members.add(assumption)
+                self._assumptions_minimal.add(assumption)
                 # every time we discover a new mus member we also check if all currently found mus members already
                 # suffice to make the instance unsatisfiable. If so we can stop the search sice we found our mus.
-                if not self._solve(assumptions=mus_members)[0]:
+                if not self._solve(assumptions=self._assumptions_minimal)[0]:
                     break
-
-        return mus_members
-
-    def shrink(self, assumptions: Optional[AssumptionSet] = None) -> AssumptionSet:
+            else:
+                # Remove the current assumption since it's not part of the mus
+                self._assumptions_removed.add(assumption)
+
+            # Do a very short wait every time to allow for async timeout interruption
+            await asyncio.sleep(0.0000001)
+
+        return UnsatisfiableSubset(self._assumptions_minimal, minimal=True)
+
+    async def _shrink_unsatisfiable_subset(
+        self, assumptions: Optional[AssumptionSet] = None, timeout: Optional[float] = None
+    ) -> UnsatisfiableSubset:
+        timeout_occurred = False
+        try:
+            await asyncio.wait_for(self._compute_single_minimal(assumptions=assumptions), timeout=timeout)
+            unsat_subset = self._assumptions_minimal
+        except TimeoutError:
+            timeout_occurred = True
+            warnings.warn(
+                "Timeout encountered while computing unsatisfiable subset, "
+                "intermediate unsatisfiable subset is returned"
+            )
+            # Remove the already excluded assumptions from the original set and return them
+            provided_assumptions = set(assumptions) if assumptions is not None else set(self.assumption_set)
+            unsat_subset = provided_assumptions.difference(self._assumptions_removed)
+        return UnsatisfiableSubset(unsat_subset, minimal=not timeout_occurred)
+
+    def shrink(
+        self, assumptions: Optional[AssumptionSet] = None, timeout: Optional[float] = None
+    ) -> UnsatisfiableSubset:
         """
         This function applies the unsatisfiable subset minimization (`self._compute_single_minimal`) on the assumptions
         set `assumptions` and stores the resulting MUS inside `self.minimal`.
 
         Returns the MUS as a set of assumptions.
         """
-        self.minimal = self._compute_single_minimal(assumptions=assumptions)
+        self.minimal = asyncio.run(self._shrink_unsatisfiable_subset(assumptions=assumptions, timeout=timeout))
         return self.minimal
 
-    def get_multiple_minimal(self, max_mus: Optional[int] = None) -> Generator[AssumptionSet, None, None]:
+    def get_multiple_minimal(self, max_mus: Optional[int] = None) -> Generator[UnsatisfiableSubset, None, None]:
         """
         This function generates all minimal unsatisfiable subsets of the provided assumption set. It implements the
         generator pattern since finding all mus of an assumption set is exponential in nature and the search might not
@@ -112,7 +155,7 @@ class CoreComputer:
             if any(set(muc).issubset(current_subset) for muc in found_mucs):
                 continue
 
-            muc = self._compute_single_minimal(assumptions=current_subset)
+            muc = asyncio.run(self._compute_single_minimal(assumptions=current_subset))
 
             # if the current subset wasn't unsatisfiable store this info and continue
             if len(list(muc)) == 0:
@@ -127,7 +170,11 @@ class CoreComputer:
                 if max_mus is not None and len(found_mucs) == max_mus:
                     break
 
-    def mus_to_string(self, muc: AssumptionSet, literal_lookup: Optional[Dict[int, clingo.Symbol]] = None) -> Set[str]:
+    def mus_to_string(
+        self,
+        muc: Iterable[Union[Tuple[clingo.Symbol, bool], int]],
+        literal_lookup: Optional[Dict[int, clingo.Symbol]] = None,
+    ) -> Set[str]:
         """
         Converts a MUS into a set containing the string representations of the contained assumptions
         """

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/src/clingexplaid/transformers/transformer_rule_id.py

@@ -55,7 +55,7 @@ class RuleIDTransformer(_ast.Transformer):
         out = []
         _ast.parse_string(string, lambda stm: out.append((str(self(stm)))))
         out.append(
-            f"{{_rule(1..{self._get_number_of_rules()})}}"
+            f"{{_rule(1..{self._get_number_of_rules()})}}."
             f" % Choice rule to allow all _rule atoms to become assumptions"
         )
 

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/src/clingexplaid.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clingexplaid
-Version: 1.2.0
+Version: 1.2.2
 Summary: Tools to aid the development of explanation systems using clingo
 Author-email: Hannes Weichelt <hweichelt@uni-potsdam.de>, Susana Hahn <susuhahnml@yahoo.com.mx>
 Maintainer-email: Hannes Weichelt <hweichelt@uni-potsdam.de>

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/tests/clingexplaid/res/transformed_program_rule_ids.lp

@@ -6,4 +6,4 @@ d((10..15)) :- _rule(4).
 e(16) :- _rule(5).
 f(17); f(18) :- e(16); _rule(6).
 x(19) :- _rule(7).
-{_rule(1..7)} % Choice rule to allow all _rule atoms to become assumptions
+{_rule(1..7)}. % Choice rule to allow all _rule atoms to become assumptions

{clingexplaid-1.2.0 → clingexplaid-1.2.2}/tests/clingexplaid/test_muc.py

@@ -2,6 +2,7 @@
 Tests for the mus package
 """
 
+import asyncio
 import random
 from typing import Iterable, List, Optional, Sequence, Set, Tuple, Union
 from unittest import TestCase
@@ -9,9 +10,9 @@ from unittest import TestCase
 import clingo
 
 from clingexplaid.mus import CoreComputer
+from clingexplaid.mus.core_computer import UnsatisfiableSubset
 from clingexplaid.transformers import AssumptionTransformer
 from clingexplaid.transformers.transformer_assumption import FilterPattern, FilterSignature
-from clingexplaid.utils.types import AssumptionSet
 
 from .test_main import TEST_DIR
 
@@ -20,7 +21,8 @@ def get_mus_of_program(
     program_string: str,
     assumption_filters: Optional[Iterable[Union[FilterPattern, FilterSignature]]] = None,
     control: Optional[clingo.Control] = None,
-) -> Tuple[AssumptionSet, CoreComputer]:
+    timeout: Optional[float] = None,
+) -> Tuple[UnsatisfiableSubset, CoreComputer]:
     """
     Helper function to directly get the MUS of a given program string.
     """
@@ -43,12 +45,12 @@ def get_mus_of_program(
     cc = CoreComputer(ctl, assumptions)
 
     def shrink_on_model(core: Sequence[int]) -> None:
-        _ = cc.shrink(core)
+        _ = cc.shrink(core, timeout=timeout)
 
     ctl.solve(assumptions=list(assumptions), on_core=shrink_on_model)
 
     # if the instance was satisfiable and the on_core function wasn't called an empty set is returned, else the mus.
-    result = cc.minimal if cc.minimal is not None else set()
+    result = cc.minimal if cc.minimal is not None else UnsatisfiableSubset(set())
 
     return result, cc
 
@@ -178,6 +180,25 @@ class TestMUS(TestCase):
             self.fail()
         self._assert_mus(cc.mus_to_string(mus), [{f"a({i})" for i in random_core}])
 
+    def test_core_computer_shrink_timeout(self) -> None:
+        """
+        Test the CoreComputer's `shrink` function with a satisfiable assumption set.
+        """
+
+        ctl = clingo.Control()
+
+        n_assumptions = 3000
+        random_core = random.choices(range(1, n_assumptions), k=500)
+        program = f"""
+                    a(1..{n_assumptions}).
+                    :- {', '.join([f"a({i})" for i in random_core])}.
+                    """
+        filters = {FilterSignature("a", 1)}
+
+        mus, _ = get_mus_of_program(program_string=program, assumption_filters=filters, control=ctl, timeout=1)
+
+        self.assertEqual(mus.minimal, False)
+
     def test_core_computer_shrink_satisfiable(self) -> None:
         """
         Test the CoreComputer's `shrink` function with a satisfiable assumption set.
@@ -192,7 +213,7 @@ class TestMUS(TestCase):
 
         mus, _ = get_mus_of_program(program_string=program, assumption_filters=filters, control=ctl)
 
-        self.assertEqual(mus, set())
+        self.assertEqual(mus, UnsatisfiableSubset(set()))
 
     def test_core_computer_get_multiple_minimal(self) -> None:
         """
@@ -265,8 +286,8 @@ class TestMUS(TestCase):
         control.ground([("base", [])])
         assumptions = {(clingo.parse_term(c), True) for c in "abc"}
         cc = CoreComputer(control, assumptions)
-        mus = cc._compute_single_minimal()  # pylint: disable=W0212
-        self.assertEqual(mus, set())
+        mus = asyncio.run(cc._compute_single_minimal())  # pylint: disable=W0212
+        self.assertEqual(mus, UnsatisfiableSubset(set()))
 
     def test_core_computer_internal_compute_single_minimal_no_assumptions(self) -> None:
         """
@@ -276,7 +297,8 @@ class TestMUS(TestCase):
         control = clingo.Control()
         cc = CoreComputer(control, set())
         # Disabled exception assertion due to change in error handling
-        # self.assertRaises(ValueError, cc._compute_single_minimal)  # pylint: disable=W0212
+        mus = asyncio.run(cc._compute_single_minimal(assumptions=None))  # pylint: disable=W0212
+        self.assertEqual(mus, UnsatisfiableSubset(set()))
         cc.shrink([])
 
     def test_core_computer_mus_to_string(self) -> None: