Tom/Gene-Regulatory-Networks-Seminar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

60% draft submission

Browse Source 
is not really 60% but close. includes the script for simulation.
This commit is contained in:
Tom Zuidberg
2026-05-17 23:52:07 +02:00
parent 1948cb6b11
commit 4a059b8451
4 changed files with 244 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
bn_example_table.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

75
bn_sim.py Normal file
View File

@@ -0,0 +1,75 @@
from itertools import product
funcs = [
lambda x1, x2, x3, x4: not x2,
lambda x1, x2, x3, x4: x1,
lambda x1, x2, x3, x4: x1 ^ x4,
lambda x1, x2, x3, x4: x3,
]
sequential_sync_funcs = [
lambda x1, x2, x3, x4: not x2,
lambda x1, x2, x3, x4: not x2,
lambda x1, x2, x3, x4: (not x2) ^ x4,
lambda x1, x2, x3, x4: (not x2) ^ x4,
]
nodes = []
def init(initial_state):
global nodes
nodes = [bool(i) for i in initial_state]
assert len(funcs) == len(nodes)
def synchronous_update():
global nodes, funcs
temp = nodes.copy()
for i in range(len(funcs)):
temp[i] = funcs[i](*nodes)
nodes = temp
def sequential_update(order):
global nodes, funcs
assert len(order) == len(nodes)
for i in order:
nodes[i] = funcs[i](*nodes)
def state_to_str():
return "".join(str(int(i)) for i in nodes)
def simulate(initial_state):
print("press ENTER to simulate one step. press 'q' before ENTER to exit")
init(initial_state)
state = state_to_str()
while input() != "q":
update()
print(state + " -> " + state_to_str(), end="")
def get_table():
for i in product((0, 1), repeat=4):
init(tuple(i))
state = state_to_str()
update()
print(state + " -> " + state_to_str())
def update():
return synchronous_update()
return sequential_update([0, 1, 2, 3])
# return block_sequential_update(...)
# return asynchronous_deterministic_update(...)
def main():
get_table()
if __name__ == "__main__":
main()

BIN
paper.pdf
View File

Binary file not shown.

191
paper.tex
View File

