mpbn 3.5__py3-none-any.whl → 4.0__py3-none-any.whl

mpbn/__init__.py

@@ -31,10 +31,6 @@ from colomoto import minibn
 
 from boolean import boolean
 import clingo
-
-from pyeda.boolalg import bdd
-import pyeda.boolalg.expr
-from pyeda.boolalg.expr import expr
 sys.setrecursionlimit(max(100000, sys.getrecursionlimit()))
 
 __asplibdir__ = os.path.realpath(os.path.join(os.path.dirname(__file__), "asplib"))
@@ -46,23 +42,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)
@@ -81,7 +74,7 @@ def s2v(s):
 def v2s(v):
     return 1 if v > 0 else 0
 
-def is_unate(ba, f):
+def is_dnf_unate(ba, f):
     pos_lits = set()
     neg_lits = set()
     def is_lit(f):
@@ -119,34 +112,6 @@ 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 circuitasp_of_boolfunc(f, i, ba):
     atoms = []
     fid = clingo.String(i)
@@ -179,28 +144,9 @@ def circuitasp_of_boolfunc(f, i, ba):
     atoms.append(f"circuit({fid},root,{root}).\n")
     return "\n".join(atoms)
 
-
-def expr2bpy(ex, ba):
-    """
-    converts a pyeda Boolean expression into a boolean.py one
-    """
-    if isinstance(ex, pyeda.boolalg.expr.Variable):
-        return ba.Symbol(str(ex))
-    elif isinstance(ex, pyeda.boolalg.expr._One):
-        return ba.TRUE
-    elif isinstance(ex, pyeda.boolalg.expr._Zero):
-        return ba.FALSE
-    elif isinstance(ex, pyeda.boolalg.expr.Complement):
-        return ba.NOT(ba.Symbol(str(ex.__invert__())))
-    elif isinstance(ex, pyeda.boolalg.expr.NotOp):
-        return ba.NOT(expr2bpy(ex.x, ba))
-    elif isinstance(ex, pyeda.boolalg.expr.OrOp):
-        return ba.OR(*(expr2bpy(x, ba) for x in ex.xs))
-    elif isinstance(ex, pyeda.boolalg.expr.AndOp):
-        return ba.AND(*(expr2bpy(x, ba) for x in ex.xs))
-    raise NotImplementedError(str(ex), type(ex))
-
 DEFAULT_ENCODING = "mixed-dnf-bdd"
+DEFAULT_BOOLFUNCLIB = os.environ.get("MPBN_BOOLFUNCLIB", "aeon")
+SUPPORTED_BOOLFUNCLIBS = ["aeon", "pyeda"]
 
 class MPBooleanNetwork(minibn.BooleanNetwork):
     """
@@ -221,7 +167,8 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
     def __init__(self, bn=minibn.BooleanNetwork(), auto_dnf=True,
                         simplify=False,
                         try_unate_hard=False,
-                        encoding=DEFAULT_ENCODING):
+                        encoding=DEFAULT_ENCODING,
+                        boolfunclib=DEFAULT_BOOLFUNCLIB):
         """
         Constructor for :py:class:`.MPBoooleanNetwork`.
 
@@ -230,6 +177,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:
 
