preliminary fixes/removed typos, etc.

bn_sim.py

@@ -1,4 +1,5 @@
 from itertools import product
+from random import random
 
 funcs = [
     lambda x1, x2, x3, x4: not x2,
@@ -14,6 +15,13 @@ sequential_sync_funcs = [
     lambda x1, x2, x3, x4: (not x2) ^ x4,
 ]
 
+probabilistic_funcs = [
+    (1, funcs[0], None),
+    (1, funcs[1], None),
+    (1, funcs[2], None),
+    (0.5, funcs[3], lambda x1, x2, x3, x4: not x3),
+]
+
 
 nodes = []
 
@@ -39,6 +47,17 @@ def sequential_update(order):
         nodes[i] = funcs[i](*nodes)
 
 
+def probabilistic_update():
+    global nodes, probabilistic_funcs
+    funcs = probabilistic_funcs
+    temp = nodes.copy()
+    for i in range(len(funcs)):
+        probability, *nodeFuncs = funcs[i]
+        func = nodeFuncs[0] if probability >= random() else nodeFuncs[1]
+        temp[i] = func(*nodes)
+    nodes = temp
+
+
 def state_to_str():
     return "".join(str(int(i)) for i in nodes)
 
@@ -61,14 +80,16 @@ def get_table():
 
 
 def update():
-    return synchronous_update()
+    # return synchronous_update()
-    return sequential_update([0, 1, 2, 3])
+    # return sequential_update([0, 1, 2, 3])
+    return probabilistic_update()
     # return block_sequential_update(...)
     # return asynchronous_deterministic_update(...)
 
 
 def main():
     get_table()
+    # simulate([0,0,0,0])
 
 
 if __name__ == "__main__":

paper.tex

@@ -76,21 +76,24 @@
 
 
 \section{Introduction}
-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.
+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 in 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.
+When it comes to modeling a system by a boolean network, the choice of the update scheme takes an important role, as it defines how and when individual parts of the network change. Some of the most commonly used schemes include the 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.
+The choice of the update scheme will lead to a different behavior, such as other attractors and cycles, a change in reachability and different 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.
+In the following, we will introduce different update schemes and their respective effects on boolean networks illustrated on examples and find the best use case for each scheme.
 
 
 \todo[inline]{use more \textbf{references}!}
 
 \section{Boolean networks}
 \label{sec:bn}
-A boolean network consists of nodes $x_i(t)$ that have a boolean state, either $0$ or $1$, at a point in time $t$. Each node has a corresponding update function $x_i(t+1) = f_i(x_1(t), x_2(t), \ldots, x_n(t))$ expressing the new state of $x_i(t+1)$. The state of the boolean network can be describe as a boolean number $x_1 x_2\ldots x_n$ where each node is replaced with the corresponding state.
+A boolean network consists of nodes $x_i(t)$ that have a boolean state, either $0$ or $1$, at a point in time $t$. Each node has a corresponding update function
+$$
+x_i(t+1) = f_i(x_1(t), x_2(t), \ldots, x_n(t))
+$$ expressing the new state of $x_i(t+1)$. The state of the boolean network can be describe as a boolean number \mbox{$x(t) = x_1 x_2\ldots x_n$} where each node is replaced with the corresponding state 0 or 1.
 
 
 \begin{figure}
@@ -147,9 +150,13 @@ A boolean network consists of nodes $x_i(t)$ that have a boolean state, either $
 	\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}.
+Consider the boolean network shown in \cref{fig:bn_example}. For example, if the state is $x(t)=0011$ at time $t$, meaning that $x_1, x_2$ are $0$ and $x_3, x_4$ are $1$. After applying the synchronous update, the next state $x(t+1)$ 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 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.
+A state graph shows all possible states of the network with the corresponding trajectory. For example, the state graph in \cref{fig:bn_syn_state_graph} shows the trajectories from the boolean network in \cref{fig:bn_example}. These state graphs help visualizing the attractors and cycles, e.g. 2 cycles of length 8.
+
+%TODO: Subsection??
+
+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 from \cref{fig:bn_syn_state_graph}, 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}
 
@@ -266,15 +273,15 @@ In boolean networks, robustness refers to stability of the behavior with regards
 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 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.
+In \cref{sec:bn}, we have used the synchronous update scheme to introduce the general dynamics of boolean networks. This scheme assumes that each update function takes the exact same amount of time and executes at the same time, which means that regardless of the outcome of the first function, any subsequenct function will have the same result. Updating the network with this method is quite simple, always leads to a deterministic output 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}
-Unlike the synchronous scheme, the sequential scheme allows for side effects when updating the network, by having an order in which nodes are updated.
+Unlike the synchronous scheme, the sequential scheme allows for side effects when updating the network by having an order in which nodes are updated at each step.
-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}.
+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
@@ -369,14 +376,14 @@ When using the sequential update scheme, the update cycle evaluates each after a
 
 	\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$}
+	\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
+While the sequential update scheme seems to be different from synchronous, it is actually possible to derive a set of functions for a synchronous update scheme that have the same outcome as the current set for a particular sequential scheme. This can be achieved by reevaluating each function in the 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
-
+%TODO: Above: rewording of explanation for creating the sync function set from seqential
 
 $$
 f'_1 = \neg x_2,
@@ -391,9 +398,9 @@ $$
 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.
+This means that sequential schemes share the same characteristics as the synchronous scheme. Furthermore, if the side-effects from the sequential scheme are desired, the synchronous function set would become larger and more complex.
 
-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.
+An extension of the sequential scheme is the block-sequential scheme. This allows to divide 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 can also be converted to a synchronous scheme, thus producing the same behavior as previously described.