mpbn 3.1.1__tar.gz → 4.3__tar.gz

{mpbn-3.1.1 → mpbn-4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mpbn
-Version: 3.1.1
+Version: 4.3
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé
@@ -11,9 +11,26 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Description-Content-Type: text/markdown
-
-
-The `mpbn` Python module offers a simple implementation of reachability and attractor analysis (minimal trap spaces) in *Most Permissive Boolean Networks* ([doi:10.1038/s41467-020-18112-5](https://doi.org/10.1038/s41467-020-18112-5)).
+Requires-Dist: boolean.py
+Requires-Dist: clingo
+Requires-Dist: colomoto_jupyter>=0.8.0
+Requires-Dist: numpy
+Requires-Dist: biodivine_aeon>=1.0.1
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+
+The `mpbn` Python module offers a simple implementation of reachability and attractor analysis (minimal trap spaces) in *Most Permissive Boolean Networks* ([doi:10.1038/s41467-020-18112-5](https://doi.org/10.1038/s41467-020-18112-5)). The `mpbn` Python module also offers a *Most Permissive* simulator, which provides trajectory sampling and computes attractor propensities (see paper [Variable-Depth Simulation of Most Permissive Boolean Networks](https://link.springer.com/chapter/10.1007/978-3-031-15034-0_7) for more details).
 
 It is built on the `minibn` module from [colomoto-jupyter](https://github.com/colomoto/colomoto-jupyter) which allows importation of Boolean networks in many formats. See http://colomoto.org/notebook.
 
@@ -31,7 +48,7 @@ pip install mpbn
 
 ### Using conda
 ```
-conda install -c colomoto -c potassco mpbn
+conda install -c colomoto -c potassco -c daemontus mpbn
 ```
 
 ## Usage

{mpbn-3.1.1 → mpbn-4.3}/README.md

@@ -1,5 +1,5 @@
 
-The `mpbn` Python module offers a simple implementation of reachability and attractor analysis (minimal trap spaces) in *Most Permissive Boolean Networks* ([doi:10.1038/s41467-020-18112-5](https://doi.org/10.1038/s41467-020-18112-5)).
+The `mpbn` Python module offers a simple implementation of reachability and attractor analysis (minimal trap spaces) in *Most Permissive Boolean Networks* ([doi:10.1038/s41467-020-18112-5](https://doi.org/10.1038/s41467-020-18112-5)). The `mpbn` Python module also offers a *Most Permissive* simulator, which provides trajectory sampling and computes attractor propensities (see paper [Variable-Depth Simulation of Most Permissive Boolean Networks](https://link.springer.com/chapter/10.1007/978-3-031-15034-0_7) for more details).
 
 It is built on the `minibn` module from [colomoto-jupyter](https://github.com/colomoto/colomoto-jupyter) which allows importation of Boolean networks in many formats. See http://colomoto.org/notebook.
 
@@ -17,7 +17,7 @@ pip install mpbn
 
 ### Using conda
 ```
-conda install -c colomoto -c potassco mpbn
+conda install -c colomoto -c potassco -c daemontus mpbn
 ```
 
 ## Usage

{mpbn-3.1.1 → mpbn-4.3}/mpbn/__init__.py

@@ -1,7 +1,7 @@
 """
 This module provides a simple implementation of Most Permissive Boolean Networks
-(MPBNs) for computing reachability properties, attractors, and reachable
-attractors in locally-monotonic Boolean networks.
+(MPBNs) for computing reachability properties, attractors, reachable attractors.
+Attractors of MPBNs are the *minimal* trap spaces of the underlying Boolean maps.
 See http://dx.doi.org/10.1101/2020.03.22.998377 and https://arxiv.org/abs/1808.10240 for technical details.
 
 It relies on clingo Answer-Set Programming solver
@@ -15,7 +15,7 @@ Quick example:
         "a": "!b",
         "b": "!a",
         "c": "!a & b"})
->>> list(mbn.attractors())
+>>> list(mbn.attractors()) # minimal trap spaces
 [{'a': 0, 'b': 1, 'c': 1}, {'a': 1, 'b': 0, 'c': 0}]
 >>> mbn.reachability({'a': 0, 'b': 1, 'c': 1}, {'a': 1, 'b': 0, 'c': 0})
 False
@@ -31,9 +31,6 @@ from colomoto import minibn
 
 from boolean import boolean
 import clingo
-
-from pyeda.boolalg import bdd
-from pyeda.boolalg.expr import expr
 sys.setrecursionlimit(max(100000, sys.getrecursionlimit()))
 
 __asplibdir__ = os.path.realpath(os.path.join(os.path.dirname(__file__), "asplib"))
@@ -45,15 +42,21 @@ if hasattr(clingo, "version") and clingo.version() >= (5,5,0):
 def aspf(basename):
     return os.path.join(__asplibdir__, basename)
 
-def clingo_subsets(limit=0):
-    s = clingo.Control(clingo_options)
+def _clingo_domrec(mod, limit=0, project=False, extra_opts=[]):
+    s = clingo.Control(clingo_options + extra_opts)
     s.configuration.solve.models = limit
-    s.configuration.solve.project = 1
+    if project:
+        s.configuration.solve.project = 1
     s.configuration.solve.enum_mode = "domRec"
     s.configuration.solver[0].heuristic = "Domain"
-    s.configuration.solver[0].dom_mod = "5,16"
+    s.configuration.solver[0].dom_mod = f"{mod},{16 if project else 0}"
     return s
 
+def clingo_subsets(**opts):
+    return _clingo_domrec(5, **opts)
+def clingo_supsets(**opts):
+    return _clingo_domrec(3, **opts)
+
 def clingo_exists():
     s = clingo.Control(clingo_options)
     s.configuration.solve.models = 1
@@ -71,7 +74,8 @@ def s2v(s):
 def v2s(v):
     return 1 if v > 0 else 0
 
-def is_unate(ba, f):
+
+def is_dnf(ba, f, test_unate=False):
     pos_lits = set()
     neg_lits = set()
     def is_lit(f):
@@ -95,6 +99,8 @@ def is_unate(ba, f):
         return False
 
     def test_monotonicity():
+        if not test_unate:
+            return True
         both = pos_lits.intersection(neg_lits)
         return not both
 
@@ -109,33 +115,44 @@ def is_unate(ba, f):
         return test_monotonicity()
     return False
 
-def asp_of_bdd(bid, b):
-    _rules = dict()
-    def register(node, nid=None):
-        if node is bdd.BDDNODEONE:
-            if nid is not None:
-                _rules[bid] = f"bdd({clingo.String(nid)},1)"
-            return 1
-        elif node is bdd.BDDNODEZERO:
-            if nid is not None:
-                _rules[bid] = f"bdd({clingo.String(nid)},-1)"
-            return -1
-        nid = clingo.String(f"{bid}_n{id(node)}" if nid is None else nid)
-        if nid not in _rules:
-            var = clingo.String(bdd._VARS[node.root].qualname)
-            lo = register(node.lo)
-            hi = register(node.hi)
-            a = f"bdd({nid},{var},{lo},{hi})"
-            _rules[nid] = a
-        return nid
-    register(b.node, bid)
-    return _rules.values()
-
-def bddasp_of_boolfunc(f, i):
-    e = expr(str(f).replace("!","~"))
-    b = bdd.expr2bdd(e)
-    atoms = asp_of_bdd(i, b)
-    return "\n".join((f"{a}." for a in atoms))
+def is_dnf_unate(ba, f):
+    return is_dnf(ba, f, test_unate=True)
+
+def circuitasp_of_boolfunc(f, i, ba):
+    atoms = []
+    fid = clingo.String(i)
+    def encode(expr):
+        if expr == ba.TRUE:
+            nodeid = "(constant,1)"
+            atoms.append(f"circuit({nodeid}).")
+        elif expr == ba.FALSE:
+            nodeid = "(constant,-1)"
+            atoms.append(f"circuit({nodeid}).")
+        elif isinstance(expr, ba.Symbol):
+            nodeid = f"(var,{clingo.String(expr.obj)})"
+            atoms.append(f"circuit({fid},{nodeid}).")
+        else:
+            nodeid = f"n{id(expr)}"
+            if isinstance(expr, ba.NOT):
+                nodetype = "neg"
+            elif isinstance(expr, ba.AND):
+                nodetype = "and"
+            elif isinstance(expr, ba.OR):
+                nodetype = "or"
+            else:
+                raise NotImplementedError(type(expr))
+            atoms.append(f"circuit({fid},{nodeid},{nodetype}).")
+            for child in expr.args:
+                cid = encode(child)
+                atoms.append(f"circuitedge({fid},{nodeid},{cid}).")
+        return nodeid
+    root = encode(f)
+    atoms.append(f"circuit({fid},root,{root}).\n")
+    return "\n".join(atoms)
+
+DEFAULT_ENCODING = "mixed-dnf-bdd"
+DEFAULT_BOOLFUNCLIB = os.environ.get("MPBN_BOOLFUNCLIB", "pyeda")
+SUPPORTED_BOOLFUNCLIBS = ["aeon", "pyeda"]
 
 class MPBooleanNetwork(minibn.BooleanNetwork):
     """
@@ -143,17 +160,21 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
 
     Extends ``colomoto.minibn.BooleanNetwork`` class by adding methods for
     computing reachable and attractor properties with the Most Permissive
-    semantics.
-    It requires that the Boolean network is *locally monotonic*.
-
-    Ensures that the Boolean functions are monotonic and in disjunctive normal
-    form (DNF).
-    The local-monotonic checking requires that a literal never appears
-    with both signs in a same Boolean function.
+    update mode.
     """
+    supported_encodings = [
+            "unate-dnf", "bdd", "circuit",
+            "dnf-bdd", "mixed-dnf-bdd",
+            "force-unate-dnf"]
+    dnf_encodings = ["dnf-bdd", "unate-dnf", "force-unate-dnf",
+                        "mixed-dnf-bdd"]
+    nonpc_encodings = ["circuit"]
+
     def __init__(self, bn=minibn.BooleanNetwork(), auto_dnf=True,
-                        try_unate_hard=True,
-                        encoding="auto"):
+                        simplify=False,
+                        try_unate_hard=False,
+                        encoding=DEFAULT_ENCODING,
+                        boolfunclib=DEFAULT_BOOLFUNCLIB):
         """
         Constructor for :py:class:`.MPBoooleanNetwork`.
 
@@ -162,6 +183,9 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
             :py:class:`colomoto.minibn.BooleanNetwork` constructor
         :param bool auto_dnf: if ``False``, turns off automatic DNF
             transformation of local functions
+        :param str boolfunlib: library to use for Boolean function manipulation
+            among ``"aeon"`` (default) or ``"pyeda"``. Default can be overriden with
+            ``MPBN_BOOLFUNCLIB`` environment variable.
 
         Examples:
 
@@ -170,11 +194,22 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         >>> bn["a"] = ".."; ...
         >>> mbn = MPBooleanNetwork(bn)
         """
-        assert encoding in ["auto", "unate-dnf", "bdd"]
-        self.auto_dnf = auto_dnf and encoding != "bdd"
+        assert encoding in self.supported_encodings
+        assert boolfunclib in SUPPORTED_BOOLFUNCLIBS
+        self.auto_dnf = auto_dnf and encoding in self.dnf_encodings
         self.encoding = encoding
         self.try_unate_hard = try_unate_hard
+        self._simplify = simplify
         self._is_unate = dict()
+
+        self._boolfunclib = boolfunclib
+        __boolfunclib_symbols = (
+            "make_dnf_boolfunc",
+            "bddasp_of_boolfunc",
+            )
+        self._bf_impl = __import__(f"mpbn.boolfunclib.{boolfunclib}_impl",
+                                           fromlist=__boolfunclib_symbols)
+
         super(MPBooleanNetwork, self).__init__(bn)
 
     def __setitem__(self, a, f):
@@ -186,18 +221,21 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         if isinstance(f, str):
             f = self.ba.parse(f)
         f = self._autobool(f)
-        if self.auto_dnf:
-            f = self.ba.dnf(f).simplify()
-            if self.try_unate_hard:
-                f = minibn.simplify_dnf(self.ba, f)
+        if self.auto_dnf and (not is_dnf(self.ba, f) or self._simplify):
+            f = self._bf_impl.make_dnf_boolfunc(self.ba, f,
+                                simplify=self._simplify,
+                                try_unate_hard=self.try_unate_hard)
         a = self._autokey(a)
-        if self.encoding != "bdd":
-            self._is_unate[a] = is_unate(self.ba, f)
+        if self.encoding in self.dnf_encodings:
+            self._is_unate[a] = is_dnf_unate(self.ba, f)
             if self.encoding == "unate-dnf":
                 assert self._is_unate[a], f"'{f}' seems not unate. Try simplify()?"
         return super().__setitem__(a, f)
 
-    def asp_of_bn(self):
+    def asp_of_bn(self, encoding=None):
+        if encoding is None:
+            encoding = self.encoding
+
         def clauses_of_dnf(f):
             if isinstance(f, boolean.OR):
                 return f.args
@@ -221,36 +259,65 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         facts = []
         for n, f in self.items():
             facts.append("node(\"{}\").".format(n))
-            if self.encoding == "bdd":
-                f_encoding = "bdd"
-            elif self.encoding == "unate-dnf":
+            if encoding in ["unate-dnf", "force-unate-dnf"]:
                 f_encoding = "dnf"
-            else:
+            elif encoding == "dnf-bdd":
                 f_encoding = "dnf" if self._is_unate[n] else "bdd"
+            else:
+                f_encoding = encoding
             if f == self.ba.FALSE:
                 f = False
             elif f == self.ba.TRUE:
                 f = True
             if isinstance(f, bool):
-                facts.append(" constant(\"{}\",{}).".format(n, s2v(f)))
+                facts.append("constant(\"{}\",{}).".format(n, s2v(f)))
             elif f_encoding == "dnf":
                 facts.extend(encode_dnf(f))
             elif f_encoding == "bdd":
-                facts.append(bddasp_of_boolfunc(f, n))
+                facts.append(self._bf_impl.bddasp_of_boolfunc(self.ba, f, n))
+            elif f_encoding == "mixed-dnf-bdd":
+                facts.extend(encode_dnf(f))
+                if self._is_unate[n]:
+                    facts.append(f"unate(\"{n}\").")
+                else:
+                    facts.append(self._bf_impl.bddasp_of_boolfunc(self.ba, f, n))
+            elif f_encoding == "circuit":
+                facts.append(circuitasp_of_boolfunc(f, n, self.ba))
         return "".join(facts)
 
+    def _file_eval(self):
+        if self.encoding == "circuit":
+            f = aspf("eval_circuit.asp")
+        elif self.encoding == "mixed-dnf-bdd":
+            f = aspf("eval_mixed.asp")
+        else:
+            f = aspf("mp_eval.asp")
+        return f
+
+    def rules_eval(self):
+        f = self._file_eval()
+        with open(f, "r") as fp:
+            return fp.read()
+    def load_eval(self, solver):
+        f = self._file_eval()
+        solver.load(f)
+
+    def assert_pc_encoding(self):
+        assert self.encoding not in self.nonpc_encodings, "Unsupported encoding"
+
     def asp_of_cfg(self, e, t, c):
         facts = ["timepoint({},{}).".format(e,t)]
         facts += [" mp_state({},{},\"{}\",{}).".format(e,t,n,s2v(s))
                     for (n,s) in c.items()]
-        facts += [" 1 {{mp_state({},{},\"{}\",(-1;1))}} 1.".format(e,t,n)
-                        for n in self if n not in c]
+        facts += [f"1 {{mp_state({e},{t},N,(-1;1))}} 1 :- node(N)."]
+        #facts += [" 1 {{mp_state({},{},\"{}\",(-1;1))}} 1 :- node(N).".format(e,t,n)
+        #                for n in self if n not in c]
         return "".join(facts)
 
     def reachability(self, x, y):
         """
         Returns ``True`` whenever the configuration `y` is reachable from `x`
-        with the Most Permissive semantics.
+        with the Most Permissive update mode.
         Configurations can be partially defined.
         In that case, returns ``True`` whenever there exists a configuration
         matching with `y` which is reachable with at least one configuration
@@ -259,8 +326,9 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         :param dict[str,int] x: initial configuration
         :param dict[str,int] y: target configuration
         """
+        self.assert_pc_encoding()
         s = clingo_exists()
-        s.load(aspf("mp_eval.asp"))
+        self.load_eval(s)
         s.load(aspf("mp_positivereach-np.asp"))
         s.add("base", [], self.asp_of_bn())
         e = "default"
@@ -273,6 +341,32 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         res = s.solve()
         return res.satisfiable
 
+    def _ground_rules(self, ctl, rules):
+        rules = "\n".join(rules)
+        ctl.add("base", [], rules)
+        ctl.ground([("base",[])])
+
+    def _fixedpoints(self, reachable_from=None, constraints={}, limit=0):
+        e = "fp"
+        t2 = "fp"
+        rules = [self.asp_of_cfg(e, t2, constraints)]
+        rules.append(f"mp_reach({e},{t2},N,V) :- mp_state({e},{t2},N,V).")
+        rules.append(f":- mp_state({e},{t2},N,V), mp_eval({e},{t2},N,-V).")
+        rules.append(self.asp_of_bn())
+        if reachable_from:
+            self.assert_pc_encoding()
+            t1 = "0"
+            rules.append(open(aspf("mp_positivereach-np.asp")).read())
+            rules.append(self.asp_of_cfg(e,t1,reachable_from))
+            rules.append("is_reachable({},{},{}).".format(e,t1,t2))
+        rules.append(f"#show. #show fixpoint(N,V) : mp_state({e},{t2},N,V).")
+        rules.append(open(aspf("mp_eval.asp")).read())
+
+        project = reachable_from and set(self.keys()).difference(reachable_from)
+        s = clingo_enum(limit=limit, project=project)
+        self._ground_rules(s, rules)
+        return s
+
     def fixedpoints(self, reachable_from=None, constraints={}, limit=0):
         """
         Iterator over fixed points of the MPBN (i.e., of f)
@@ -285,22 +379,8 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
             the given constraints.
         :param int limit: maximum number of solutions, ``0`` for unlimited.
         """
-        s = clingo_enum(limit=limit)
-        s.add("base", [], self.asp_of_bn())
-        e = "fp"
-        t2 = "fp"
-        s.add("base", [], self.asp_of_cfg(e, t2, constraints))
-        s.load(aspf("mp_eval.asp"))
-        s.add("base", [], f"mp_reach({e},{t2},N,V) :- mp_state({e},{t2},N,V).")
-        s.add("base", [], f":- mp_state({e},{t2},N,V), mp_eval({e},{t2},N,-V).")
-        if reachable_from:
-            t1 = "0"
-            s.load(aspf("mp_positivereach-np.asp"))
-            s.add("base", [], self.asp_of_cfg(e,t1,reachable_from))
-            s.add("base", [], "is_reachable({},{},{}).".format(e,t1,t2))
-        s.add("base", [], f"#show. #show fixpoint(N,V) : mp_state({e},{t2},N,V).")
-
-        s.ground([("base",[])])
+        s = self._fixedpoints(reachable_from=reachable_from,
+                              constraints=constraints, limit=limit)
         for sol in s.solve(yield_=True):
             x = {n: None for n in self}
             data = sol.symbols(shown=True)
@@ -314,11 +394,9 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
                 x[n] = v
             yield x
 
-    def attractors(self, reachable_from=None, constraints={}, limit=0, star='*'):
+    def count_fixedpoints(self, reachable_from=None, constraints={}, limit=0):
         """
-        Iterator over attractors of the MPBN.
-        An attractor is an hypercube, represented by a dictionnary mapping every
-        component of the network to either ``0``, ``1``, or ``star``.
+        Returns number of fixed points
 
         :param dict[str,int] reachable_from: restrict to the attractors
             reachable from the given configuration. Whenever partial, restrict
@@ -327,29 +405,48 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         :param dict[str,int] constraints: consider only attractors matching with
             the given constraints.
         :param int limit: maximum number of solutions, ``0`` for unlimited.
-        :param str star: value to use for components which are free in the
-            attractor
         """
-        s = clingo_subsets(limit=limit)
-        s.load(aspf("mp_eval.asp"))
-        s.load(aspf("mp_attractor.asp"))
-        s.add("base", [], self.asp_of_bn())
+        s = self._fixedpoints(reachable_from=reachable_from,
+                              constraints=constraints, limit=limit)
+        return sum((1 for _ in s.solve(yield_=True)))
+
+
+    def _trapspaces(self, reachable_from=None, subcube={}, limit=0,
+                        mode="min", exclude_full=False):
+        self.assert_pc_encoding()
+
+        rules = []
+        rules.append(self.asp_of_bn())
+        rules.append(self.rules_eval())
+        rules.append(open(aspf("mp_attractor.asp")).read())
+        rules.append("#show attractor/2.")
+
         e = "__a"
         t2 = "final"
+        if exclude_full and not subcube:
+            rules.append(f"{{ mp_reach({e},{t2},N,(-1;1)): node(N) }} {len(self)*2-1}.")
         if reachable_from:
             t1 = "0"
-            s.load(aspf("mp_positivereach-np.asp"))
-            s.add("base", [], self.asp_of_cfg(e,t1,reachable_from))
-            s.add("base", [], "is_reachable({},{},{}).".format(e,t1,t2))
-            s.add("base", [], "mp_state({},{},N,V) :- attractor(N,V).".format(e,t2))
-
-        for n, b in constraints.items():
-            s.add("base", [], "mp_reach({},{},\"{}\",{}).".format(e,t2,n,s2v(b)))
-            s.add("base", [], ":- mp_reach({},{},\"{}\",{}).".format(e,t2,n,s2v(1-b)))
-
-        s.add("base", [], "#show attractor/2.")
-
-        s.ground([("base",[])])
+            rules.append(open(aspf("mp_positivereach-np.asp")).read())
+            rules.append(self.asp_of_cfg(e,t1,reachable_from))
+            rules.append("is_reachable({},{},{}).".format(e,t1,t2))
+            rules.append("mp_state({},{},N,V) :- attractor(N,V).".format(e,t2))
+
+        for n, b in subcube.items():
+            if isinstance(b, str):
+                b = int(b)
+            if b not in [0,1]:
+                continue
+            rules.append(":- mp_reach({},{},\"{}\",{}).".format(e,t2,n,s2v(1-b)))
+
+        project = reachable_from and set(self.keys()).difference(reachable_from)
+        solver = clingo_subsets if mode == "min" else clingo_supsets
+        s = solver(limit=limit, project=project)
+        self._ground_rules(s, rules)
+        return s
+
+    def _yield_trapspaces(self, *args, star="*", **kwargs):
+        s = self._trapspaces(*args, **kwargs)
         for sol in s.solve(yield_=True):
             attractor = {n: None for n in self}
             data = sol.symbols(shown=True)
@@ -364,11 +461,77 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
                 else:
                     v = 1 if v == 1 else 0
                 if attractor[n] is not None:
-                    attractor[n] = star
+                    if star is not None:
+                        attractor[n] = star
+                    else:
+                        del attractor[n]
                 else:
                     attractor[n] = v
             yield attractor
 
+    def _count_trapspaces(self, *args, **kwargs):
+        s = self._trapspaces(*args, **kwargs)
+        return sum((1 for _ in s.solve(yield_=True)))
+
+    def attractors(self, reachable_from=None, constraints={}, limit=0, star='*'):
+        """
+        Iterator over attractors of the MPBN (minimal trap spaces of the BN).
+        An attractor is an hypercube, represented by a dictionnary mapping every
+        component of the network to either ``0``, ``1``, or ``star``.
+
+        :param dict[str,int] reachable_from: restrict to the attractors
+            reachable from the given configuration. Whenever partial, restrict
+            attractors to the one reachable by at least one matching
+            configuration.
+        :param dict[str,int] constraints: consider only attractors matching with
+            the given constraints.
+        :param int limit: maximum number of solutions, ``0`` for unlimited.
+        :param str star: value to use for components which are free in the
+            attractor
+        """
+        return self._yield_trapspaces(reachable_from=reachable_from,
+                                subcube=constraints, limit=limit, star=star,
+                                mode="min")
+    minimal_trapspaces = attractors
+
+    def maximal_trapspaces(self, limit=0, subcube={}, star="*",
+                            exclude_full=True):
+        return self._yield_trapspaces(subcube=subcube, limit=limit, star=star,
+                                mode="max", exclude_full=exclude_full)
+
+    def count_attractors(self, reachable_from=None, constraints={}, limit=0):
+        """
+        Returns number of attractors of the MPBN (minimal trap spaces of the BN).
+
+        :param dict[str,int] reachable_from: restrict to the attractors
+            reachable from the given configuration. Whenever partial, restrict
+            attractors to the one reachable by at least one matching
+            configuration.
+        :param dict[str,int] constraints: consider only attractors matching with
+            the given constraints.
+        :param int limit: maximum number of solutions, ``0`` for unlimited.
+        """
+        return self._count_trapspaces(reachable_from=reachable_from,
+                                subcube=constraints, limit=limit,
+                                mode="min")
+    count_minimal_trapspaces = count_attractors
+
+    def count_maximal_trapspaces(self, reachable_from=None, constraints={}, limit=0):
+        """
+        Returns number of attractors of the MPBN (minimal trap spaces of the BN).
+
+        :param dict[str,int] reachable_from: restrict to the attractors
+            reachable from the given configuration. Whenever partial, restrict
+            attractors to the one reachable by at least one matching
+            configuration.
+        :param dict[str,int] constraints: consider only attractors matching with
+            the given constraints.
+        :param int limit: maximum number of solutions, ``0`` for unlimited.
+        """
+        return self._count_trapspaces(reachable_from=reachable_from,
+                                subcube=constraints, limit=limit,
+                                mode="max")
+
     def has_cyclic_attractor(self):
         for a in self.attractors():
             if "*" in a.values():
@@ -378,7 +541,7 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
     def reachable_from(self, x, reversed=False):
         """
         Returns an iterator over the configurations reachable from ``x`` with the
-        Most Permissive semantics.
+        Most Permissive update mode.
         Configuration ``x`` can be partially defined: in that case a configuration
         is yielded whnever it is reachable from at least one configuration
         matching with ``x``.
@@ -386,8 +549,9 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         Whenever ``reversed`` is ``True``, yields over the configurations that can
         reach `x` instead.
         """
+        self.assert_pc_encoding()
         s = clingo_enum()
-        s.load(aspf("mp_eval.asp"))
+        self.load_eval(s)
         s.load(aspf("mp_positivereach-np.asp"))
         s.add("base", [], self.asp_of_bn())
         e = "default"
@@ -410,7 +574,7 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
     def dynamics(self, update_mode="mp", **kwargs):
         """
         Returns a :py:class:`networkx.DiGraph` object representing the transitions between
-        the configurations using the Most Permissive semantics by default.
+        the configurations using the Most Permissive update mode by default.
         See :py:meth:`colomoto.minibn.BooleanNetwork.dynamics`.
         """
         if update_mode in ["mp", "most-permissive"]:

mpbn-4.3/mpbn/asplib/eval_circuit.asp

@@ -0,0 +1,28 @@
+mp_eval(E,T,N,V) :- timepoint(E,T), node(N), circuit(N,root,C), evalcircuit(E,T,N,C,V).
+mp_eval(E,T,N,V) :- timepoint(E,T), node(N), constant(N,V).
+
+%
+% leafs
+%
+evalcircuit(E,T,N,(var,M),V) :- circuit(N,(var,M)), mp_reach(E,T,M,V).
+evalcircuit(E,T,N,(constant,V),V) :- timepoint(E,T),node(N),circuit((constant,V)).
+
+%
+% operators
+%
+
+% negation
+evalcircuit(E,T,N,C,-V) :- circuit(N,C,neg), circuitedge(N,C,D),
+                            evalcircuit(E,T,N,D,V).
+
+% disjunction
+evalcircuit(E,T,N,C,1) :- circuit(N,C,or), circuitedge(N,C,D),
+                            evalcircuit(E,T,N,D,1).
+evalcircuit(E,T,N,C,-1) :- timepoint(E,T), circuit(N,C,or);
+                            evalcircuit(E,T,N,D,-1): circuitedge(N,C,D).
+
+% conjunction
+evalcircuit(E,T,N,C,-1) :- circuit(N,C,and), circuitedge(N,C,D),
+                            evalcircuit(E,T,N,D,-1).
+evalcircuit(E,T,N,C,1) :- timepoint(E,T), circuit(N,C,and);
+                            evalcircuit(E,T,N,D,1): circuitedge(N,C,D).