mpbn 3.8__tar.gz → 4.3.1__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mpbn
-Version: 3.8
+Version: 4.3.1
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé
@@ -15,9 +15,19 @@ Requires-Dist: boolean.py
 Requires-Dist: clingo
 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.8 → mpbn-4.3.1}/README.md

@@ -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.8 → mpbn-4.3.1}/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"))
@@ -78,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):
@@ -102,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
 
@@ -116,33 +115,8 @@ 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 = []
@@ -176,28 +150,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", "pyeda")
+SUPPORTED_BOOLFUNCLIBS = ["aeon", "pyeda"]
 
 class MPBooleanNetwork(minibn.BooleanNetwork):
     """
@@ -218,7 +173,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`.
 
@@ -227,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:
 
@@ -236,11 +195,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):
@@ -252,19 +221,13 @@ class MPBooleanNetwork(minibn.BooleanNetwork):
         if isinstance(f, str):
             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()
+        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 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)
@@ -311,13 +274,13 @@ 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)

mpbn-4.3.1/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, boolean._TRUE):
+            return ctx.mk_const(True)
+        if type(f) is ba.FALSE or isinstance(f, boolean._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-3.8/mpbn/converters.py → mpbn-4.3.1/mpbn/boolfunclib/pyeda_impl.py

@@ -1,7 +1,10 @@
+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
 
@@ -29,6 +32,68 @@ def expr2str(ex):
         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))),
@@ -76,12 +141,3 @@ def bn_of_asynchronous_transition_graph(adyn, names,
         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.8 → mpbn-4.3.1}/mpbn/cli/__init__.py

@@ -17,6 +17,9 @@ 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,
@@ -27,6 +30,7 @@ def main():
                     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)

mpbn-4.3.1/mpbn/converters.py

@@ -0,0 +1,14 @@
+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
+
+    f = mpbn.MPBooleanNetwork({
+        "x1": "x2",
+        "x2": "x3",
+        "x3": "x1"})
+    g = f.dynamics("asynchronous")
+    print(bn_of_asynchronous_transition_graph(g, list(f)))

{mpbn-3.8 → mpbn-4.3.1}/mpbn/simulation.py

@@ -188,7 +188,7 @@ def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10, emit=Non
     I = set(f)
     n = len(f)
     def filter_reachable_attractors(A, x):
-        H = spread(f, x, I, n)
+        H = spread(f, x, I, n) 
         return [(ia,a) for (ia,a) in A if is_subhypercube(a, (x,H))]
     k = 1
     x = x.copy()
@@ -201,7 +201,7 @@ def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10, emit=Non
         if k % refresh_rate == 0:
             A = filter_reachable_attractors(A, x)
         k += 1
-    return A[0][0]
+    return None if (len(A)==0) else A[0][0]
 
 def sample_trace(f, mem, x, A, depth, W):
     if not isinstance(f, MPBNSim): f = MPBNSim(f)
@@ -257,6 +257,8 @@ def estimate_reachable_attractors_probabilities(f, x, A, nb_sims, depth, W):
     C = {ia: 0 for (ia,_) in A}
     for _ in tqdm(range(nb_sims)):
         ia = sample_reachable_attractor(f, mem, x, A, depth, W)
+        if (ia is None):
+        	continue
         C[ia] += 1
     for ia, _ in A:
         C[ia] = (C[ia]*100) / nb_sims

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: mpbn
-Version: 3.8
+Version: 4.3.1
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé
@@ -15,9 +15,19 @@ Requires-Dist: boolean.py
 Requires-Dist: clingo
 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.8 → mpbn-4.3.1}/mpbn.egg-info/SOURCES.txt

@@ -15,5 +15,8 @@ mpbn/asplib/eval_mixed.asp
 mpbn/asplib/mp_attractor.asp
 mpbn/asplib/mp_eval.asp
 mpbn/asplib/mp_positivereach-np.asp
+mpbn/boolfunclib/__init__.py
+mpbn/boolfunclib/aeon_impl.py
+mpbn/boolfunclib/pyeda_impl.py
 mpbn/cli/__init__.py
 mpbn/cli/sim.py

{mpbn-3.8 → mpbn-4.3.1}/mpbn.egg-info/requires.txt

@@ -2,6 +2,6 @@ boolean.py
 clingo
 colomoto_jupyter>=0.8.0
 numpy
-pyeda
+biodivine_aeon>=1.0.1
 scipy
 tqdm

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

@@ -4,7 +4,7 @@
 from setuptools import setup, find_packages
 
 NAME = "mpbn"
-VERSION = "3.8"
+VERSION = "4.3.1"
 
 setup(name=NAME,
     version=VERSION,
@@ -27,7 +27,7 @@ setup(name=NAME,
         "clingo",
         "colomoto_jupyter>=0.8.0",
         "numpy",
-        "pyeda",
+        "biodivine_aeon>=1.0.1",
         "scipy",
         "tqdm"
     ],