{ "cells": [ { "cell_type": "markdown", "id": "d35d9bb9", "metadata": {}, "source": [ "# BoolForge Tutorial 7: Dynamics of Boolean Networks\n", "\n", "In this tutorial, we study the *dynamics* of Boolean networks.\n", "Building on the construction and structural analysis from previous tutorials,\n", "we now focus on how Boolean networks evolve over time and how their long-term\n", "behavior can be characterized.\n", "\n", "You will learn how to:\n", "\n", "- simulate Boolean network dynamics under different updating schemes,\n", "- compute and classify attractors,\n", "- analyze basins of attraction,\n", "- relate network structure to dynamical behavior.\n", "\n", "---\n", "## 0. Setup" ] }, { "cell_type": "code", "execution_count": 1, "id": "33920430", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:17.198022Z", "iopub.status.busy": "2026-01-12T19:19:17.197716Z", "iopub.status.idle": "2026-01-12T19:19:17.873324Z", "shell.execute_reply": "2026-01-12T19:19:17.873030Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "import boolforge\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "00650f89", "metadata": {}, "source": [ "---\n", "## 1. State space of a Boolean network\n", "\n", "A Boolean network with $N$ nodes defines a dynamical system on the discrete\n", "state space $\\{0,1\\}^N$.\n", "\n", "Each state is a binary vector\n", "\n", "$$\n", "\\mathbf{x} = (x_0, \\ldots, x_{N-1}) \\in \\{0,1\\}^N,\n", "$$\n", "\n", "where $x_i$ denotes the state of node $i$.\n", "\n", "We use a small Boolean network as a running example." ] }, { "cell_type": "code", "execution_count": 2, "id": "fecb35b3", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:17.874642Z", "iopub.status.busy": "2026-01-12T19:19:17.874524Z", "iopub.status.idle": "2026-01-12T19:19:17.876755Z", "shell.execute_reply": "2026-01-12T19:19:17.876545Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Variables: ['x' 'y' 'z']\n", "N: 3\n", "bn.I: [array([1]), array([0, 2]), array([1])]\n", "bn.F: [BooleanFunction(f=[0, 1]), BooleanFunction(f=[0, 1, 1, 1]), BooleanFunction(f=[0, 1])]\n" ] } ], "source": [ "string = \"\"\"\n", "x = y\n", "y = x OR z\n", "z = y\n", "\"\"\"\n", "\n", "bn = boolforge.BooleanNetwork.from_string(string, separator=\"=\")\n", "\n", "print(\"Variables:\", bn.variables)\n", "print(\"N:\", bn.N)\n", "print(\"bn.I:\", bn.I)\n", "print(\"bn.F:\", bn.F)" ] }, { "cell_type": "markdown", "id": "70ecc7c0", "metadata": {}, "source": [ "All state vectors follow the variable order given by `bn.variables`.\n", "For small networks, we can enumerate all $2^N$ states explicitly." ] }, { "cell_type": "code", "execution_count": 3, "id": "c44a984a", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:17.877823Z", "iopub.status.busy": "2026-01-12T19:19:17.877756Z", "iopub.status.idle": "2026-01-12T19:19:17.882218Z", "shell.execute_reply": "2026-01-12T19:19:17.881971Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xyz
0000
1001
2010
3011
4100
5101
6110
7111
\n", "
" ], "text/plain": [ " x y z\n", "0 0 0 0\n", "1 0 0 1\n", "2 0 1 0\n", "3 0 1 1\n", "4 1 0 0\n", "5 1 0 1\n", "6 1 1 0\n", "7 1 1 1" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "all_states = boolforge.get_left_side_of_truth_table(bn.N)\n", "pd.DataFrame(all_states, columns=bn.variables)" ] }, { "cell_type": "markdown", "id": "ad0f94d1", "metadata": { "lines_to_next_cell": 2 }, "source": [ "---\n", "## 2. Dynamics of synchronous Boolean networks\n", "\n", "Under *synchronous updating*, all nodes are updated simultaneously, defining\n", "a deterministic update map\n", "\n", "$$\n", "\\mathbf{x}(t+1) = F(\\mathbf{x}(t)).\n", "$$" ] }, { "cell_type": "markdown", "id": "4c7642a7", "metadata": {}, "source": [ "### 2.1 Exact computation" ] }, { "cell_type": "code", "execution_count": 4, "id": "2a94cade", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:17.883288Z", "iopub.status.busy": "2026-01-12T19:19:17.883227Z", "iopub.status.idle": "2026-01-12T19:19:17.884984Z", "shell.execute_reply": "2026-01-12T19:19:17.884795Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 0 0] --> [0 0 0]\n", "[0 0 1] --> [0 1 0]\n", "[0 1 0] --> [1 0 1]\n", "[0 1 1] --> [1 1 1]\n", "[1 0 0] --> [0 1 0]\n", "[1 0 1] --> [0 1 0]\n", "[1 1 0] --> [1 1 1]\n", "[1 1 1] --> [1 1 1]\n" ] } ], "source": [ "for state in all_states:\n", " print(state, \"-->\", bn.update_network_synchronously(state))" ] }, { "cell_type": "markdown", "id": "20c99447", "metadata": {}, "source": [ "This output matches the synchronous truth table representation:" ] }, { "cell_type": "code", "execution_count": 5, "id": "e784b24e", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:17.885949Z", "iopub.status.busy": "2026-01-12T19:19:17.885890Z", "iopub.status.idle": "2026-01-12T19:19:18.580211Z", "shell.execute_reply": "2026-01-12T19:19:18.579992Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
x(t)y(t)z(t)x(t+1)y(t+1)z(t+1)
0000000
1001010
2010101
3011111
4100010
5101010
6110111
7111111
\n", "
" ], "text/plain": [ " x(t) y(t) z(t) x(t+1) y(t+1) z(t+1)\n", "0 0 0 0 0 0 0\n", "1 0 0 1 0 1 0\n", "2 0 1 0 1 0 1\n", "3 0 1 1 1 1 1\n", "4 1 0 0 0 1 0\n", "5 1 0 1 0 1 0\n", "6 1 1 0 1 1 1\n", "7 1 1 1 1 1 1" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bn.to_truth_table()" ] }, { "cell_type": "markdown", "id": "6dfa3680", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Each state has exactly one successor, so the dynamics consist of transient\n", "trajectories leading into *attractors* (steady states or cycles).\n", "\n", "In this example, the network has:\n", "\n", "- two steady states: $(0,0,0)$ and $(1,1,1)$,\n", "- one cyclic attractor of length 2: $(0,1,0) \\leftrightarrow (1,0,1)$." ] }, { "cell_type": "markdown", "id": "7bc99d37", "metadata": {}, "source": [ "### Exhaustive attractor computation" ] }, { "cell_type": "code", "execution_count": 6, "id": "6f206f0f", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:18.581495Z", "iopub.status.busy": "2026-01-12T19:19:18.581374Z", "iopub.status.idle": "2026-01-12T19:19:18.589102Z", "shell.execute_reply": "2026-01-12T19:19:18.588914Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "{'Attractors': [[0], [2, 5], [7]],\n", " 'NumberOfAttractors': 3,\n", " 'BasinSizes': array([0.125, 0.5 , 0.375]),\n", " 'AttractorID': array([0, 1, 1, 2, 1, 1, 2, 2], dtype=int32),\n", " 'STG': array([0, 2, 5, 7, 2, 2, 7, 7])}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_attractors_synchronous_exact()\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "9005b36d", "metadata": {}, "source": [ "The returned dictionary contains:\n", "\n", "- `STG`: the synchronous state transition graph,\n", "- `NumberOfAttractors`,\n", "- `Attractors`,\n", "- `AttractorDict`,\n", "- `BasinSizes`.\n", "\n", "The state transition graph can be decoded as follows:" ] }, { "cell_type": "code", "execution_count": 7, "id": "d625018c", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:18.590099Z", "iopub.status.busy": "2026-01-12T19:19:18.590023Z", "iopub.status.idle": "2026-01-12T19:19:18.591739Z", "shell.execute_reply": "2026-01-12T19:19:18.591525Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 = [0, 0, 0] --> 0 = [0, 0, 0]\n", "1 = [0, 0, 1] --> 2 = [0, 1, 0]\n", "2 = [0, 1, 0] --> 5 = [1, 0, 1]\n", "3 = [0, 1, 1] --> 7 = [1, 1, 1]\n", "4 = [1, 0, 0] --> 2 = [0, 1, 0]\n", "5 = [1, 0, 1] --> 2 = [0, 1, 0]\n", "6 = [1, 1, 0] --> 7 = [1, 1, 1]\n", "7 = [1, 1, 1] --> 7 = [1, 1, 1]\n" ] } ], "source": [ "for state in range(2 ** bn.N):\n", " next_state = dict_dynamics[\"STG\"][state]\n", " print(\n", " state,\n", " \"=\",\n", " boolforge.dec2bin(state, bn.N),\n", " \"-->\",\n", " next_state,\n", " \"=\",\n", " boolforge.dec2bin(next_state, bn.N),\n", " )" ] }, { "cell_type": "markdown", "id": "71ada354", "metadata": {}, "source": [ "Attractors can be printed in binary representation:" ] }, { "cell_type": "code", "execution_count": 8, "id": "706db19e", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:18.592727Z", "iopub.status.busy": "2026-01-12T19:19:18.592663Z", "iopub.status.idle": "2026-01-12T19:19:18.594160Z", "shell.execute_reply": "2026-01-12T19:19:18.593978Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Attractor of length 1:\n", "0 [0, 0, 0]\n", "\n", "Attractor of length 2:\n", "2 [0, 1, 0]\n", "5 [1, 0, 1]\n", "\n", "Attractor of length 1:\n", "7 [1, 1, 1]\n", "\n" ] } ], "source": [ "for attractor in dict_dynamics[\"Attractors\"]:\n", " print(f\"Attractor of length {len(attractor)}:\")\n", " for state in attractor:\n", " print(state, boolforge.dec2bin(state, bn.N))\n", " print()" ] }, { "cell_type": "markdown", "id": "b169685a", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Basin sizes count how many states flow into each attractor.\n", "They always sum to $2^N$." ] }, { "cell_type": "markdown", "id": "5aac0e8a", "metadata": {}, "source": [ "### 2.2 Monte Carlo simulation\n", "\n", "For larger networks, exhaustive enumeration is infeasible.\n", "Monte Carlo simulation approximates the attractor landscape." ] }, { "cell_type": "code", "execution_count": 9, "id": "6d5bbf19", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:18.595203Z", "iopub.status.busy": "2026-01-12T19:19:18.595121Z", "iopub.status.idle": "2026-01-12T19:19:18.904337Z", "shell.execute_reply": "2026-01-12T19:19:18.904114Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "{'Attractors': [[2, 5], [7], [0]],\n", " 'NumberOfAttractors': 3,\n", " 'BasinSizes': [62, 28, 10],\n", " 'AttractorDict': {2: 0, 5: 0, 4: 0, 1: 0, 7: 1, 3: 1, 6: 1, 0: 2},\n", " 'InitialSamplePoints': [1,\n", " 4,\n", " 4,\n", " 2,\n", " 1,\n", " 6,\n", " 2,\n", " 3,\n", " 2,\n", " 5,\n", " 1,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 7,\n", " 4,\n", " 3,\n", " 7,\n", " 6,\n", " 4,\n", " 4,\n", " 6,\n", " 1,\n", " 0,\n", " 0,\n", " 1,\n", " 4,\n", " 2,\n", " 5,\n", " 4,\n", " 4,\n", " 7,\n", " 2,\n", " 0,\n", " 7,\n", " 4,\n", " 0,\n", " 1,\n", " 6,\n", " 4,\n", " 1,\n", " 1,\n", " 0,\n", " 5,\n", " 5,\n", " 2,\n", " 4,\n", " 0,\n", " 2,\n", " 7,\n", " 4,\n", " 7,\n", " 2,\n", " 6,\n", " 1,\n", " 5,\n", " 7,\n", " 5,\n", " 7,\n", " 2,\n", " 2,\n", " 5,\n", " 1,\n", " 0,\n", " 5,\n", " 3,\n", " 3,\n", " 7,\n", " 0,\n", " 1,\n", " 0,\n", " 2,\n", " 5,\n", " 2,\n", " 7,\n", " 6,\n", " 6,\n", " 4,\n", " 6,\n", " 2,\n", " 1,\n", " 0,\n", " 5,\n", " 2,\n", " 2,\n", " 3,\n", " 1,\n", " 5,\n", " 6,\n", " 6,\n", " 7,\n", " 2,\n", " 2,\n", " 5,\n", " 5,\n", " 4,\n", " 3,\n", " 6,\n", " 4],\n", " 'STG': {1: 2, 4: 2, 2: 5, 6: 7, 3: 7, 5: 2, 7: 7, 0: 0},\n", " 'NumberOfTimeouts': 0}" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_attractors_synchronous(nsim=100)\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "d7c05667", "metadata": {}, "source": [ "The simulation returns additional information:\n", "\n", "- sampled initial states,\n", "- the number of timeouts (trajectories not reaching an attractor in time).\n", "\n", "If an attractor has relative basin size $q$, the probability that it is found\n", "after $m$ random initializations is $1 - (1-q)^m$." ] }, { "cell_type": "code", "execution_count": 10, "id": "bb5ab6b7", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:18.905549Z", "iopub.status.busy": "2026-01-12T19:19:18.905472Z", "iopub.status.idle": "2026-01-12T19:19:19.043640Z", "shell.execute_reply": "2026-01-12T19:19:19.043390Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "qs = [0.0001, 0.001, 0.01, 0.1]\n", "ms = np.logspace(0, 4, 1000)\n", "\n", "fig, ax = plt.subplots()\n", "for q in qs:\n", " ax.semilogx(ms, 1 - (1 - q) ** ms, label=str(q))\n", "\n", "ax.legend(title=r\"$q$\", frameon=False)\n", "ax.set_xlabel(\"number of initial states ($m$)\")\n", "ax.set_ylabel(\"probability attractor is found\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a395359b", "metadata": { "lines_to_next_cell": 2 }, "source": [ "---\n", "## 3. Dynamics of asynchronous Boolean networks\n", "\n", "Synchronous updating is computationally convenient but biologically unrealistic.\n", "Asynchronous updating assumes that only one node is updated at a time." ] }, { "cell_type": "markdown", "id": "be99812f", "metadata": {}, "source": [ "### 3.1 Steady states under general asynchronous update\n", "\n", "BoolForge can compute steady states under general asynchronous updating." ] }, { "cell_type": "code", "execution_count": 11, "id": "165c6ced", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:19.044875Z", "iopub.status.busy": "2026-01-12T19:19:19.044801Z", "iopub.status.idle": "2026-01-12T19:19:19.047632Z", "shell.execute_reply": "2026-01-12T19:19:19.047415Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "{'SteadyStates': [0, 7],\n", " 'NumberOfSteadyStates': 2,\n", " 'BasinSizes': array([0.33333333, 0.66666667]),\n", " 'STGAsynchronous': {0: {0: np.float64(1.0)},\n", " 1: {1: np.float64(0.3333333333333333),\n", " 3: np.float64(0.3333333333333333),\n", " 0: np.float64(0.3333333333333333)},\n", " 2: {6: np.float64(0.3333333333333333),\n", " 0: np.float64(0.3333333333333333),\n", " 3: np.float64(0.3333333333333333)},\n", " 3: {7: np.float64(0.3333333333333333), 3: np.float64(0.6666666666666666)},\n", " 4: {0: np.float64(0.3333333333333333),\n", " 6: np.float64(0.3333333333333333),\n", " 4: np.float64(0.3333333333333333)},\n", " 5: {1: np.float64(0.3333333333333333),\n", " 7: np.float64(0.3333333333333333),\n", " 4: np.float64(0.3333333333333333)},\n", " 6: {6: np.float64(0.6666666666666666), 7: np.float64(0.3333333333333333)},\n", " 7: {7: np.float64(1.0)}},\n", " 'FinalTransitionProbabilities': array([[1. , 0. ],\n", " [0.5 , 0.5 ],\n", " [0.33333333, 0.66666667],\n", " [0. , 1. ],\n", " [0.5 , 0.5 ],\n", " [0.33333333, 0.66666667],\n", " [0. , 1. ],\n", " [0. , 1. ]])}" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous_exact()\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "1600d375", "metadata": { "lines_to_next_cell": 2 }, "source": [ "This reveals the same two steady states as in the synchronous case.\n", "In addition, the full asynchronous transition graph and absorption\n", "probabilities are returned.\n", "\n", "BoolForge currently does not detect complex cyclic attractors under\n", "asynchronous updating; for those, specialized tools such as\n", "`pystablemotifs` are recommended." ] }, { "cell_type": "markdown", "id": "e7794a2a", "metadata": {}, "source": [ "### Monte Carlo approximation" ] }, { "cell_type": "code", "execution_count": 12, "id": "f4920827", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:19.048744Z", "iopub.status.busy": "2026-01-12T19:19:19.048664Z", "iopub.status.idle": "2026-01-12T19:19:19.055696Z", "shell.execute_reply": "2026-01-12T19:19:19.055497Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "{'SteadyStates': [0, 7],\n", " 'NumberOfSteadyStates': 2,\n", " 'BasinSizes': [161, 339],\n", " 'STGAsynchronous': {(2, 1): 0,\n", " (0, 1): 0,\n", " (0, 0): 0,\n", " (0, 2): 0,\n", " (1, 2): 0,\n", " (6, 1): 6,\n", " (6, 0): 6,\n", " (6, 2): 7,\n", " (7, 2): 7,\n", " (7, 0): 7,\n", " (7, 1): 7,\n", " (1, 1): 3,\n", " (3, 1): 3,\n", " (3, 0): 7,\n", " (2, 0): 6,\n", " (4, 1): 6,\n", " (3, 2): 3,\n", " (2, 2): 3,\n", " (5, 1): 7,\n", " (4, 0): 0,\n", " (4, 2): 4,\n", " (1, 0): 1,\n", " (5, 2): 4,\n", " (5, 0): 1},\n", " 'InitialSamplePoints': [2,\n", " 1,\n", " 6,\n", " 1,\n", " 2,\n", " 2,\n", " 4,\n", " 7,\n", " 6,\n", " 7,\n", " 2,\n", " 2,\n", " 2,\n", " 0,\n", " 1,\n", " 3,\n", " 0,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 5,\n", " 6,\n", " 0,\n", " 4,\n", " 2,\n", " 7,\n", " 4,\n", " 1,\n", " 4,\n", " 1,\n", " 2,\n", " 3,\n", " 7,\n", " 2,\n", " 2,\n", " 1,\n", " 3,\n", " 6,\n", " 0,\n", " 4,\n", " 3,\n", " 3,\n", " 3,\n", " 6,\n", " 6,\n", " 5,\n", " 5,\n", " 6,\n", " 3,\n", " 7,\n", " 4,\n", " 7,\n", " 5,\n", " 2,\n", " 5,\n", " 1,\n", " 7,\n", " 4,\n", " 1,\n", " 4,\n", " 4,\n", " 3,\n", " 6,\n", " 6,\n", " 4,\n", " 6,\n", " 7,\n", " 7,\n", " 0,\n", " 2,\n", " 7,\n", " 0,\n", " 1,\n", " 7,\n", " 5,\n", " 4,\n", " 5,\n", " 1,\n", " 3,\n", " 7,\n", " 6,\n", " 5,\n", " 6,\n", " 5,\n", " 4,\n", " 1,\n", " 6,\n", " 0,\n", " 7,\n", " 3,\n", " 4,\n", " 0,\n", " 4,\n", " 5,\n", " 0,\n", " 6,\n", " 2,\n", " 6,\n", " 0,\n", " 7,\n", " 2,\n", " 1,\n", " 6,\n", " 4,\n", " 6,\n", " 1,\n", " 1,\n", " 2,\n", " 5,\n", " 1,\n", " 6,\n", " 4,\n", " 2,\n", " 0,\n", " 4,\n", " 2,\n", " 1,\n", " 4,\n", " 7,\n", " 0,\n", " 3,\n", " 4,\n", " 7,\n", " 2,\n", " 7,\n", " 1,\n", " 2,\n", " 5,\n", " 5,\n", " 7,\n", " 2,\n", " 6,\n", " 5,\n", " 5,\n", " 4,\n", " 0,\n", " 5,\n", " 0,\n", " 3,\n", " 6,\n", " 5,\n", " 1,\n", " 0,\n", " 6,\n", " 0,\n", " 0,\n", " 4,\n", " 7,\n", " 4,\n", " 7,\n", " 1,\n", " 4,\n", " 3,\n", " 6,\n", " 6,\n", " 1,\n", " 2,\n", " 1,\n", " 4,\n", " 0,\n", " 6,\n", " 7,\n", " 2,\n", " 2,\n", " 6,\n", " 4,\n", " 0,\n", " 6,\n", " 6,\n", " 2,\n", " 4,\n", " 2,\n", " 5,\n", " 2,\n", " 5,\n", " 3,\n", " 0,\n", " 0,\n", " 4,\n", " 1,\n", " 5,\n", " 3,\n", " 6,\n", " 3,\n", " 7,\n", " 2,\n", " 3,\n", " 4,\n", " 2,\n", " 7,\n", " 0,\n", " 4,\n", " 1,\n", " 0,\n", " 7,\n", " 6,\n", " 2,\n", " 7,\n", " 5,\n", " 1,\n", " 1,\n", " 1,\n", " 7,\n", " 6,\n", " 3,\n", " 0,\n", " 2,\n", " 4,\n", " 7,\n", " 2,\n", " 5,\n", " 7,\n", " 0,\n", " 1,\n", " 5,\n", " 2,\n", " 0,\n", " 3,\n", " 2,\n", " 6,\n", " 7,\n", " 3,\n", " 6,\n", " 3,\n", " 3,\n", " 0,\n", " 0,\n", " 3,\n", " 2,\n", " 7,\n", " 2,\n", " 5,\n", " 0,\n", " 0,\n", " 3,\n", " 1,\n", " 3,\n", " 2,\n", " 6,\n", " 0,\n", " 1,\n", " 4,\n", " 0,\n", " 4,\n", " 0,\n", " 2,\n", " 3,\n", " 1,\n", " 7,\n", " 5,\n", " 7,\n", " 2,\n", " 0,\n", " 3,\n", " 1,\n", " 2,\n", " 2,\n", " 5,\n", " 7,\n", " 1,\n", " 1,\n", " 4,\n", " 4,\n", " 7,\n", " 4,\n", " 6,\n", " 1,\n", " 7,\n", " 3,\n", " 1,\n", " 1,\n", " 5,\n", " 0,\n", " 7,\n", " 5,\n", " 3,\n", " 6,\n", " 2,\n", " 0,\n", " 4,\n", " 5,\n", " 0,\n", " 1,\n", " 2,\n", " 6,\n", " 2,\n", " 2,\n", " 0,\n", " 7,\n", " 7,\n", " 6,\n", " 4,\n", " 5,\n", " 3,\n", " 5,\n", " 2,\n", " 1,\n", " 7,\n", " 6,\n", " 3,\n", " 4,\n", " 7,\n", " 5,\n", " 3,\n", " 6,\n", " 0,\n", " 7,\n", " 6,\n", " 2,\n", " 6,\n", " 7,\n", " 4,\n", " 4,\n", " 2,\n", " 6,\n", " 1,\n", " 5,\n", " 1,\n", " 0,\n", " 6,\n", " 5,\n", " 3,\n", " 6,\n", " 7,\n", " 4,\n", " 1,\n", " 1,\n", " 5,\n", " 5,\n", " 4,\n", " 2,\n", " 3,\n", " 1,\n", " 1,\n", " 7,\n", " 0,\n", " 5,\n", " 2,\n", " 0,\n", " 3,\n", " 2,\n", " 5,\n", " 6,\n", " 7,\n", " 7,\n", " 6,\n", " 1,\n", " 7,\n", " 3,\n", " 3,\n", " 4,\n", " 0,\n", " 3,\n", " 0,\n", " 3,\n", " 3,\n", " 2,\n", " 6,\n", " 2,\n", " 2,\n", " 5,\n", " 7,\n", " 2,\n", " 5,\n", " 2,\n", " 3,\n", " 5,\n", " 3,\n", " 5,\n", " 4,\n", " 0,\n", " 0,\n", " 7,\n", " 3,\n", " 3,\n", " 5,\n", " 3,\n", " 5,\n", " 5,\n", " 3,\n", " 2,\n", " 4,\n", " 1,\n", " 5,\n", " 4,\n", " 4,\n", " 6,\n", " 6,\n", " 1,\n", " 0,\n", " 2,\n", " 4,\n", " 3,\n", " 3,\n", " 5,\n", " 4,\n", " 5,\n", " 7,\n", " 6,\n", " 1,\n", " 0,\n", " 1,\n", " 5,\n", " 5,\n", " 7,\n", " 5,\n", " 6,\n", " 6,\n", " 7,\n", " 4,\n", " 6,\n", " 3,\n", " 0,\n", " 6,\n", " 2,\n", " 6,\n", " 0,\n", " 1,\n", " 4,\n", " 5,\n", " 5,\n", " 5,\n", " 3,\n", " 7,\n", " 5,\n", " 5,\n", " 4,\n", " 6,\n", " 3,\n", " 4,\n", " 2,\n", " 1,\n", " 4,\n", " 2,\n", " 5,\n", " 4,\n", " 6,\n", " 5,\n", " 0,\n", " 2,\n", " 6,\n", " 6,\n", " 6,\n", " 3,\n", " 7,\n", " 2,\n", " 1,\n", " 0,\n", " 3,\n", " 7,\n", " 2,\n", " 0,\n", " 5,\n", " 1,\n", " 4,\n", " 1,\n", " 0,\n", " 7,\n", " 7,\n", " 3,\n", " 1,\n", " 6,\n", " 7,\n", " 2,\n", " 3,\n", " 1,\n", " 5,\n", " 0,\n", " 7,\n", " 0,\n", " 2,\n", " 2,\n", " 7,\n", " 5,\n", " 2,\n", " 4,\n", " 2,\n", " 2,\n", " 4,\n", " 0,\n", " 1,\n", " 3,\n", " 4,\n", " 5,\n", " 6,\n", " 7,\n", " 6,\n", " 1,\n", " 4,\n", " 5,\n", " 7,\n", " 3,\n", " 3,\n", " 4,\n", " 1,\n", " 3,\n", " 3,\n", " 7]}" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous(nsim=500)\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "8a3c848e", "metadata": { "lines_to_next_cell": 2 }, "source": [ "The simulation provides:\n", "\n", "- a lower bound on the number of steady states,\n", "- approximate basin size distributions,\n", "- samples of the asynchronous state transition graph." ] }, { "cell_type": "markdown", "id": "492d2ffb", "metadata": {}, "source": [ "### Sampling from a fixed initial condition" ] }, { "cell_type": "code", "execution_count": 13, "id": "451df9c7", "metadata": { "execution": { "iopub.execute_input": "2026-01-12T19:19:19.056766Z", "iopub.status.busy": "2026-01-12T19:19:19.056696Z", "iopub.status.idle": "2026-01-12T19:19:19.069833Z", "shell.execute_reply": "2026-01-12T19:19:19.069620Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { "text/plain": [ "{'SteadyStates': [7, 0],\n", " 'NumberOfSteadyStates': 2,\n", " 'BasinSizes': [252, 248],\n", " 'TransientTimes': [[2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2,\n", " 2],\n", " [1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1,\n", " 1]],\n", " 'STGAsynchronous': {(1, 0): 1,\n", " (1, 1): 3,\n", " (3, 1): 3,\n", " (3, 0): 7,\n", " (7, 0): 7,\n", " (7, 1): 7,\n", " (7, 2): 7,\n", " (1, 2): 0,\n", " (0, 2): 0,\n", " (0, 1): 0,\n", " (0, 0): 0,\n", " (3, 2): 3},\n", " 'UpdateQueues': [[1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0],\n", " [1, 0],\n", " [1, 3, 7],\n", " [1, 0]]}" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous_given_one_initial_condition(\n", " initial_condition=[0, 0, 1], nsim=500\n", ")\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "6c5527c5", "metadata": {}, "source": [ "---\n", "## Summary and outlook\n", "\n", "In this tutorial you learned how to:\n", "\n", "- simulate Boolean network dynamics,\n", "- compute synchronous attractors exactly and approximately,\n", "- analyze basin sizes,\n", "- compute steady states under asynchronous updating.\n", "\n", "This concludes the function- and network-level analysis.\n", "Subsequent work focuses on large-scale dynamical analysis,\n", "perturbations, and stability in Boolean network models." ] } ], "metadata": { "jupytext": { "cell_metadata_filter": "-all", "main_language": "python", "notebook_metadata_filter": "-all" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 5 }