@@ -24,6 +24,8 @@
\usepackage{tikz}
% You can define your own commands. This is useful for shorthands, for example
\newcommand{\EE}{\mathbb{E}}
\newcommand{\RR}{\mathbb{R}}
@@ -74,15 +76,17 @@
\section{Introduction}
Possible points to mention here:
\begin{itemize}
\item Explain shortly gene regulatory networks (GRN)
\item Explain why boolean networks are used to model GRN
\item Maybe mention history of boolean networks
\item Set the focus to the update scheme as it seems to be rarely covered in the field of GRNs
\item Possible open question about which update scheme might be best to model GRNs. Answer to this must follow in the conclusion
\end{itemize}
Boolean networks were first introduced by Stuart Kauffman in the late 1960s as a simplified model of biochemical systems \cite{helikar2011boolean}. In this framework, genes or regulatory components are represented as binary variables, whose states evolve according to logical functions encoding regulatory interactions. Despite their simplicity, boolean networks have proven useful for capturing qualitative dynamical behavior in complex biochemical systems and have since become a standard tool of modeling in this field.
A key abstraction in Boolean network modeling is the representation of dynamics via a state graph, where nodes correspond to network states and directed edges represent transitions induced by update functions. The long term behavior of the network is typically described in terms of attractors in this graph, which are often interpreted as stable cellular or functional states \cite{helikar2011boolean}.
When it comes to modeling a system, the choice of the update scheme for the boolean network takes an important role as it defines how and when individual parts of the network change. Most common schemes are synchronous scheme, where all nodes update synchronously, asynchronous scheme, where only individual nodes are updated, sequential and probabilistic which introduces randomness into the system.
The choice of an update scheme will lead to a different behavior, in particular other attractors and cycles, change in reachability and change in robustness with regards to perturbations.
In the following, we will introduce different update scheme and their respective change on a network illustrated on examples and figure out the best use case for each scheme.
\todo[inline]{use more \textbf{references}!}
\section{Boolean networks}
\label{sec:bn}
@@ -138,13 +142,25 @@ A boolean network consists of nodes $x_i(t)$ that have a boolean state, either $
\end{tikzpicture}
\caption{Example of a boolean network with four nodes. Each vertex indicates that a node is part of the update function of the other node. For instance $x_1$ is part of $f_2$ and $f_3$.
\caption{Example of a boolean network with four nodes. Each vertex indicates that a node is part of the update function of the other node. For instance $x_1$ is part of $f_2$ and $f_3$. Note that $\neg$ means the logical NOT and $\oplus$ means the logical XOR function.
}
\label{fig:bn_example}
\end{figure}
Consider the boolean network shown in \cref{fig:bn_example}. Assume the current state is $0011$, meaning that $x_1, x_2$ are $0$ and $x_3, x_4$ are $1$. The next state when applying the update function all at once is $1011$. Updating the network multiple times creates a trajectory, which is the sequence of the states starting from the initial state. With our example, the trajectory is $0011 \rightarrow 1011 \rightarrow 1101 \rightarrow 0100 \rightarrow \ldots$. Each trajectory in a reasonably small boolean network eventually reaches one of two scenarios. Either it falls into a state, called attractor, that doesn't change when updated, or it falls into a cycle of states. In the example, there are 2 cycles of length 8 visible in \cref{fig:bn_syn_state_graph}.
In boolean networks, robustness refers to stability of the behavior with regards to perturbations, e.g. a single node state change. A boolean network with poor robustness means that a simple flip of a node can change the resulting attractor, respectively cycle for that trajectory. In regards to our example, if either $x_3$ or $x_4$ (not both at once) is flipped, the cycle switches. A strong robustness however would mean that even with such perturbations, the resulting attractor or cycle doesn't change.
\todo[inline]{currently feels to short. once introduction is implemented, create a better transition/section 2 introduction. Also introduce robustness!}
\todo[inline]{combine figure 1, 2, 3 into a single figure* (page-width figure), or split the table from figure 2 into to parts of 8 states}
\begin{figure}
\centering
\includegraphics[height=7cm]{bn_example_table.png}
\caption{State transitions for all states of the boolean network from \cref{fig:bn_example} using synchronous update scheme once.}
\label{fig:bn_state_table}
\end{figure}
\begin{figure}
@@ -250,31 +266,157 @@ Consider the boolean network shown in \cref{fig:bn_example}. Assume the current
Explain different update schemes including characteristics for behavior especially chaotic behavior. These will mostly focus on boolean networks only. Maybe mention of use-cases for each update scheme.
\todo[inline]{update this text.. (or remove it)}
\subsection{Synchronous scheme}
In \cref{sec:bn}, we have used the synchronous update scheme to introduce the workings of boolean networks. This scheme assumes that each update function takes the exact same amount of time and executes at the same time, meaning regardless of the outcome of the first function, any other function will have the same result. Updating the network with this method is on one side quite simple, deterministic and doesn't require a lot of computing power in order to simulate larger networks, as each state of the network results in exactly on updated state. In regards to gene regulatory networks, this is an oversimplification as normal GRNs never execute fully synchronously.
In \cref{sec:bn}, we have used the synchronous update scheme to introduce the workings of boolean networks. This scheme assumes that each update function takes the exact same amount of time and executes at the same time, meaning regardless of the outcome of the first function, any other function will have the same result. Updating the network with this method is quite simple, deterministic and doesn't require a lot of computing power in order to simulate larger networks, as each state of the network results in exactly on updated state. In regards to gene regulatory networks however, this is an oversimplification as normal GRNs never execute fully synchronously. Furthermore, the change of one node has no effect on any other function, whereas larger biochemical system often show dependencies between functions.
\todo[inline]{add more context and information about grn and their effects, split text into logical paragraphs}
\subsection{Sequential scheme}
When using the sequential update scheme, the update cycle processes each after another in a fixed order. For example take the sequence $x_1, x_2, x_3, x_4$. Updating the state $0000$ means first using $f_1$ which results in an intermediate state $1000$, then using $f_2$, then $f_3$ and lastly $f_4$. This will lead to $0000 \rightarrow 1111$, a different state as when using the synchronous update scheme. In fact the whole state graph changes depending on the update scheme used, namely every initial state will fall into a single 4-state cycle being $0000 \rightarrow 1111 \rightarrow 0011 \rightarrow 1100 \rightarrow 0000$, see \cref{fig:bn_seq_state_graph}.
Unlike the synchronous scheme, the sequential scheme allows for side effects when updating the network, by having an order in which nodes are updated.
When using the sequential update scheme, the update cycle evaluates each after another in a fixed order. For example take the sequence $x_1, x_2, x_3, x_4$. Updating the state $0000$ means first using $f_1$ which results in an intermediate state $1000$, then using $f_2$, then $f_3$ and lastly $f_4$. This will lead to $0000 \rightarrow 1111$, a different state as when using the synchronous update scheme. In fact the whole state graph changes depending on the update scheme used, namely every initial state will fall into a single 4-state cycle being $0000 \rightarrow 1111 \rightarrow 0011 \rightarrow 1100 \rightarrow 0000$, see \cref{fig:bn_seq_state_graph}.
\begin{figure}
\centering
\tikzset{every picture/.style={line width=0.75pt}} %set default line width to 0.75pt
\begin{tikzpicture}[x=0.75pt,y=0.75pt,yscale=-1,xscale=1]
%uncomment if require: \path (0,182); %set diagram left start at 0, and has height of 182
%Straight Lines [id:da7515060673133168]
\draw (60,40) -- (88.34,58.89) ;
\draw [shift={(90,60)}, rotate = 213.69] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da5101009163931332]
\draw (130,70) -- (158,70) ;
\draw [shift={(160,70)}, rotate = 180] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da17974568496180332]
\draw (180,40) -- (180,58) ;
\draw [shift={(180,60)}, rotate = 270] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da28479803325341]
\draw (230,70) -- (202,70) ;
\draw [shift={(200,70)}, rotate = 360] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da9289522355407928]
\draw (230,40) -- (201.66,58.89) ;
\draw [shift={(200,60)}, rotate = 326.31] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da5098188343671546]
\draw (230,110) -- (202,110) ;
\draw [shift={(200,110)}, rotate = 360] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da48531701923414494]
\draw (110,100) -- (110,82) ;
\draw [shift={(110,80)}, rotate = 90] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da8391791574907262]
\draw (180,80) -- (180,98) ;
\draw [shift={(180,100)}, rotate = 270] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da24177074905043572]
\draw (60,110) -- (88,110) ;
\draw [shift={(90,110)}, rotate = 180] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da21625025411268273]
\draw (60,70) -- (88,70) ;
\draw [shift={(90,70)}, rotate = 180] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da9822082649794383]
\draw (60,140) -- (88.34,121.11) ;
\draw [shift={(90,120)}, rotate = 146.31] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da1915219980691898]
\draw (180,140) -- (180,122) ;
\draw [shift={(180,120)}, rotate = 90] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da22061673245947822]
\draw (230,140) -- (201.66,121.11) ;
\draw [shift={(200,120)}, rotate = 33.69] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da6267831846161589]
\draw (160,110) -- (132,110) ;
\draw [shift={(130,110)}, rotate = 360] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da6290428382558753]
\draw (110,140) -- (110,122) ;
\draw [shift={(110,120)}, rotate = 90] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
%Straight Lines [id:da9391797989074463]
\draw (110,40) -- (110,58) ;
\draw [shift={(110,60)}, rotate = 270] [color={rgb, 255:red, 0; green, 0; blue, 0 } ][line width=0.75] (10.93,-3.29) .. controls (6.95,-1.4) and (3.31,-0.3) .. (0,0) .. controls (3.31,0.3) and (6.95,1.4) .. (10.93,3.29) ;
% Text Node
\draw (91,62) node [anchor=north west][inner sep=0.75pt] [align=left] {0000};
% Text Node
\draw (231,62) node [anchor=north west][inner sep=0.75pt] [align=left] {1000};
% Text Node
\draw (21,22) node [anchor=north west][inner sep=0.75pt] [align=left] {1110};
% Text Node
\draw (161,142) node [anchor=north west][inner sep=0.75pt] [align=left] {0111};
% Text Node
\draw (231,102) node [anchor=north west][inner sep=0.75pt] [align=left] {1101};
% Text Node
\draw (24,62) node [anchor=north west][inner sep=0.75pt] [align=left] {0100};
% Text Node
\draw (21,142) node [anchor=north west][inner sep=0.75pt] [align=left] {1011};
% Text Node
\draw (161,102) node [anchor=north west][inner sep=0.75pt] [align=left] {0011};
% Text Node
\draw (91,142) node [anchor=north west][inner sep=0.75pt] [align=left] {0001};
% Text Node
\draw (231,22) node [anchor=north west][inner sep=0.75pt] [align=left] {1010};
% Text Node
\draw (161,62) node [anchor=north west][inner sep=0.75pt] [align=left] {1111};
% Text Node
\draw (231,142) node [anchor=north west][inner sep=0.75pt] [align=left] {0101};
% Text Node
\draw (91,102) node [anchor=north west][inner sep=0.75pt] [align=left] {1100};
% Text Node
\draw (91,22) node [anchor=north west][inner sep=0.75pt] [align=left] {0110};
% Text Node
\draw (21,102) node [anchor=north west][inner sep=0.75pt] [align=left] {1001};
% Text Node
\draw (161,22) node [anchor=north west][inner sep=0.75pt] [align=left] {0010};
\end{tikzpicture}
\caption{State graph of the boolean network shown in \cref{fig:bn_example} using the sequential update with the sequence $x_1, x_2, x_3, x_4$}
\label{fig:bn_seq_state_graph}
\end{figure}
While the sequential update scheme seems to be different from synchronous, it is actually possible to derive a set of functions for synchronous update scheme that have the same outcome as the current set for sequential scheme. This can be achieved by reevaluating each function in order of the sequence and replacing $x_i$ with $f'_i$ if $f'_i$ has been computed previously where $f'_i$ represents the new function for synchronous use. In case of the boolean network from \cref{fig:bn_example} with sequence $x_1, x_2, x_3, x_4$, the resulting functions are
$$
f'_1 = \neg x_2,
$$
$$
f'_2 = f'_1 = \neg x_2,
$$
$$
f'_3 = f'_1 \oplus x_4 = \neg x_2 \oplus x_4,
$$
$$
f'_4 = f'_3 = \neg x_2 \oplus x_4.
$$
This means that sequential schemes share the same characteristics as the synchronous scheme, and can have more simple functions at a larger scale, as synchronous would have to incorporate extra operations in order to simulate the side effects of one function happening before another.
An extension of the sequential scheme is the block-sequential scheme. This allows to devide the nodes into groups, called blocks, that run synchronously, while the blocks execute in sequence. This allows for further fine tuning of the behavior and can simplify the modeling of realistic systems. The block-sequential scheme too can be converted to a synchronous scheme, thus producing the same behavior as the synchronous scheme.
\todo[inline]{refer to synchronous by computing new functions that can be run synchronously with the same outcome as sequential with the current functions}
\subsection{Block-sequential scheme}
mix of synchronous and sequential. predefined blocks update sequential, inside a block the update follows the synchronous scheme
\subsection{Probabilistic scheme}
The Probabilistic update scheme is a synchronous scheme in terms of executing the functions, however, there is no longer only one function per node. Instead you can have multiple functions per node with each a fixed probability. This introduces some noise into the system and can lead to more realistic simulations. In order to show it using the example from \cref{fig:bn_example}, we need to extend the set of functions with alternatives and probability, which will only be used in this section.
The probabilistic scheme is an extension of synchronous, sequential and non-random asynchronous scheme as it introduces randomness into the system. Instead of having one function per node, a node has multiple functions with individual probabilities. Upon updating a node, one of these functions is chosen randomly with regards to the probability distribution. This allows the introduction of noise and uncertainty into the system.
An example of how this can drastically change the outcome can be visualized when adding a second function to the node $x_4$ from the example in \cref{fig:bn_example}. Let $f_{4 switch} = \neg f_4 = \neg x_3$ with an equal probability distribution. This simple addition to the boolean network causes that on average, every second update the state switches from one cycle to the other. Thus there are no longer two individual cycles. Any initial state will eventually reach all possible states and will never fall into a repeating pattern.
$$
\text{PLACEHOLDER}
$$
\todo[inline]{refer to \cite{schwab2020concepts} and potentially add figure 2 from that paper}
\subsection{Asynchronous deterministic}
one node is updated per tick following a specific sequence
\subsection{Asynchronous scheme}
While synchronous, sequential and probabilistic schemes update all the nodes in one time step, the asynchronous scheme only updates one node per time step. The order in which nodes are updated depend on the chosen asynchronous scheme.
\begin{itemize}
\item Asynchronous deterministic is similar to sequential in that it has a sequence of nodes in which the nodes are updated. However, nodes can appear an arbitrary amount of times in one sequence, allowing for a more dynamical behavior modeling compared to sequential scheme.
\item Asynchronous random is pretty straight forward. On each update cycle a random node is chosen to be updated.
\end{itemize}
During early stages of research of boolean networks, it was believed that asynchronous update schemes would lead to a more realistic modeling of biochemical systems \cite{schwab2020concepts}. However, as studies have shown, asynchronous update schemes and synchronous update schemes can lead to the same meaningful behavior for biochemical systems. Furthermore, assuming that one update process takes a few seconds to minutes, updating a large system can take days to have every node updated once, if not longer\cite{schwab2020concepts}.
\todo[inline]{create introduction, conclusion/transition to the next scheme for each scheme}
@@ -287,12 +429,17 @@ Tie the update schemes and their different outcomes or behavior to GRN.
Emphasizing the drawbacks of asynchronous models when applied to GRN e.g. it takes way to long to update a GRN using asynchronous deterministic for it to have an effect; assuming that one update takes a few minutes, when the whole process can take days to complete.\cite{schwab2020concepts}
\section{Conclusion}
Not yet included: robustness! might be covered for each update scheme individually.
While initially believed that different update schemes lead to different outputs, it turns out that in general, most schemes are equal, especially synchronous, sequential, block-sequential and asynchronous deterministic. It only requires a different function set, in order to move from one update scheme to the next one.
Only the probabilistic scheme and asynchronous random are non deterministic and cannot truly be changed to a different update scheme with just a change of functions.
Choosing an update scheme depends mostly on which effect is required and most simple to model using a certain scheme. No side effects? Choose synchronous. With side effects? Choose sequential or asynchronous. Have a system with noise? Give probabilistic a try or maybe even asynchronous random.
References: \cite{schwab2020concepts}\cite{aracena2009robustness}\cite{bornholdt2008boolean}\cite{goles2010block}\cite{helikar2011boolean}
\todo[inline]{currently not really using references. i need to go over everything again and add the references at the right spots and even mention them explicitly in sentences for further context.}
\todo[inline]{DON'T FORGET THE 2 MINUTE SLIDES!!!}