mpbn 3.4__tar.gz → 3.8__tar.gz

{mpbn-3.4 → mpbn-3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpbn
-Version: 3.4
+Version: 3.8
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé

{mpbn-3.4 → mpbn-3.8}/mpbn/__init__.py

@@ -46,23 +46,20 @@ 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_supsets(limit=0):
-    s = clingo.Control(clingo_options)
-    s.configuration.solve.models = limit
-    s.configuration.solve.project = 1
-    s.configuration.solve.enum_mode = "domRec"
-    s.configuration.solver[0].heuristic = "Domain"
-    s.configuration.solver[0].dom_mod = "3,16"
-    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)
@@ -325,13 +322,22 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
                 facts.append(circuitasp_of_boolfunc(f, n, self.ba))
         return "".join(facts)
 
-    def load_eval(self, solver):
+    def _file_eval(self):
         if self.encoding == "circuit":
-            solver.load(aspf("eval_circuit.asp"))
+            f = aspf("eval_circuit.asp")
         elif self.encoding == "mixed-dnf-bdd":
-            solver.load(aspf("eval_mixed.asp"))
+            f = aspf("eval_mixed.asp")
         else:
-            solver.load(aspf("mp_eval.asp"))
+            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"
@@ -340,8 +346,9 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         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):
@@ -371,6 +378,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)
@@ -383,23 +416,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"
-        self.load_eval(s)
-        s.add("base", [], self.asp_of_cfg(e, t2, constraints))
-        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:
-            self.assert_pc_encoding()
-            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)
@@ -413,36 +431,59 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
                 x[n] = v
             yield x
 
+    def count_fixedpoints(self, reachable_from=None, constraints={}, limit=0):
+        """
+        Returns number of fixed points
 
-    def _trapspaces(self, reachable_from=None, subcube={}, limit=0, 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.
+        """
+        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()
-        solver = clingo_subsets if mode == "min" else clingo_supsets
-        s = solver(limit=limit)
-        self.load_eval(s)
-        s.load(aspf("mp_attractor.asp"))
-        s.add("base", [], self.asp_of_bn())
+
+        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:
-            s.add("base", [], f"{{ mp_reach({e},{t2},N,(-1;1)): node(N) }} {len(self)*2-1}.")
+            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))
+            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
-            s.add("base", [], ":- mp_reach({},{},\"{}\",{}).".format(e,t2,n,s2v(1-b)))
+            rules.append(":- mp_reach({},{},\"{}\",{}).".format(e,t2,n,s2v(1-b)))
 
-        s.add("base", [], "#show attractor/2.")
+        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
 
-        s.ground([("base",[])])
+    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)
@@ -465,6 +506,10 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
                     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).
