update before meeting. there's a lot to do..

paper.tex

@@ -69,6 +69,7 @@
 
 \begin{abstract}
     In this paper we will introduce boolean networks (BN) and their relevance to gene regulatory networks (GRN). We will have a closer look on update schemes. Specifically, synchronous, sequential and asynchronous update schemes and their effect on the behavior of BN and GRN respectively.
+    \todo[inline]{will be change once introduction and conclusion are done}
 \end{abstract}
 
 
@@ -84,6 +85,7 @@ Possible points to mention here:
 
 
 \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.
 
 
@@ -141,7 +143,8 @@ 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 that doesn't change when updated, called attractor, or it falls into a cycle of states. In the example, there are 2 cycles of length 8 visible in \cref{fig:bn_ex_state_graph}.
+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}.
+\todo[inline]{currently feels to short. once introduction is implemented, create a better transition/section 2 introduction. Also introduce robustness!}
 
 \begin{figure}
 
@@ -237,33 +240,44 @@ Consider the boolean network shown in \cref{fig:bn_example}. Assume the current
 	\end{tikzpicture}
 	\centering
 	\caption{State graph of the boolean network shown in \cref{fig:bn_example} using synchronous update scheme.}
-	\label{fig:bn_ex_state_graph}
+	\label{fig:bn_syn_state_graph}
 \end{figure}
 
 
-\subsection{Notation}
-Define clear notation used throughout the paper. Position of this subsection could change to be part of the Introduction instead.
-
 
 
 \section{Update Schemes}
 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}
-The Synchronous (also known as Parallel) update scheme assumes that every node is updated at once.
+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.
+
+
+
+\todo[inline]{add more context and information about grn and their effects, split text into logical paragraphs}
 
 \subsection{Sequential scheme}
-close to synchronous. the nodes update in a specific order and take into account the updated input node if that node had been updated before/is positioned earlier in the sequence
+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}.
+
+\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 define a new set of functions, which will only be used in this section.
+
+$$
+\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 generalized}
-same as asynchronous deterministic with the slight change that within the sequence nodes may appear multiple times.
 
+\todo[inline]{create introduction, conclusion/transition to the next scheme for each scheme}
 
 
 \section{Relevance for Gene Regulatory Networks}
@@ -277,29 +291,11 @@ Not yet included: robustness! might be covered for each update scheme individual
 
 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!!!}
 
 
 
-\begin{figure*}  % The starred version uses both columns; unstarred only one column
-	\centering
-
-	\caption{
-		graph of all possible states for a boolean network using a synchronous update scheme
-	}
-
-\end{figure*}
-
-\begin{figure*}  % The starred version uses both columns; unstarred only one column
-	\centering
-	% \includegraphics[width=5in]{edge_vs_hyperedge.png}
-	% TIP: Ensure the original image file has approximately the right dimensions
-	% (if using matplotlib, specify correct figure size) so that the image is not rescaled too brutally.
-	\caption{
-		example graph of boolean network showcasing grouping of specific nodes.
-	}
-
-\end{figure*}
-
 
 % The list of references is provided as `references.bib`
 \bibliographystyle{unsrt}