{ "cells": [ { "cell_type": "markdown", "id": "0754a39f", "metadata": {}, "source": [ "# 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 characterizing the long-term behavior of Boolean networks.\n", "\n", "## What you will learn\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", "## Setup" ] }, { "cell_type": "code", "execution_count": 1, "id": "27654b54", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:04.925740Z", "iopub.status.busy": "2026-03-14T21:36:04.925449Z", "iopub.status.idle": "2026-03-14T21:36:06.229478Z", "shell.execute_reply": "2026-03-14T21:36:06.229108Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "import boolforge as bf\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "id": "e1c53189", "metadata": {}, "source": [ "## 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": "5efccf84", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:06.231703Z", "iopub.status.busy": "2026-03-14T21:36:06.231491Z", "iopub.status.idle": "2026-03-14T21:36:06.234568Z", "shell.execute_reply": "2026-03-14T21:36:06.234301Z" }, "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:\n", " F[0] = BooleanFunction(name='x', f=[0, 1])\n", " F[1] = BooleanFunction(name='y', f=[0, 1, 1, 1])\n", " F[2] = BooleanFunction(name='z', f=[0, 1])\n" ] } ], "source": [ "string = \"\"\"\n", "x = y\n", "y = x OR z\n", "z = y\n", "\"\"\"\n", "\n", "bn = bf.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:\")\n", "for i, f in enumerate(bn.F):\n", " print(f\" F[{i}] = {f!r}\")" ] }, { "cell_type": "markdown", "id": "ff40f5b4", "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": "79f96501", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:06.235963Z", "iopub.status.busy": "2026-03-14T21:36:06.235865Z", "iopub.status.idle": "2026-03-14T21:36:06.240626Z", "shell.execute_reply": "2026-03-14T21:36:06.240358Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 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\n" ] } ], "source": [ "all_states = bf.get_left_side_of_truth_table(bn.N)\n", "print(pd.DataFrame(all_states, columns=bn.variables).to_string())" ] }, { "cell_type": "markdown", "id": "f5ed7b43", "metadata": { "lines_to_next_cell": 2 }, "source": [ "## 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": "950011cf", "metadata": {}, "source": [ "### Exact computation\n", "The update map $F$ can be evaluated directly for any state vector. In BoolForge,\n", "this is implemented by the method `update_network_synchronously`. For convenience,\n", "Boolean networks are callable, so that `bn(state)` evaluates the update map and\n", "is equivalent to `bn.update_network_synchronously(state)`." ] }, { "cell_type": "code", "execution_count": 4, "id": "16ab07b3", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:06.242053Z", "iopub.status.busy": "2026-03-14T21:36:06.241948Z", "iopub.status.idle": "2026-03-14T21:36:06.244274Z", "shell.execute_reply": "2026-03-14T21:36:06.244044Z" }, "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(state))" ] }, { "cell_type": "markdown", "id": "e370deac", "metadata": {}, "source": [ "This output matches the synchronous truth table representation:" ] }, { "cell_type": "code", "execution_count": 5, "id": "236d7a50", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:06.245487Z", "iopub.status.busy": "2026-03-14T21:36:06.245406Z", "iopub.status.idle": "2026-03-14T21:36:07.300579Z", "shell.execute_reply": "2026-03-14T21:36:07.300263Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 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\n" ] } ], "source": [ "print(bn.to_truth_table().to_string())" ] }, { "cell_type": "markdown", "id": "fce3acc2", "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": "0eec253e", "metadata": {}, "source": [ "### Exhaustive attractor computation\n", "BoolForge contains a dedicated method to identify all attractors of a network\n", "under synchronous update." ] }, { "cell_type": "code", "execution_count": 6, "id": "f0ebee4f", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.302146Z", "iopub.status.busy": "2026-03-14T21:36:07.301975Z", "iopub.status.idle": "2026-03-14T21:36:07.308146Z", "shell.execute_reply": "2026-03-14T21:36:07.307877Z" }, "lines_to_next_cell": 2 }, "outputs": [], "source": [ "dict_dynamics = bn.get_attractors_synchronous_exact()" ] }, { "cell_type": "markdown", "id": "8b715090", "metadata": {}, "source": [ "The returned dictionary contains:\n", "\n", "- `STG`: the synchronous state transition graph,\n", "- `NumberOfAttractors`,\n", "- `Attractors`,\n", "- `AttractorID`,\n", "- `BasinSizes`.\n", "\n", "For computational reasons, binary states in $\\{0,1\\}^N$ are identified by their decimal representation.\n", "The state transition graph can be decoded as follows:" ] }, { "cell_type": "code", "execution_count": 7, "id": "060f3d87", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.309410Z", "iopub.status.busy": "2026-03-14T21:36:07.309325Z", "iopub.status.idle": "2026-03-14T21:36:07.311362Z", "shell.execute_reply": "2026-03-14T21:36:07.311124Z" } }, "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", " bf.dec2bin(state, bn.N),\n", " \"-->\",\n", " next_state,\n", " \"=\",\n", " bf.dec2bin(next_state, bn.N),\n", " )" ] }, { "cell_type": "markdown", "id": "f12affbc", "metadata": {}, "source": [ "After repeated updates, the system settles into periodic behavior. That is,\n", "irrespective of the initial state, an attractor is reached. The list\n", "of all attractors (in decimal representation) can be displayed. " ] }, { "cell_type": "code", "execution_count": 8, "id": "bac21604", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.312576Z", "iopub.status.busy": "2026-03-14T21:36:07.312501Z", "iopub.status.idle": "2026-03-14T21:36:07.314055Z", "shell.execute_reply": "2026-03-14T21:36:07.313800Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0], [2, 5], [7]]\n" ] } ], "source": [ "print(dict_dynamics['Attractors'])" ] }, { "cell_type": "markdown", "id": "d1919842", "metadata": {}, "source": [ "Attractors can be printed in binary representation:" ] }, { "cell_type": "code", "execution_count": 9, "id": "8290d98b", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.315223Z", "iopub.status.busy": "2026-03-14T21:36:07.315141Z", "iopub.status.idle": "2026-03-14T21:36:07.316896Z", "shell.execute_reply": "2026-03-14T21:36:07.316662Z" } }, "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, bf.dec2bin(state, bn.N))\n", " print()" ] }, { "cell_type": "markdown", "id": "62767d89", "metadata": {}, "source": [ "The information which state transitions to which attractor is stored in a dictionary.\n", "Here, the indices correspond to the list of attractors in `dict_dynamics['Attractors']`." ] }, { "cell_type": "code", "execution_count": 10, "id": "8077b40e", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.318129Z", "iopub.status.busy": "2026-03-14T21:36:07.318055Z", "iopub.status.idle": "2026-03-14T21:36:07.319768Z", "shell.execute_reply": "2026-03-14T21:36:07.319550Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 --> attractor 0 which is [0]\n", "1 --> attractor 1 which is [2, 5]\n", "2 --> attractor 1 which is [2, 5]\n", "3 --> attractor 2 which is [7]\n", "4 --> attractor 1 which is [2, 5]\n", "5 --> attractor 1 which is [2, 5]\n", "6 --> attractor 2 which is [7]\n", "7 --> attractor 2 which is [7]\n" ] } ], "source": [ "for state_dec,attr_id in enumerate(dict_dynamics['AttractorID']):\n", " print(state_dec,'--> attractor',attr_id,\n", " 'which is',dict_dynamics['Attractors'][attr_id])" ] }, { "cell_type": "markdown", "id": "c16c299b", "metadata": {}, "source": [ "Finally, the basin size of each attractor is determined by the number of states that eventually transition to an attractor.\n", "By definition, the sum of all basin sizes is always $2^N$. To simplify the comparison of\n", "the basin size distribution for networks of different size, `BoolForge` normalizes the basin sizes by default." ] }, { "cell_type": "code", "execution_count": 11, "id": "6d656890", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.320973Z", "iopub.status.busy": "2026-03-14T21:36:07.320881Z", "iopub.status.idle": "2026-03-14T21:36:07.322598Z", "shell.execute_reply": "2026-03-14T21:36:07.322385Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.125 0.5 0.375]\n" ] } ], "source": [ "print(dict_dynamics['BasinSizes'])" ] }, { "cell_type": "markdown", "id": "4cc5a55d", "metadata": {}, "source": [ "From the previous two outputs, we see that there is no state (other than 000) that eventually\n", "transitions to 000. Half the states transition to the 2-cycle, while 3 out of 8\n", "states transition to the attractor 111.\n", "\n", "### 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": 12, "id": "2e9249ef", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.323766Z", "iopub.status.busy": "2026-03-14T21:36:07.323691Z", "iopub.status.idle": "2026-03-14T21:36:07.747446Z", "shell.execute_reply": "2026-03-14T21:36:07.747165Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Discovered attractors: [[7], [2, 5], [0]]\n", "Basin size approximation: [0.347 0.533 0.12 ]\n" ] } ], "source": [ "dict_dynamics = bn.get_attractors_synchronous(n_simulations=1000)\n", "print('Discovered attractors:',dict_dynamics['Attractors'])\n", "print('Basin size approximation:',dict_dynamics['BasinSizesApproximation'])" ] }, { "cell_type": "markdown", "id": "97bb5fd5", "metadata": {}, "source": [ "The simulation returns additional information:\n", "\n", "- sampled initial states,\n", "- the number of timeouts (trajectories not reaching an attractor before timeout)." ] }, { "cell_type": "code", "execution_count": 13, "id": "b4764d0b", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.748787Z", "iopub.status.busy": "2026-03-14T21:36:07.748685Z", "iopub.status.idle": "2026-03-14T21:36:07.750477Z", "shell.execute_reply": "2026-03-14T21:36:07.750243Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Attractors\n", "NumberOfAttractorsLowerBound\n", "BasinSizesApproximation\n", "AttractorID\n", "InitialSamplePoints\n", "STG\n", "NumberOfTimeouts\n" ] } ], "source": [ "for key in dict_dynamics:\n", " print(key)" ] }, { "cell_type": "markdown", "id": "e3e040ec", "metadata": {}, "source": [ "In the absence of timeouts: If an attractor has relative basin size $q$, \n", "the probability that it is found from $m$ random initializations is $1 - (1-q)^m$." ] }, { "cell_type": "code", "execution_count": 14, "id": "aa9bf89b", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.751681Z", "iopub.status.busy": "2026-03-14T21:36:07.751602Z", "iopub.status.idle": "2026-03-14T21:36:07.940207Z", "shell.execute_reply": "2026-03-14T21:36:07.939938Z" }, "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 of basin size q is found\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "12670880", "metadata": { "lines_to_next_cell": 2 }, "source": [ "## Dynamics of asynchronous Boolean networks\n", "\n", "Synchronous updating is computationally convenient but biologically unrealistic.\n", "Asynchronous updating assumes that only one node changes at a time." ] }, { "cell_type": "markdown", "id": "6385e4bd", "metadata": {}, "source": [ "### Steady states under general asynchronous update\n", "\n", "BoolForge can compute steady states under **general asynchronous updating**,\n", "where at each step only a single node updates according to its Boolean rule." ] }, { "cell_type": "code", "execution_count": 15, "id": "1cf36365", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.941631Z", "iopub.status.busy": "2026-03-14T21:36:07.941534Z", "iopub.status.idle": "2026-03-14T21:36:07.943598Z", "shell.execute_reply": "2026-03-14T21:36:07.943377Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Discovered steady states: [0, 7]\n", "Number of steady states (lower bound): 2\n" ] } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous_exact()\n", "print('Discovered steady states:',dict_dynamics['SteadyStates'])\n", "print('Number of steady states (lower bound):',dict_dynamics['NumberOfSteadyStates'])" ] }, { "cell_type": "markdown", "id": "533226a5", "metadata": { "lines_to_next_cell": 2 }, "source": [ "The result reveals the same two steady states as in the synchronous case.\n", "However, the limit cycle observed under synchronous updating disappears\n", "under asynchronous dynamics.\n", "\n", "In addition, BoolForge returns the **full asynchronous state transition graph**." ] }, { "cell_type": "code", "execution_count": 16, "id": "90a12c7b", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.944833Z", "iopub.status.busy": "2026-03-14T21:36:07.944742Z", "iopub.status.idle": "2026-03-14T21:36:07.946429Z", "shell.execute_reply": "2026-03-14T21:36:07.946204Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 --> {0: 1.0}\n", "1 --> {1: 0.3333333333333333, 3: 0.3333333333333333, 0: 0.3333333333333333}\n", "2 --> {6: 0.3333333333333333, 0: 0.3333333333333333, 3: 0.3333333333333333}\n", "3 --> {7: 0.3333333333333333, 3: 0.6666666666666666}\n", "4 --> {0: 0.3333333333333333, 6: 0.3333333333333333, 4: 0.3333333333333333}\n", "5 --> {1: 0.3333333333333333, 7: 0.3333333333333333, 4: 0.3333333333333333}\n", "6 --> {6: 0.6666666666666666, 7: 0.3333333333333333}\n", "7 --> {7: 1.0}\n" ] } ], "source": [ "for state, successors in dict_dynamics[\"STGAsynchronous\"].items():\n", " print(state,'-->',successors)" ] }, { "cell_type": "markdown", "id": "b8fc5737", "metadata": {}, "source": [ "The state transition graph describes for each state the possible next states \n", "that the system may transition to, in addition to the transition probabilities. \n", "This graph can be interpreted as a **sparse transition matrix**\n", "of a Markov chain. Each directed edge corresponds to a possible single-node update.\n", "\n", "By repeatedly composing this transition matrix with itself (equivalently,\n", "raising it to higher powers), BoolForge computes the **absorption probabilities**,\n", "i.e., the probability that a trajectory starting from any state eventually\n", "reaches each steady state." ] }, { "cell_type": "code", "execution_count": 17, "id": "16eb415c", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.947657Z", "iopub.status.busy": "2026-03-14T21:36:07.947558Z", "iopub.status.idle": "2026-03-14T21:36:07.949619Z", "shell.execute_reply": "2026-03-14T21:36:07.949386Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[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. ]]\n" ] } ], "source": [ "print(dict_dynamics['FinalTransitionProbabilities'])" ] }, { "cell_type": "markdown", "id": "3083e284", "metadata": {}, "source": [ "The size of each basin of attraction is the (column-wise) average of these probabilities." ] }, { "cell_type": "code", "execution_count": 18, "id": "616b1b14", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.950801Z", "iopub.status.busy": "2026-03-14T21:36:07.950722Z", "iopub.status.idle": "2026-03-14T21:36:07.952593Z", "shell.execute_reply": "2026-03-14T21:36:07.952367Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Basin sizes: [0.33333333 0.66666667]\n" ] } ], "source": [ "assert np.all(dict_dynamics['BasinSizes'] == \n", " np.mean(dict_dynamics['FinalTransitionProbabilities'],0))\n", "print('Basin sizes:',dict_dynamics['BasinSizes'])" ] }, { "cell_type": "markdown", "id": "288028e9", "metadata": { "lines_to_next_cell": 2 }, "source": [ "Note that `BoolForge` currently does not detect complex cyclic attractors under\n", "asynchronous update; for this task, specialized tools such as\n", "[pystablemotifs](https://github.com/jcrozum/pystablemotifs) are recommended. \n", "\n", "In fact, some of BoolForge's asynchronous update methods fail when the network\n", "contains no steady state. " ] }, { "cell_type": "markdown", "id": "7f83a51b", "metadata": {}, "source": [ "### Monte Carlo approximation\n", "\n", "As in the synchronous case, `BoolForge` also contains a Monte Carlo routine\n", "for sampling asynchronous dynamics.\n", "\n", "The simulation provides:\n", "\n", "- a lower bound on the number of steady states,\n", "- approximate basin size distributions," ] }, { "cell_type": "code", "execution_count": 19, "id": "ee93a652", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.953792Z", "iopub.status.busy": "2026-03-14T21:36:07.953706Z", "iopub.status.idle": "2026-03-14T21:36:07.960132Z", "shell.execute_reply": "2026-03-14T21:36:07.959904Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Discovered steady states: [0, 7]\n", "Number of steady states (lower bound): 2\n", "Basin size approximation: [0.318 0.682]\n" ] } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous(n_simulations=500)\n", "print('Discovered steady states:', dict_dynamics['SteadyStates'])\n", "print('Number of steady states (lower bound):',dict_dynamics['NumberOfSteadyStatesLowerBound'])\n", "print('Basin size approximation:',dict_dynamics['BasinSizesApproximation'])" ] }, { "cell_type": "markdown", "id": "834527e7", "metadata": {}, "source": [ "### Sampling from a fixed initial condition\n", "In biological Boolean network models, a specific state $\\mathbf x \\in \\{0,1\\}^N$\n", "is frequently considered the initial state, e.g., corresponding to the G0 phase of the cell cylce.\n", "To enable exploration of the stochastic trajectories from a specific state, BoolForge\n", "contains the following method." ] }, { "cell_type": "code", "execution_count": 20, "id": "82cc30bd", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.961325Z", "iopub.status.busy": "2026-03-14T21:36:07.961244Z", "iopub.status.idle": "2026-03-14T21:36:07.966186Z", "shell.execute_reply": "2026-03-14T21:36:07.965904Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Discovered steady states: [7, 9, 0, 2]\n", "Number of steady states (lower bound): 4\n", "Basin size approximation: [0.158 0.162 0.512 0.168]\n" ] } ], "source": [ "dict_dynamics = bn.get_steady_states_asynchronous_given_one_initial_condition(\n", " initial_condition=[0, 0, 1], n_simulations=500\n", ")\n", "print('Discovered steady states:', dict_dynamics['SteadyStates'])\n", "print('Number of steady states (lower bound):',dict_dynamics['NumberOfSteadyStatesLowerBound'])\n", "print('Basin size approximation:',dict_dynamics['BasinSizesApproximation'])" ] }, { "cell_type": "markdown", "id": "def391de", "metadata": {}, "source": [ "Note the equivalent analysis under synchronous update is trivial because the dynamics\n", "are deterministic and the long-term behavior when starting in a specific initial\n", "condition can be found by" ] }, { "cell_type": "code", "execution_count": 21, "id": "20dcb338", "metadata": { "execution": { "iopub.execute_input": "2026-03-14T21:36:07.967355Z", "iopub.status.busy": "2026-03-14T21:36:07.967273Z", "iopub.status.idle": "2026-03-14T21:36:07.969861Z", "shell.execute_reply": "2026-03-14T21:36:07.969633Z" } }, "outputs": [ { "data": { "text/plain": [ "{'Attractors': [[2, 5]],\n", " 'NumberOfAttractorsLowerBound': 1,\n", " 'BasinSizesApproximation': array([1.]),\n", " 'AttractorID': {2: 0, 5: 0},\n", " 'InitialSamplePoints': [[0, 0, 1]],\n", " 'STG': {1: 2},\n", " 'NumberOfTimeouts': 0}" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dict_dynamics = bn.get_attractors_synchronous(n_simulations=1,\n", " initial_sample_points=[[0,0,1]],\n", " initial_sample_points_are_vectors=True)\n", "dict_dynamics" ] }, { "cell_type": "markdown", "id": "0b5bcb05", "metadata": {}, "source": [ "## Summary\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 tutorials focus on analyzing stability to perturbations, control analysis, \n", "and ensemble experiments." ] } ], "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 }