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

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/simulation.py

@@ -177,14 +177,14 @@ def step(f, mem, x, depth, W):
     sample_configuration(f, mem, x, S, W)
     return True
 
-
 def is_subhypercube(a, b):
     x, H = a
     y, G = b
     return H.issubset(G) and \
             not [i for i in set(x).difference(G) if x[i] != y[i]]
 
-def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10):
+def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10, emit=None):
+    if not isinstance(f, MPBNSim): f = MPBNSim(f)
     I = set(f)
     n = len(f)
     def filter_reachable_attractors(A, x):
@@ -194,6 +194,8 @@ def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10):
     x = x.copy()
     A = filter_reachable_attractors(A, x)
     while len(A) > 1:
+        if emit is not None:
+            emit(x)
         if not step(f, mem, x, depth, W):
             k = 0
         if k % refresh_rate == 0:
@@ -201,6 +203,48 @@ def sample_reachable_attractor(f, mem, x, A, depth, W, refresh_rate=10):
         k += 1
     return A[0][0]
 
+def sample_trace(f, mem, x, A, depth, W):
+    if not isinstance(f, MPBNSim): f = MPBNSim(f)
+    I = set(f)
+    n = len(f)
+    def filter_reachable_attractors(A, x):
+        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()
+    trace = list()
+    trace.append(x.copy())
+    A = filter_reachable_attractors(A, x)
+    while len(A) and x != A[0][1][0]:
+        step(f, mem, x, depth, W)
+        trace.append(x.copy())
+        A = filter_reachable_attractors(A, x)
+    return trace
+
+
+def sample_switchpoint(f, mem, x, A, depth, W):
+    """ experimental: sample a trace and stop at an attractor's
+    strong bassin, returning the attractor as well."""
+    if not isinstance(f, MPBNSim): f = MPBNSim(f)
+    I = set(f)
+    n = len(f)
+    def filter_reachable_attractors(A, x):
+        H = spread(f, x, I, n)
+        return [(ia,a) for (ia,a) in A if is_subhypercube(a, (x,H))]
+    
+    names = lambda _A: set(_a_name for _a_name, _a_cfg in _A)
+    k = 1
+    x = x.copy()
+    trace = list()
+    A = filter_reachable_attractors(A, x)
+    trace.append((x.copy(), names(A)))
+    while len(A) > 1:
+        step(f, mem, x, depth, W)
+        A = filter_reachable_attractors(A, x)
+        trace.append((x.copy(), names(A)))
+    #return [*trace, [a_name for a_name, a_x in A]] 
+    return trace
+
 def convert_attractor(A):
     H = {i for i,v in A.items() if v == '*'}
     x = {i:v for i,v in A.items() if v != '*'}
@@ -307,6 +351,7 @@ def nexponential_depth(f, base=2):
 ##
 ## Rates
 ##
+## TODO: resolve this
 def uniform_rates(f):
     """
     Returns 1

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpbn
-Version: 3.3
+Version: 3.5
 Summary: Simple implementation of Most Permissive Boolean networks
 Home-page: https://github.com/bnediction/mpbn
 Author: Loïc Paulevé
@@ -20,7 +20,7 @@ Requires-Dist: scipy
 Requires-Dist: tqdm
 
 
-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.
 

{mpbn-3.3.dist-info → mpbn-3.5.dist-info}/RECORD

@@ -1,5 +1,6 @@
 mpbn/__init__.py,sha256=oPey2_tk0ymBGwiL9dcG88Hk-vUuWH-gpmP7ZDwXyu4,20578
-mpbn/simulation.py,sha256=Ii6QpTeeQY278wruRYPY4rY8dBPYrMyb_9Fshzf1_Jo,9115
+mpbn/converters.py,sha256=33mhsGnFkJL4PlqYMIKu3zNb5oCNT6ZLaK6xoj9WsI4,3034
+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
@@ -14,8 +15,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.3.dist-info/METADATA,sha256=zBtRnfvK4rhv3l78c6LYlJQO166RQ87UTd9DgfJj8H4,1833
-mpbn-3.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-mpbn-3.3.dist-info/entry_points.txt,sha256=CpzAc9SkB-mH_dojzt1N3YgDxy8hniDrIGzSHcPDo8g,68
-mpbn-3.3.dist-info/top_level.txt,sha256=oe3jlFHbQ6oIXyE1q7yAAnf1m49oP_jBPUU05d71n74,11
-mpbn-3.3.dist-info/RECORD,,
+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-3.3.dist-info → mpbn-3.5.dist-info}/WHEEL

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