diff --git a/sheets/04_mip/README.md b/sheets/04_mip/README.md
index 2c59bd7c02a6b64a8e524d6cdf08aec433e8ea32..cde8340c42e6eecef616a0c62412d0fff3af552a 100644
--- a/sheets/04_mip/README.md
+++ b/sheets/04_mip/README.md
@@ -1,44 +1,33 @@
 # Sheet 04: (Mixed) Integer (Linear) Programming
 
 The oldest and most common technique for solving NP-hard optimization problems in practice is [(Mixed) Integer (Linear) Programming](https://en.wikipedia.org/wiki/Integer_programming).
-It allows modelling problems using linear constraints and objective functions on fractional and integral variables.
-Most combinatorial problems are easily expressable by Mixed Integer Programming, and most practical optimization problems can be sufficiently approximated.
-The probably most famous sucess story of this technique is its usage by the [TSP-solver Concorde](https://en.wikipedia.org/wiki/Concorde_TSP_Solver), which was able to solve a (non-trivial) instance with over 85000 vertices to optimality.
+It allows modeling problems using linear constraints and objective functions on fractional and integral variables.
+Most combinatorial problems are easily expressible by Mixed Integer Programming, and most practical optimization problems can be sufficiently approximated.
+The probably most famous success story of this technique is its usage by the [TSP-solver Concorde](https://en.wikipedia.org/wiki/Concorde_TSP_Solver), which was able to solve a (non-trivial) instance with over 85000 vertices to optimality.
 The solvers are usually based on [Branch&Bound](https://en.wikipedia.org/wiki/Branch_and_bound), [Linear Relaxation](https://en.wikipedia.org/wiki/Linear_programming_relaxation), and [Cutting Planes](https://en.wikipedia.org/wiki/Cutting-plane_method), of which especially the last two have a serious mathematical foundation.
 Mixed Integer Programming is one of the prime examples for the importance of theoretical research for practical progress.
 However, you don't have to worry about any mathematical details, as modern solvers will do most of the complicated stuff for you.
 This [primer](https://www.gurobi.com/resources/mixed-integer-programming-mip-a-primer-on-the-basics/) gives you some further details on how it is working.
-We will focus here on just modelling the problems and using such a solver as a black box.
+We will focus here on just modeling the problems and using such a solver as a black box.
 
-## Modelling
+## Modeling
 
-TBD: Give some basics on modelling.
+Modern MIP-solvers like Gurobi have a very expressive API that allows a declarative usage, similar to CP-SAT that we used in a [previous sheet](../02_cpsat).
+The main differences are that MIP-solvers are usually limited to linear expressions (everything non-linear is usually done by inefficient tricks) but can deal much better with fractional values.
+An advanced concept are also lazy constraints, that allow to efficiently add further constraints via callbacks.
+In the [previous sheet](../03_card_sat), we already used iterative model building to only add constraints if necessary, with MIP-solvers this is more interactive.
+Linear expressions are algebraic formulas of the first degree, i.e., variables are not multiplied or divided by each other (or themselves).
+As comparisons, only $\leq, =, \geq$ are allowed, but not true inequalities, making them essentially half-planes or spaces in a high-dimensional spaces (and the solution space linear).
+An example for a linear constraint is $4\cdot x_1-3 \cdot x_2+0.5\cdot x_3 \geq 7.3$.
+$x_1^2 \leq 3$ would *not* be linear as $x_1$ is multiplied by itself.
+Advanced functions such as $\sin x$ are of course completely forbidden (though, there are tricks to approximate them).
 
-Ein *lineares Programm* (LP) besteht, ähnlich wie ein Constraint Program, aus Variablen $x_1,\ldots,x_n$ sowie einer Zielfunktion und Nebenbedingungen über diesen Variablen.
-Allerdings ist man bei einem LP auf eine lineare Zielfunktion sowie lineare Nebenbedingungen beschränkt.
-Die Zielfunktion hat im Allgemeinen die Form $\sum_{i=1}^{n} c_ix_i$ für frei bestimmbare, aber feste Koeffizienten $c_i \in \mathbb{R}$, und kann entweder minimiert oder maximiert werden.
-Es ist insbesondere nicht möglich, Variablen miteinander zu multiplizieren oder ihren Absolutwert zu bestimmen, oder ähnliche nicht-lineare Elemente in die Zielfunktion einzubauen.
+In a Mixed Integer Program, we have
 
-Genau wie die Zielfunktion müssen auch die Nebenbedingungen linear sein.
-Die $j$-te Nebenbedingung hat im Allgemeinen die Form $\sum_{i=1}^n a_{ij}x_i \leq b_j$, wobei $a_{ij}$ und $b_j$ wieder frei bestimmbare, aber feste Koeffizienten aus $\mathbb{R}$ sind.
-Es darf statt $\leq$ auch $\geq$ oder $=$ genutzt werden.
-Auch hier ist es also nicht möglich, Variablen miteinander zu multiplizieren oder andere nicht-lineare Nebenbedingungen einzuführen.
-
-Üblicherweise haben die Variablen Schranken, also Nebenbedingungen der Form $\ell_i \leq x_i \leq u_i$, die ihren Wertebereich einschränken.
-Diese kann man gesondert behandeln, aber auch einfach als zusätzliche Nebenbedingungen betrachten.
-
-
-Nun brauchen wir zur Modellierung eines NP-schweren Problems natürlich zwingend ein NP-schweres Problem, es sei denn, uns ist der Beweis für $P = NP$ geglückt.
-Hier kommt die Erweiterung der linearen Programmierung zur ganzzahligen linearen Programmierung (IP) ins Spiel.
-Sie erlaubt es uns, alle Variablen (oder auch nur einen Teil der Variablen\footnote{Man spricht technisch gesehen von einem Mixed Integer Program (MIP), wenn es sowohl ganzzahlige als auch kontinuierliche Variablen gibt.}) auf ganzzahlige Werte zu beschränken.
-Dadurch wird es zum einen möglich, unter anderem Entscheidungsvariablen als $\{0,1\}$-Variablen zu implementieren, und das Problem wird NP-schwer.
-Zum anderen erlaubt uns Integer Programming, auf Umwegen auch einige nicht-lineare Nebenbedingungen zu modellieren.
-
-Anders als die bisher verwendeten CP- und SAT-Solver bieten IP-Solver oft die Möglichkeit, während einer laufenden Suche neue Bedingungen hinzuzufügen.
-Solche Nebenbedingungen werden auch  *Lazy Constraints* genannt.
-Dies geschieht in der Regel durch sogenannte \emph{Callbacks}: Während der Suche ruft der IP-Solver an bestimmten Punkten den zuvor registrierten Code des Benutzers auf.
-Dabei erhält der Benutzer-Code Zugriff auf eine aktuelle (ganzzahlige oder auch nicht-ganzzahlige) Lösung und erhält die Möglichkeit, neue Bedingungen einzufügen, die diese Lösung verbieten.
-Dies wird beim TSP zum Beispiel verwendet, um während der Lösung auftretende Subtouren zu verbieten, ähnlich wie wir das bei SAT gemacht haben, allerdings ohne den Solver immer wieder neu zu starten.
+1. Variables, which can be fractional, boolean, or integral. Fractional and integral variables can additional have a lower and upper bound.
+2. A linear objective function that can be minimized or maximized.
+3. A set of linear constraints on the variables that have to be satisfied by every solution.
+4. Optionally, a lazy constraints-function that gets a solution and returns nothing if the solution is feasible or constraints that are violated and should be added to the set. This allows to have a theoretically huge number of constraints in the model, but not in the computer memory.
 
 You can also check out these [video lectures](https://www.gurobi.com/resource/tutorial-mixed-integer-linear-programming/).
 
@@ -46,28 +35,28 @@ We again provide an [example for the Degree Constrained Bottleneck Spanning Tree
 
 ## Installation
 
-We will use Gurobi. In case you  haven't already installed it, you can do so using Anaconda
+We will use [Gurobi](https://www.gurobi.com/). In case you  haven't already installed it, you can do so using Anaconda
 
 ```bash
 conda config --add channels http://conda.anaconda.org/gurobi
 conda install gurobi
 ```
 
-You can also install  it via `pip` but this may not install the license tool `grbgetkey`,  which is required for activating a  full academic license.
-Without such a license, only very small models and only as subset of the API can be used.
-For getting such an acemdic license, you have to [register](https://www.gurobi.com/academia/academic-program-and-licenses/).
+You can also install it via `pip` but this may not install the license tool `grbgetkey`,  which is required for activating a full academic license.
+Without such a license, only very small models and only a subset of the API can be used.
+For getting such an academic license, you have to [register](https://www.gurobi.com/academia/academic-program-and-licenses/).
+In the past, this page has been buggy from time to time (e.g., it forgot your student status).
 
 Once you got a license from the webpage, you can run
 ```bash
 grbgetkey XXXXXXXX-YOUR-KEY-XXXXXXXXXX
 ```
 to activate  it.
+You may have to be within the university's network (or use VPN) for this.
 
 ## Tasks
 
-* Modelliert statt des DBST das BTSP als Integer Program und implementiert einen Solver auf dieser Basis. Ihr könnt Euch dabei wieder an dem DBST-Beispiel orientieren; achtet allerdings darauf, dass die von Euch generierten Lazy Constraints so scharf wie möglich sind.
-* Modelliert auch die Variante des BTSP, bei der die kürzeste Tour gesucht wird, deren Bottleneck minimal ist, und implementiert einen Solver für diese Problemvariante.
-* Wie groß sind die Instanzen, die Ihr in der Regel noch in einer Minute bzw.\ in einer Viertelstunde lösen könnt? Wie schnell ist der IP-basierte Solver im Vergleich zum SAT-basierten und zum CP-basierten Solver? Wie viel länger dauert es, die Problemvariante zu lösen, bei der nach einer kürzesten Tour mit minimalem Bottleneck gesucht wird? Überlegt Euch, wie Ihr diese Fragen experimentell beantworten könnt, und wie Ihr die Ergebnisse Eurer Experimente graphisch (mithilfe von Plots) darstellen könnt.
-* Im Codebeispiel seht Ihr, dass Ihr nicht nur ganzzahlige Zwischenlösungen bekommen könnt, sondern im Callback auch Zugang zu den nicht-ganzzahligen (fraktionalen) Zwischenlösungen bekommt. Baut eine Option in Eure Solver ein, mit der Ihr die entstehenden fraktionalen Zwischenlösungen visualisieren könnt. Ihr könnt dazu beispielsweise jede Zwischenlösung in ein Bild exportieren. Stellt dabei am besten nur diejenigen Kanten dar, deren Entscheidungsvariablen größer als ein gewisser Minimalwert (z.\,B. $10^{-4}$) sind. Ihr könnt neben Labels an den Kanten dabei mit Transparenz oder Farben arbeiten, um den Wert der zugehörigen Variablen darzustellen.
-* Untersucht für ein paar kleine Beispiele die entstehenden Zwischenlösungen. Könnt ihr Bedingungen identifizieren, die sich als lineare Nebenbedingungen darstellen lassen, welche von allen zulässigen ganzzahligen Lösungen erfüllt werden, aber von vielen Eurer Zwischenlösungen nicht? Achtet dabei insbesondere darauf, dass der Solver nicht alle Constraints kennt und diese daher in vielen Zwischenlösungen nicht berücksichtigt werden können, bevor Ihr sie dem Solver gebt.
-* Falls Ihr solche Nebenbedingungen finden könnt, implementiert Routinen, die diese Nebenbedingungen finden und dem Solver zur Verfügung stellen. Diese Routinen sollten mit Optionen abschaltbar sein. Führt Experimente durch und untersucht, ob die Performance Eures Solvers sich mit diesen Nebenbedingungen verbessert. Versucht auch herauszufinden, mit welchen Optionen der Solver am besten funktioniert.
+* Model the BTSP as a Mixed Integer Program on paper.
+* Implement the model with Gurobi.
+* How does the solver performs compared to the CP-SAT-solver and the SAT-solver? What is the smallest instance you can no longer solve, and what is the largest instance you still can solve in 5 minutes.
+* You can provide Gurobi with initial solutions. How does this influence the performance?