From 21f78a0479a70ff7f9ea6cec913b6531a4e26de2 Mon Sep 17 00:00:00 2001
From: Maximilian Schlosser <maximilian.schlosser@tu-dresden.de>
Date: Fri, 23 Jun 2017 19:00:50 +0200
Subject: [PATCH] initial documentation

---
 doc.md | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 doc.md

diff --git a/doc.md b/doc.md
new file mode 100644
index 0000000..4eed2da
--- /dev/null
+++ b/doc.md
@@ -0,0 +1,37 @@
+## scheduling problem defined by:
+  1. $m$ specialized machines
+  2. tasks $\tau$ of the form $(e, i)$ with $t \in \mathbb{N}$ the execution time and $i \in \{1,2,\dots,m\}$ the machine the task has to run on
+  3. $n$ jobs $T_k$ with $\forall T_k:$ linear order of tasks, with $k \in \{1,2,\dots,n\}$
+  4. Additionally, a multiset $\Omega$ of arbitrary but fixed size that contains wait states $\omega := (1, i)$ with $i \in \{1,2,\dots,m\}$ the blocked machine.
+
+The goal is to find the fastest feasible schedule $\sigma_{min}$.
+
+## evaluative function
+  - minimize the execution time of $\sigma$
+  - upper bound: largest processing time first
+  - lower bound: max sum of execution times on one machine
+
+## solutions
+  - list of tuples $(t, \tau)$ with $t \in \mathbb{N}$ the scheduled begin of $\tau$
+
+## operations
+  - $\operatorname{ins}(\omega, t)$: block a machine at time $t$ for $w$ time steps.
+  - $\operatorname{xchg}(\tau_1,\tau_2)$: exchange the position of two tasks.
+  
+Both operations require that the start times are recomputed.
+
+## neighbourhood of solution
+
+  - $\operatorname{neighbours}(\sigma) = \{x \in \Sigma | \delta(\sigma, x) \leq n\}$ with $\Sigma$ the set of all feasible schedules.
+  - $\delta$: $\delta ( \sigma )=0$, $\delta ( \operatorname{op}(x)) = \delta (x) + 1$ (ass. ins has the same penalty xchg has), $x$ either op($y$) or $\sigma$ 
+
+## constraints
+  - only schedule new $\tau$ if another $\tau$ is finished
+  - only schedule $\tau \in T_k$ that has no unscheduled predecessor in $T_k$
+  - only one job on a machine any given time
+
+## implementation in Python
+  - translate jobs into lists of tasks, problem into list of jobs, ie problem = [$T_0, T_1,\dots,T_{k-1}$], $T_i$ = [$\tau_1,\tau_2,\dots$]
+  - address tasks based on their indices, ie [0][1] is the second job of the first task.
+  - compute only one possible next solution, rate, drop/accept. $\delta$ is computed iteratively during generation
+  -