@@ -481,17 +526,49 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         :param str star: value to use for components which are free in the
             attractor
         """
-        return self._trapspaces(reachable_from=reachable_from,
+        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._trapspaces(subcube=subcube, limit=limit, star=star,
+        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():

{mpbn-3.4 → mpbn-3.8}/mpbn/cli/__init__.py

@@ -1,10 +1,14 @@
 
 import mpbn
 
+import os
 import sys
 from argparse import ArgumentParser
 
 def main():
+    if "CLINGO_OPTS" in os.environ:
+        mpbn.clingo_options += os.environ["CLINGO_OPTS"].split(" ")
+
     ap = ArgumentParser(prog=sys.argv[0])
     ap.add_argument("bnet_file")
     ap.add_argument("method", choices=["attractors", "fixedpoints", "bn2asp"])
@@ -13,19 +17,26 @@ def main():
     ap.add_argument("--encoding", default=mpbn.DEFAULT_ENCODING,
                     choices=mpbn.MPBooleanNetwork.supported_encodings,
                     help=f"Encoding method (default: {mpbn.DEFAULT_ENCODING})")
+    ap.add_argument("--input-is-dnf", action="store_true", default=False,
+                    help="Functions are already in DNF form")
     ap.add_argument("--simplify", action="store_true", default=False,
                     help="Try costly Boolean function simplifications to improve encoding")
     ap.add_argument("--try-unate-hard", action="store_true", default=False,
                     help="Try even more costly Boolean function simplifications")
+    ap.add_argument("--count", action="store_true",
+                    help="Returns only the number of solutions")
     args = ap.parse_args()
     mbn = mpbn.MPBooleanNetwork(args.bnet_file, encoding=args.encoding,
+                    auto_dnf=not args.input_is_dnf,
                     simplify=args.simplify,
                     try_unate_hard=args.try_unate_hard)
-    if args.method == "attractors":
-        for attractor in mbn.attractors(limit=args.limit):
-            print(attractor)
-    elif args.method == "fixedpoints":
-        for attractor in mbn.fixedpoints(limit=args.limit):
-            print(attractor)
+    if args.method in ["attractors", "fixedpoints"]:
+        if args.count:
+            func = getattr(mbn, f"count_{args.method}")
+            print(func(limit=args.limit))
+        else:
+            func = getattr(mbn, args.method)
+            for obj in func(limit=args.limit):
+                print(obj)
     elif args.method == "bn2asp":
         print(mbn.asp_of_bn())

mpbn-3.8/mpbn/converters.py

@@ -0,0 +1,87 @@
+import networkx as nx
+from pyeda.boolalg.minimization import *
+import pyeda.boolalg.expr
+from pyeda.inter import expr
+
+from colomoto import minibn
+
+def expr2str(ex):
+    """
+    converts a pyeda Boolean expression to string representation
+    """
+    def _protect(e):
+        if isinstance(e, (pyeda.boolalg.expr.OrOp, pyeda.boolalg.expr.AndOp)):
+            return f"({expr2str(e)})"
+        return expr2str(e)
+    if isinstance(ex, pyeda.boolalg.expr.Variable):
+        return str(ex)
+    elif isinstance(ex, pyeda.boolalg.expr._One):
+        return "1"
+    elif isinstance(ex, pyeda.boolalg.expr._Zero):
+        return "0"
+    elif isinstance(ex, pyeda.boolalg.expr.Complement):
+        return f"!{_protect(ex.__invert__())}"
+    elif isinstance(ex, pyeda.boolalg.expr.NotOp):
+        return f"!{_protect(ex.x)}"
+    elif isinstance(ex, pyeda.boolalg.expr.OrOp):
+        return " | ".join(map(_protect, ex.xs))
+    elif isinstance(ex, pyeda.boolalg.expr.AndOp):
+        return " & ".join(map(_protect, ex.xs))
+    raise NotImplementedError(str(ex), type(ex))
+
+
+def bn_of_asynchronous_transition_graph(adyn, names,
+            parse_node=(lambda n: tuple(map(int, n))),
+            bn_class=minibn.BooleanNetwork,
+            simplify=True):
+    """
+    Convert the transition graph of a (fully) asynchronous Boolean network to
+    a propositional logic representation.
+
+    The object `adyn` must be an instance of `networkx.DiGraph`.
+    The `parse_node` function must return a tuple of 0 and 1 from an `adyn`
+    node. By default, it is assumed that nodes are strings of binary values.
+    Returned object will be of `bn_class`, instantiated with a dictionnary
+    mapping component names to a string representation of their Boolean expression.
+    """
+    relabel = {label: parse_node(label) for label in adyn.nodes()}
+    adyn = nx.relabel_nodes(adyn, relabel)
+    n = len(next(iter(adyn.nodes)))
+    assert n == len(names), "list of component names and dimension of configuraitons seem different"
+    assert adyn.number_of_nodes() == 2**n, "unexpected number of nodes in the transition graph"
+
+    def expr_of_cfg(x):
+        e = "&".join(f"{'~' if not v else ''}{names[i]}" for i, v in enumerate(x))
+        return f"({e})"
+
+    f = []
+    for i in range(n):
+        pos = []
+        for x in adyn.nodes():
+            dx = list(x)
+            dx[i] = 1-x[i]
+            y = dx if tuple(dx) in adyn[x] else x
+            target = y[i]
+            if target:
+                pos.append(x)
+        if not pos:
+            f.append(expr("0"))
+        else:
+            e = expr("|".join(map(expr_of_cfg,pos)))
+            e, = espresso_exprs(e.to_dnf())
+            f.append(e)
+    f = map(expr2str, f)
+    f = bn_class(dict(zip(names, f)))
+    if simplify:
+        f = f.simplify()
+    return f
+
+if __name__ == "__main__":
+    import mpbn
+
+    f = mpbn.MPBooleanNetwork({
+        "x1": "x2",
+        "x2": "x3",
+        "x3": "x1"})
+    g = f.dynamics("asynchronous")
+    print(bn_of_asynchronous_transition_graph(g, list(f)))

{mpbn-3.4 → mpbn-3.8}/mpbn.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpbn
-Version: 3.4
+Version: 3.8
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé

{mpbn-3.4 → mpbn-3.8}/mpbn.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ MANIFEST.in
 README.md
 setup.py
 mpbn/__init__.py
+mpbn/converters.py
 mpbn/simulation.py
 mpbn.egg-info/PKG-INFO
 mpbn.egg-info/SOURCES.txt

{mpbn-3.4 → mpbn-3.8}/setup.py

@@ -4,7 +4,7 @@
 from setuptools import setup, find_packages
 
 NAME = "mpbn"
-VERSION = "3.4"
+VERSION = "3.8"
 
 setup(name=NAME,
     version=VERSION,