@@ -239,11 +189,21 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         >>> mbn = MPBooleanNetwork(bn)
         """
         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):
@@ -256,18 +216,12 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
             f = self.ba.parse(f)
         f = self._autobool(f)
         if self.auto_dnf:
-            e = expr(str(f).replace("!","~"))
-            e = e.to_dnf()
-            if self._simplify is not None:
-                e = e.simplify()
-            f = expr2bpy(e, self.ba)
-            if self.try_unate_hard:
-                f = minibn.simplify_dnf(self.ba, f)
-            elif self._simplify:
-                f = f.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 in self.dnf_encodings:
-            self._is_unate[a] = is_unate(self.ba, f)
+            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)
@@ -314,24 +268,33 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
             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(bddasp_of_boolfunc(f, n))
+                    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 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 +303,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 +335,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 +373,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 +388,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 +463,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 +483,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/boolfunclib/aeon_impl.py

@@ -0,0 +1,202 @@
+import networkx as nx
+import clingo
+
+from boolean import boolean
+from colomoto import minibn
+
+from typing import Optional
+
+from biodivine_aeon import Bdd, BddPointer
+from biodivine_aeon import BddVariableSet, BddValuation
+
+def is_unate_symbolic(f: Bdd) -> boolean:
+    """
+    Returns `True` if the given `biodivine_aeon.Bdd` represents a unate function
+    (i.e. all arguments are locally monotonic).
+
+    The way this is handled is that we test for positive/negative monotonicity by
+    symbolically expressing the inputs where decreasing the input increases the
+    output (i.e. a counterexample to positive monotonicity), or vice versa.
+    """
+    variables = f.__ctx__().variable_ids()
+    f_false = f.l_not()
+    f_true = f
+    for var in f.support_set():
+        var_is_true = f.__ctx__().mk_literal(var, True)
+        var_is_false = f.__ctx__().mk_literal(var, False)
+        
+        f_1_to_0 = f_false.l_and(var_is_true).r_exists(var)
+        f_0_to_1 = f_true.l_and(var_is_false).r_exists(var)
+        is_positive = f_0_to_1.l_and(f_1_to_0).r_exists(variables).l_not().is_true()        
+        
+        f_0_to_0 = f_false.l_and(var_is_false).r_exists(var)
+        f_1_to_1 = f_true.l_and(var_is_true).r_exists(var)
+        is_negative = f_0_to_0.l_and(f_1_to_1).r_exists(variables).l_not().is_true()
+
+        # An input cannot be both positive and negative at the same time.
+        assert not (is_positive and is_negative)
+
+        if (not is_positive) and (not is_negative):
+            return False
+    return True
+
+
+def ba_to_bdd(ba: boolean.BooleanAlgebra, f: boolean.Expression, ctx: BddVariableSet | None = None) -> Bdd:
+    """
+    Takes a `boolean.Expression` (with the associated `boolean.BooleanAlgebra`) and
+    converts it to a `biodivine_aeon.Bdd`. 
+
+    Note that the `Bdd` has an associated `biodivine_aeon.BddVariableSet` context, which maps the 
+    variable IDs to names. You can provide your own context, or one will be created for you
+    (to access the underlying context object, use `bdd.__ctx__()`).
+    """
+    ba_vars = f.symbols
+    variables = sorted([ str(var) for var in ba_vars ])
+    if ctx is None:        
+        ctx = BddVariableSet(variables)
+    else:
+        # Check that all variables that exist in `f` also exist in `ctx`.
+        assert all((ctx.find_variable(var) is not None) for var in variables)
+    def ba_to_bdd_rec(f: boolean.Expression) -> Bdd:
+        if type(f) is ba.TRUE or isinstance(f, minibn._TRUE):
+            return ctx.mk_const(True)
+        if type(f) is ba.FALSE or isinstance(f, minibn._FALSE):
+            return ctx.mk_const(False)        
+        if type(f) is ba.Symbol: 
+            return ctx.mk_literal(str(f.obj), True)
+        if type(f) is ba.NOT:
+            assert len(f.args) == 1, "Cannot transform NOT with more than one argument."
+            return ba_to_bdd_rec(f.args[0]).l_not()
+        if type(f) is ba.AND:
+            result = ctx.mk_const(True)
+            for arg in f.args:
+                result = result.l_and(ba_to_bdd_rec(arg))
+            return result
+        if type(f) is ba.OR:
+            result = ctx.mk_const(False)
+            for arg in f.args:
+                result = result.l_or(ba_to_bdd_rec(arg))
+            return result        
+        raise NotImplementedError(str(f), type(f))
+        
+    return ba_to_bdd_rec(f)
+        
+def bdd_to_dnf(ba: boolean.BooleanAlgebra, f: Bdd) -> boolean.Expression:
+    """
+    Convert a `biodivine_aeon.Bdd` to a `boolean.Expression` in disjunctive normal form.
+    """
+    if f.is_true():
+        return ba.TRUE
+    if f.is_false():
+        return ba.FALSE    
+    ctx = f.__ctx__()
+    # Technically, `optimize=True` should be set by default, but just in case.
+    dnf = f.to_dnf(optimize=True)
+    # Maps BDD variables to BooleanAlgebra Symbols.
+    var_to_symbol = { var: ba.Symbol(ctx.get_variable_name(var)) for var in ctx.variable_ids() }
+    ba_clauses = []
+    for clause in dnf:
+        literals = []
+        for (var, value) in clause.items():            
+            if value:
+                literals.append(var_to_symbol[var])
+            else:
+                literals.append(ba.NOT(var_to_symbol[var]))                
+        assert len(literals) > 0
+        if len(literals) == 1:
+            ba_clauses.append(literals[0])
+        else:
+            ba_clauses.append(ba.AND(*literals))
+    assert len(ba_clauses) > 0 
+    if len(ba_clauses) == 1:
+        return ba_clauses[0]
+    else:
+        return ba.OR(*ba_clauses)
+
+def make_dnf_boolfunc(ba, f, **unused_opts):
+    bdd = ba_to_bdd(ba, f)
+    return bdd_to_dnf(ba, bdd)
+
+def asp_of_bdd(var_name, bdd: Bdd) -> list[str]:
+    """
+    Convert a `biodivine_aeon.Bdd` into a list of `clingo` atoms
+    representing the individual BDD nodes.    
+    """
+    if bdd.is_false():
+        return [f"bdd({clingo.String(var_name)},-1)"]
+    if bdd.is_true():
+        return [f"bdd({clingo.String(var_name)},1)"]
+    
+    _rules = {}
+    def _rec(node: BddPointer, node_name: Optional[str] = None) -> str:
+        if node.is_zero():
+            return "-1"
+        if node.is_one():
+            return "1"
+        if node_name is None:
+            node_name = f"{var_name}_n{int(node)}"        
+        node_name_clingo = clingo.String(node_name)
+        if node_name_clingo in _rules:
+            # The node was already declared.
+            return node_name_clingo
+        node_var = bdd.node_variable(node)
+        assert node_var is not None # Only `None` if node is terminal.
+        (lo, hi) = bdd.node_links(node)
+        var = clingo.String(bdd.__ctx__().get_variable_name(node_var))
+        lo = _rec(lo)
+        hi = _rec(hi)
+        atom = f"bdd({node_name_clingo},{var},{lo},{hi})"
+        _rules[node_name_clingo] = atom
+        return node_name_clingo
+    _rec(bdd.root(), var_name)
+
+    return list(_rules.values())
+
+def bddasp_of_boolfunc(ba, f, var_name):
+    f_bdd = ba_to_bdd(ba, f)
+    atoms = asp_of_bdd(var_name, f_bdd)
+    return "\n".join((f"{a}." for a in atoms))
+
+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"
+
+    bdd_ctx = BddVariableSet(names)
+
+    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(BddValuation(bdd_ctx, list(x)))
+        if len(pos) == 0:
+            f.append(bdd_ctx.mk_false())
+        else:
+            f.append(bdd_ctx.mk_dnf(pos))
+
+    bn = bn_class()
+    for (i, name) in enumerate(names):
+        bn[name] = bdd_to_dnf(bn.ba, f[i])
+    if simplify:
+        bn = bn.simplify()
+    return bn

mpbn/boolfunclib/pyeda_impl.py

@@ -0,0 +1,143 @@
+import clingo
+import networkx as nx
+
+from pyeda.boolalg.minimization import *
+import pyeda.boolalg.expr
+from pyeda.inter import expr
+from pyeda.boolalg import bdd
+
+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 expr2bpy(ex, ba):
+    """
+    converts a pyeda Boolean expression into a boolean.py one
+    """
+    if isinstance(ex, pyeda.boolalg.expr.Variable):
+        return ba.Symbol(str(ex))
+    elif isinstance(ex, pyeda.boolalg.expr._One):
+        return ba.TRUE
+    elif isinstance(ex, pyeda.boolalg.expr._Zero):
+        return ba.FALSE
+    elif isinstance(ex, pyeda.boolalg.expr.Complement):
+        return ba.NOT(ba.Symbol(str(ex.__invert__())))
+    elif isinstance(ex, pyeda.boolalg.expr.NotOp):
+        return ba.NOT(expr2bpy(ex.x, ba))
+    elif isinstance(ex, pyeda.boolalg.expr.OrOp):
+        return ba.OR(*(expr2bpy(x, ba) for x in ex.xs))
+    elif isinstance(ex, pyeda.boolalg.expr.AndOp):
+        return ba.AND(*(expr2bpy(x, ba) for x in ex.xs))
+    raise NotImplementedError(str(ex), type(ex))
+
+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(ba, 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 make_dnf_boolfunc(ba, f, try_unate_hard=False, simplify=True):
+    """
+    try_unate_hard: use costly CNF/DNF transformations
+    simplify: use boolean.py simplification method
+    """
+    e = expr(str(f).replace("!","~"))
+    e = e.to_dnf()
+    e = e.simplify()
+    e = expr2bpy(e, ba)
+    if try_unate_hard:
+        e = minibn.simplify_dnf(self.ba, e)
+    elif simplify:
+        e = e.simplify()
+    return e
+
+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
+

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,30 @@ 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("--boolfunclib", default="aeon",
+                    choices=mpbn.SUPPORTED_BOOLFUNCLIBS,
+                    help=f"Backend lib for Boolean functions (default: {mpbn.DEFAULT_BOOLFUNCLIB})")
+    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,
+                    boolfunclib=args.boolfunclib,
+                    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/converters.py

@@ -1,80 +1,7 @@
-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
+try:
+    from mpbn.boolfunclib.aeon_impl import bn_of_asynchronous_transition_graph
+except ImportError:
+    from mpbn.boolfunclib.pyeda_impl import bn_of_asynchronous_transition_graph
 
 if __name__ == "__main__":
     import mpbn

{mpbn-3.5.dist-info → mpbn-4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: mpbn
-Version: 3.5
+Version: 4.0
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé
@@ -13,11 +13,21 @@ Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Description-Content-Type: text/markdown
 Requires-Dist: boolean.py
 Requires-Dist: clingo
-Requires-Dist: colomoto-jupyter >=0.8.0
+Requires-Dist: colomoto_jupyter>=0.8.0
 Requires-Dist: numpy
-Requires-Dist: pyeda
+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).
@@ -38,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.5.dist-info → mpbn-4.0.dist-info}/RECORD

@@ -1,12 +1,15 @@
-mpbn/__init__.py,sha256=oPey2_tk0ymBGwiL9dcG88Hk-vUuWH-gpmP7ZDwXyu4,20578
-mpbn/converters.py,sha256=33mhsGnFkJL4PlqYMIKu3zNb5oCNT6ZLaK6xoj9WsI4,3034
+mpbn/__init__.py,sha256=kbHB9JR5z2XP3FNaf2F06X9TaJM3PVVHzAsltT0_awg,22903
+mpbn/converters.py,sha256=6uCjxaJ2MI19_I1h0Pk9YN6PcDx42_C-Ml8ZRMA9uxg,416
 mpbn/simulation.py,sha256=3lk6yu7k2POrSytmtnsGIh596B-qcAgBtl16iZ0vzM4,10594
 mpbn/asplib/eval_circuit.asp,sha256=5rIbkVmvobaQwE_gHr0_USccPuI0QUPuzfw_1011hSE,989
 mpbn/asplib/eval_mixed.asp,sha256=n23pbjtxuWSCerL36Gb6O32bx8_1ukc52l1hQMMs8OE,787
 mpbn/asplib/mp_attractor.asp,sha256=CawLNxlYBZG2cl8XQAxA6EXEZ89Y9iw20CZ73n97Nu8,185
 mpbn/asplib/mp_eval.asp,sha256=PNa1APcKS9bgtCB3BtAdxq0mkg3p_x3G6fWSF3uAgzw,769
 mpbn/asplib/mp_positivereach-np.asp,sha256=SxLzZMszZxy_J14WTO7Me4aXldzxhqnL-ihqcnHCb8I,453
-mpbn/cli/__init__.py,sha256=OR7EO_BbDpkbBqNq1gZPgxrvTlEiMOgG1LZOyhiulGk,1388
+mpbn/boolfunclib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpbn/boolfunclib/aeon_impl.py,sha256=X41J1tIeKIHomOpL9zrTzYaW12dkE79t_Wp9VXrP7XA,7660
+mpbn/boolfunclib/pyeda_impl.py,sha256=NkgE46MKrSOVInAF5W0QnTbAjVMtLM8ox05oJUMtPHo,5003
+mpbn/cli/__init__.py,sha256=v5C9U2YLR-J02JV-ciZkZoCvEcx7emgEy402mv4CdAg,2124
 mpbn/cli/sim.py,sha256=CHsbE4qp1L0iXyGLL1_zPontFjHL58qlt1_QVSWna68,6086
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_attractors.py,sha256=0ga4j0T6db6ljXlAs5jJG0BLB5xZchSdlhwbC-4lj8w,255
@@ -15,8 +18,8 @@ tests/test_fixpoints.py,sha256=bdDttzimiby48nVkVL-HXZ2rBldICBRbIZrVVbTGfso,786
 tests/test_input.py,sha256=mwMKd5UwAIY4Z1uZjYr09Ue8DLxD52CiPSoE-iXytfo,337
 tests/test_reachability.py,sha256=X7anTwFSIYcV2rltJBOW8TcAJnrt3SjYLqttB0eIL_Q,588
 tests/test_reachable_attractors.py,sha256=h78kvgmx9rTJWi3r2DZe_abYDxr02MLJ2iLDJUdLESY,540
-mpbn-3.5.dist-info/METADATA,sha256=I6viVUknNQ532Vya9eUX-6u_QuwxrQx-w59njI7srYQ,2129
-mpbn-3.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-mpbn-3.5.dist-info/entry_points.txt,sha256=CpzAc9SkB-mH_dojzt1N3YgDxy8hniDrIGzSHcPDo8g,68
-mpbn-3.5.dist-info/top_level.txt,sha256=oe3jlFHbQ6oIXyE1q7yAAnf1m49oP_jBPUU05d71n74,11
-mpbn-3.5.dist-info/RECORD,,
+mpbn-4.0.dist-info/METADATA,sha256=DJlh3LPEMO30F7gkqQMPlfCfBrrSuQBmG-1ty-Chlew,2364
+mpbn-4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mpbn-4.0.dist-info/entry_points.txt,sha256=CpzAc9SkB-mH_dojzt1N3YgDxy8hniDrIGzSHcPDo8g,68
+mpbn-4.0.dist-info/top_level.txt,sha256=oe3jlFHbQ6oIXyE1q7yAAnf1m49oP_jBPUU05d71n74,11
+mpbn-4.0.dist-info/RECORD,,

{mpbn-3.5.dist-info → mpbn-4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any