Repository: pacti-org/pacti (language: python)

Issue:
Main confm
Makes documentation easier.
Modified duties.py, pyproject.toml, and mkdocs.yml to display Jupyter notebooks on the website and putting documentation out there.


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a8fbeaf9..f893d438 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-on: [push,pull_request]
+on: [push]
 
 name: Test Action
 
@@ -10,7 +10,7 @@ jobs:
       max-parallel: 4
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10"]
     steps:
       - uses: pdm-project/setup-pdm@main
         name: Setup PDM
diff --git a/case_studies/evaluating_perception/construct_parametric_chain.py b/case_studies/evaluating_perception/construct_parametric_chain.py
new file mode 100644
index 00000000..b7b582e5
--- /dev/null
+++ b/case_studies/evaluating_perception/construct_parametric_chain.py
@@ -0,0 +1,1 @@
+### This script computes the parametric 
diff --git a/case_studies/evaluating_perception/evaluating_classification_algorithms.ipynb b/case_studies/evaluating_perception/evaluating_classification_algorithms.ipynb
new file mode 100644
index 00000000..05b3dc49
--- /dev/null
+++ b/case_studies/evaluating_perception/evaluating_classification_algorithms.ipynb
@@ -0,0 +1,311 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f3c253b2",
+   "metadata": {},
+   "source": [
+    "## Import libraries:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "992db0a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from gear.iocontract.utils import getVarlist\n",
+    "from PIL import Image\n",
+    "from gear.terms.polyhedra.loaders import readContract, writeContract"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e49f76b3",
+   "metadata": {},
+   "source": [
+    "### Simple Example with pedestrian 5 steps away"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9e9a6b71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## System contract: P >= 0.99\n",
+    "def system_contract():\n",
+    "    system_contract = {\n",
+    "        \"InputVars\":[\"xe\"],\n",
+    "        \"OutputVars\":[\"P\"],\n",
+    "        \"assumptions\":[\n",
+    "            {\"coefficients\":{\"xe\":-1}, \"constant\": -1},\n",
+    "            {\"coefficients\":{\"xe\": 1}, \"constant\": 1}\n",
+    "        ],\n",
+    "        \"guarantees\":[\n",
+    "            {\"coefficients\":{\"P\":-1}, \"constant\":-1},\n",
+    "            {\"coefficients\":{\"P\":1}, \"constant\":0}\n",
+    "        ]\n",
+    "    }\n",
+    "    return system_contract\n",
+    "\n",
+    "## Perception contract P = p**5 = 5p - 4\n",
+    "def perception_contract():\n",
+    "    mc = {\"InputVars\":[\"p\"],\n",
+    "        \"OutputVars\":[\n",
+    "            \"P\"\n",
+    "        ],\n",
+    "        \"assumptions\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"p\":1},\n",
+    "            \"constant\":1},\n",
+    "            {\"coefficients\":{\"p\":-1},\n",
+    "            \"constant\":0}\n",
+    "        ],\n",
+    "        \"guarantees\":\n",
+    "        [ # P = 5p - 4\n",
+    "          {\"coefficients\":{\"P\":1, \"p\":-5},\n",
+    "          \"constant\":-4},\n",
+    "          {\"coefficients\":{\"P\":-1, \"p\":5},\n",
+    "          \"constant\":4}\n",
+    "        ]}\n",
+    "    return mc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fb43c5bd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Contract1:\n",
+      "InVars: [<Var xe>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: -1*xe <= -1, 1*xe <= 1\n",
+      "G: -1*P <= -1, 1*P <= 0\n",
+      "Contract2:\n",
+      "InVars: [<Var p>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: 1*p <= 1, -1*p <= 0\n",
+      "G: 1*P + -5*p <= -4, -1*P + 5*p <= 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "c1 = readContract(system_contract())\n",
+    "c2 = readContract(perception_contract())\n",
+    "\n",
+    "print(\"Contract1:\\n\" + str(c1))\n",
+    "print(\"Contract2:\\n\" + str(c2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7ec08f44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "TILESIZE = 50\n",
+    "ORIENTATIONS = {'n': 270, 'e': 0, 's': 90,'w':180, 'ne':315, 'nw':225, 'se':45, 'sw':135}\n",
+    "START_CROSSWALK = 1\n",
+    "END_CROSSWALK = 5\n",
+    "CROSSWALK_V = 2\n",
+    "CROSSWALK_LOCATIONS = dict()\n",
+    "for i, num in enumerate(range(2*START_CROSSWALK,2*(END_CROSSWALK+1))):\n",
+    "    CROSSWALK_LOCATIONS.update({i: (num/2, CROSSWALK_V)})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64c33d74",
+   "metadata": {},
+   "source": [
+    "### Example with robot and pedestrian"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15e81316",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Grid():\n",
+    "    def __init__(self):\n",
+    "        self.xc_init = 0\n",
+    "        self.vc_init = 0\n",
+    "        self.ped = 1\n",
+    "        self.N = 5\n",
+    "        self.Vmax = 2\n",
+    "        self.xped = 5\n",
+    "        self.main_dir = os.path.dirname(os.path.dirname(os.path.realpath(\"__file__\")))\n",
+    "        self.car_fig = main_dir + '/gear/examples/evaluating_perception/imglib/red_car.png'\n",
+    "        self.ped_fig = main_dir + '/gear/examples/evaluating_perception/imglib/pedestrian_img.png'\n",
+    "    \n",
+    "    def dynamics(self):\n",
+    "        transitions = dict()\n",
+    "        for x in range(0, self.N):\n",
+    "            x_succ = []\n",
+    "            for v in range(0, self.Vmax):\n",
+    "                x_succ.append(x + v)\n",
+    "            transitions[x] = x_succ\n",
+    "        return transitions\n",
+    "    \n",
+    "    def plot_grid(self):\n",
+    "        size = [1, self.N]\n",
+    "        x_min = 0\n",
+    "        x_max = size[0] * TILESIZE\n",
+    "        y_min = 0\n",
+    "        y_max = size[1] * TILESIZE\n",
+    "        #x_min, x_max, y_min, y_max = get_map_corners(map)\n",
+    "        ax.axis('equal')\n",
+    "        ax.set_xlim(x_min, x_max)\n",
+    "        ax.set_ylim(y_min, y_max)\n",
+    "        ax.xaxis.set_visible(False)\n",
+    "        ax.yaxis.set_visible(False)\n",
+    "\n",
+    "        # fill in the road regions\n",
+    "        road_tiles = []\n",
+    "        width_tiles = np.arange(0,size[0]+1)*TILESIZE\n",
+    "        lanes_tiles = np.arange(0,size[1]+1)*TILESIZE\n",
+    "\n",
+    "        for i in np.arange(0,size[0]+1):\n",
+    "            for k in np.arange(0,size[1]+1):\n",
+    "                tile = patches.Rectangle((width_tiles[k],lanes_tiles[i]),TILESIZE,TILESIZE,linewidth=1,facecolor='k', alpha=0.4)\n",
+    "                road_tiles.append(tile)\n",
+    "        ax.add_collection(PatchCollection(road_tiles, match_original=True))\n",
+    "\n",
+    "        # now add crosswalk on top\n",
+    "        crosswalk_tiles = []\n",
+    "        for item in CROSSWALK_LOCATIONS.keys():\n",
+    "            if item % 2 == 0:\n",
+    "                color = 'silver'\n",
+    "                alpha = 0.5\n",
+    "            else:\n",
+    "                color = 'k'\n",
+    "                alpha = 0.5\n",
+    "            width = CROSSWALK_LOCATIONS[item][1]*TILESIZE\n",
+    "            lanes = CROSSWALK_LOCATIONS[item][0]*TILESIZE\n",
+    "            tile = patches.Rectangle((width,lanes),TILESIZE/2,TILESIZE,linewidth=1,facecolor=color, alpha=alpha)\n",
+    "            crosswalk_tiles.append(tile)\n",
+    "        ax.add_collection(PatchCollection(crosswalk_tiles, match_original=True))\n",
+    "        plt.gca().invert_yaxis()\n",
+    "    \n",
+    "    \n",
+    "    def plot_car(self):\n",
+    "        name, y_tile, x_tile, orientation = car_data\n",
+    "        theta_d = ORIENTATIONS[orientation]\n",
+    "        x = (x_tile) * TILESIZE\n",
+    "        y = (y_tile) * TILESIZE\n",
+    "        car_fig = Image.open(car_figs[color])\n",
+    "        car_fig = car_fig.rotate(theta_d, expand=False)\n",
+    "        offset = 0.1\n",
+    "        ax.imshow(car_fig, zorder=1, interpolation='bilinear', extent=[x+2, x+TILESIZE-2, y+2, y+TILESIZE-2])\n",
+    "\n",
+    "# Need to specify Markov Chain as a symbolic library\n",
+    "class MC():\n",
+    "    def __init__(self, states, transitions, goal):\n",
+    "        self.S = states\n",
+    "        self. T = transitions\n",
+    "        self.F = goal\n",
+    "        self.P = {t: 0 for t in self.T} # Initialize transition probabilities\n",
+    "        \n",
+    "    def read_probabilities(self, transitions, P):\n",
+    "        pass\n",
+    "\n",
+    "class CM():\n",
+    "    def __init__(self, classes):\n",
+    "        self.classes = classes\n",
+    "        self.row_data_type = \"predicted_class\"\n",
+    "        self.col_data_type = \"true_class\"\n",
+    "        self.class_dict = {i: classes[i] for i in range(len(classes))}\n",
+    "        self.rev_class_dict = {v: k for k,v in self.class_dict.items()}\n",
+    "        self.cm = np.zeros((len(classes)))\n",
+    "    \n",
+    "    def set_cm(self, cm):\n",
+    "        self.cm = cm\n",
+    "    \n",
+    "    def get_tpr(self, class_i):\n",
+    "        class_ind = self.rev_class_dict[class_i]\n",
+    "        return self.cm[class_ind, class_ind]\n",
+    "    \n",
+    "    def get_fpr(self, class_i):\n",
+    "        class_ind = self.rev_class_dict[class_i]\n",
+    "        fpr = sum(self.cm[class_ind, :]) - self.cm[class_ind, class_ind]\n",
+    "        return fpr\n",
+    "    \n",
+    "    def get_fnr(self, class_i):\n",
+    "        class_ind = self.rev_class_dict[class_i]\n",
+    "        total_samples = self.get_total_samples(class_i)\n",
+    "        return total_samples - self.cm[class_ind, class_ind]\n",
+    "    \n",
+    "    def get_total_samples(self, class_i):\n",
+    "        class_ind = self.rev_class_dict[class_i]\n",
+    "        total_samples = sum(self.cm[:, class_ind])\n",
+    "        return total_samples \n",
+    "    \n",
+    "    def get_normalized_metrics(self, class_i):\n",
+    "        total_samples = self.get_total_samples(class_i)\n",
+    "        tpr = self.get_tpr(class_i)\n",
+    "        fpr = self.get_fpr(class_i)\n",
+    "        fnr = self.get_fnr(class_i)\n",
+    "        return tpr/total_samples, fpr/total_samples, fnr/total_samples\n",
+    "    \n",
+    "# Define child classes\n",
+    "class Proposition_CM():\n",
+    "    pass\n",
+    "\n",
+    "class Distance_CM():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66bd57aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Object detection contract:\n",
+    "# Inputs: classes\n",
+    "# Outputs: true positive and false positive rates for each class\n",
+    "\n",
+    "\n",
+    "## Controller:\n",
+    "# At each time step or overall?\n",
+    "# Option 1: Overall probability analysis (not per time step)\n",
+    "# Challenge: How to generate the nonlinear expression and then simplify it to a linear constraint?\n",
+    "# Need not consider evolution.\n",
+    "# P = c + c*p1 + c*p2 + ...+ c*pn --> try to find coefficients"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/case_studies/evaluating_perception/imglib/blue_car.png b/case_studies/evaluating_perception/imglib/blue_car.png
new file mode 100644
index 00000000..27d7d5a5
Binary files /dev/null and b/case_studies/evaluating_perception/imglib/blue_car.png differ
diff --git a/case_studies/evaluating_perception/imglib/pedestrian_img.png b/case_studies/evaluating_perception/imglib/pedestrian_img.png
new file mode 100644
index 00000000..b474d111
Binary files /dev/null and b/case_studies/evaluating_perception/imglib/pedestrian_img.png differ
diff --git a/case_studies/evaluating_perception/imglib/red_car.png b/case_studies/evaluating_perception/imglib/red_car.png
new file mode 100644
index 00000000..226ee7fc
Binary files /dev/null and b/case_studies/evaluating_perception/imglib/red_car.png differ
diff --git a/case_studies/evaluating_perception/imglib/simple_case_study_fig1.png b/case_studies/evaluating_perception/imglib/simple_case_study_fig1.png
new file mode 100644
index 00000000..6a14611f
Binary files /dev/null and b/case_studies/evaluating_perception/imglib/simple_case_study_fig1.png differ
diff --git a/case_studies/evaluating_perception/imglib/simple_case_study_fig2.png b/case_studies/evaluating_perception/imglib/simple_case_study_fig2.png
new file mode 100644
index 00000000..a58f974c
Binary files /dev/null and b/case_studies/evaluating_perception/imglib/simple_case_study_fig2.png differ
diff --git a/case_studies/evaluating_perception/simple_script.ipynb b/case_studies/evaluating_perception/simple_script.ipynb
new file mode 100644
index 00000000..7204b3eb
--- /dev/null
+++ b/case_studies/evaluating_perception/simple_script.ipynb
@@ -0,0 +1,379 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5bfff69f",
+   "metadata": {},
+   "source": [
+    "# Things to watch out for while specifying contracts\n",
+    "For the evaluating perception case study, this notebook illustrates the importance of specifying contracts correctly, as this impacts the quality of the contract returned by Gear. In this script, we consider the running car-pedestrian example where the pedestrian is 5 steps away from the initial condition of the car. The object detection model has two classes: pedestrian and background. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d617573b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ## Example description:\n",
+    "# For this example, we want to find the AG-contract (highlighted in red) of the object detection component, which is specified using bounds of the probability of correctly detecting a pedestrian. This is illustrated as follows:\n",
+    "# ![alt](/imglib/simple_case_study_fig2.png \"Case Study overview\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2f10a321",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import libraries:\n",
+    "import gear.iocontract as iocontract\n",
+    "from gear.iocontract.utils import getVarlist\n",
+    "from gear.terms.polyhedra.loaders import readContract, writeContract\n",
+    "from IPython.display import display\n",
+    "from IPython.display import Latex\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.image as mpimg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "822b6692",
+   "metadata": {
+    "scrolled": true,
+    "tags": [
+     "hide-input"
+    ]
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "fig, ax = plt.subplots()\n",
+    "img = mpimg.imread('imglib/simple_case_study_fig2.png')\n",
+    "imgplot = ax.imshow(img)\n",
+    "ax.xaxis.set_visible(False)\n",
+    "ax.yaxis.set_visible(False)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75fcddca",
+   "metadata": {},
+   "source": [
+    "## First approach to specifying contracts that does not yield the desired quotient contract\n",
+    "\n",
+    "This explores a contract specification of this simple example that a user might provide, and illustrates why it might not yield the desried quotient contract. First, we specify the overall system contract as follows (similar to the first approach):\n",
+    "* The assumption assumes a pedestrian: $A_S = \\{x_e = 1\\}$ \n",
+    "* The guarantees on overall system level probability: $G_S = \\{0.99 \\leq \\mathbb{P}(s_0 \\models \\varphi) \\leq 1\\}$\n",
+    "\n",
+    "The specifications of the controller are given as follows:\n",
+    "* The assumption that the probability of correctly detecting a pedestrian is between 0 and 1: $A_K = \\{0\\leq p \\leq 1\\}$ \n",
+    "* The guarantees relate overall probability of satisfaction with the probability of correctly finding the pedestrians: $$G_K = \\{\\mathbb{P}(s_0 \\models \\varphi) = 5p - 4, \\\\ 0.99 \\leq \\mathbb{P}(s_0 \\models \\varphi) \\leq 1\\}.$$\n",
+    "The guarantee $G_K$ is the linear approximation of the non-linear relationship between the overall probability of stopping correctly for the pedestrian with the probability of correctly detecting the pedestrian: $\\mathbb{P}(s_0 \\models \\varphi) = p^5$. Furthermore, we also include the guarantee that the overall system probability lies between 0 and 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "90a0406b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall System Contract:\n",
+      "InVars: [<Var x_e>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: -1*x_e <= -1, 1*x_e <= 1\n",
+      "G: -1*P <= -0.99, 1*P <= 1.0\n",
+      "\n",
+      "Controller Contract:\n",
+      "InVars: [<Var p>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: 1*p <= 1, -1*p <= 0\n",
+      "G: 1*P + -5*p <= -4.0, -1*P + 5*p <= 4.0, -1*P <= -0.99\n"
+     ]
+    }
+   ],
+   "source": [
+    "## System contract: P >= 0.99\n",
+    "def system_contract():\n",
+    "    system_contract = {\n",
+    "        \"InputVars\":[\n",
+    "            \"x_e\"\n",
+    "        ],\n",
+    "        \"OutputVars\":[\n",
+    "            \"P\"\n",
+    "        ],\n",
+    "        \"assumptions\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"x_e\":-1}, \"constant\":-1},\n",
+    "            {\"coefficients\":{\"x_e\":1}, \"constant\":1}\n",
+    "        ],\n",
+    "        \"guarantees\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"P\":-1},\n",
+    "            \"constant\":-0.99},\n",
+    "            {\"coefficients\":{\"P\":1},\n",
+    "            \"constant\":1}\n",
+    "        ]}\n",
+    "    return system_contract\n",
+    "\n",
+    "## Perception contract P = p**5 = 5p - 4\n",
+    "def control_contract():\n",
+    "    mc= dict()\n",
+    "    mc = {\n",
+    "        \"InputVars\":[\n",
+    "            \"p\"\n",
+    "        ],\n",
+    "        \"OutputVars\":[\n",
+    "            \"P\"\n",
+    "        ],\n",
+    "        \"assumptions\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"p\":1},\n",
+    "            \"constant\":1},\n",
+    "            {\"coefficients\":{\"p\":-1},\n",
+    "            \"constant\":0}\n",
+    "        ],\n",
+    "        \"guarantees\":\n",
+    "        [\n",
+    "          {\"coefficients\":{\"P\":1, \"p\":-5},\n",
+    "          \"constant\":-4},\n",
+    "          {\"coefficients\":{\"P\":-1, \"p\":5},\n",
+    "          \"constant\":4},\n",
+    "          {\"coefficients\":{\"P\":-1},\n",
+    "          \"constant\":-0.99},\n",
+    "          {\"coefficients\":{\"P\":1},\n",
+    "          \"constant\":1}\n",
+    "        ]\n",
+    "    }\n",
+    "    return mc\n",
+    "\n",
+    "\n",
+    "Cs = readContract(system_contract())\n",
+    "Ck = readContract(control_contract())\n",
+    "\n",
+    "print(\"Overall System Contract:\\n\" + str(Cs)+\"\\n\")\n",
+    "print(\"Controller Contract:\\n\" + str(Ck))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d96db83b",
+   "metadata": {},
+   "source": [
+    "### Applying Quotient Operator\n",
+    "Now, we synthesize the contract $(A_P, G_P)$ for the object detection module using the quotient operator: $\\mathcal{C}_{S}\\backslash \\mathcal{C}_{K}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4cbc6cee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Quotient Contract:\n",
+      "InVars: [<Var x_e>]\n",
+      "OutVars:[<Var p>]\n",
+      "A: -1*x_e <= -1, 1*x_e <= 1\n",
+      "G: 1*p <= 1, -1*p <= 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "Cp = Cs.quotient(Ck)\n",
+    "print(\"Quotient Contract:\\n\" + str(Cp))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9d677bd",
+   "metadata": {},
+   "source": [
+    "### The resulting quotient contract does not satisfy the requirements\n",
+    "The guarantees returned is $G_P = 0 \\leq p \\leq 1$, which does not yield interesting probabilities. The quotient contract returned by Gear is correct. The reason why it returns $0\\leq p\\leq 1$ is because the contract for the controller already guarantees $0.99 \\leq P(s_0 \\models \\varphi) \\leq 1$, so the object detection contract does not need to satisfy any additional requirements on $p$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6ce1020f",
+   "metadata": {},
+   "source": [
+    "## Second approach to specifying contracts that yields the desired quotient contract\n",
+    "\n",
+    "This illustrates how properly specifying the base contracts can yield the correct quotient contract. First, we specify the overall system contract as follows (similar to the first approach):\n",
+    "* The assumption assumes a pedestrian: $A_S = \\{x_e = 1\\}$ \n",
+    "* The guarantees on overall system level probability: $G_S = \\{0.99 \\leq \\mathbb{P}(s_0 \\models \\varphi) \\leq 1\\}$\n",
+    "\n",
+    "The specifications of the controller are same as above except for the trivial bounds on probability:\n",
+    "* The assumption that the probability of correctly detecting a pedestrian is between 0 and 1: $A_K = \\{0\\leq p \\leq 1\\}$ \n",
+    "* The guarantees relate overall probability of satisfaction with the probability of correctly finding the pedestrians: $G_K = \\{\\mathbb{P}(s_0 \\models \\varphi) = 5p - 4\\}$.\n",
+    "The guarantee $G_K$ is the linear approximation of the non-linear relationship between the overall probability of stopping correctly for the pedestrian with the probability of correctly detecting the pedestrian: $\\mathbb{P}(s_0 \\models \\varphi) = p^5$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e0773964",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall System Contract:\n",
+      "InVars: [<Var x_e>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: -1*x_e <= -1, 1*x_e <= 1\n",
+      "G: -1*P <= -0.99, 1*P <= 1.0\n",
+      "\n",
+      "Controller Contract:\n",
+      "InVars: [<Var p>]\n",
+      "OutVars:[<Var P>]\n",
+      "A: 1*p <= 1, -1*p <= 0\n",
+      "G: 1*P + -5*p <= -4, -1*P + 5*p <= 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "## System contract: P >= 0.99\n",
+    "def system_contract():\n",
+    "    system_contract = {\n",
+    "        \"InputVars\":[\n",
+    "            \"x_e\"\n",
+    "        ],\n",
+    "        \"OutputVars\":[\n",
+    "            \"P\"\n",
+    "        ],\n",
+    "        \"assumptions\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"x_e\":-1}, \"constant\":-1},\n",
+    "            {\"coefficients\":{\"x_e\":1}, \"constant\":1}\n",
+    "        ],\n",
+    "        \"guarantees\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"P\":-1},\n",
+    "            \"constant\":-0.99},\n",
+    "            {\"coefficients\":{\"P\":1},\n",
+    "            \"constant\":1}\n",
+    "        ]}\n",
+    "    return system_contract\n",
+    "\n",
+    "## Perception contract P = p**5 = 5p - 4\n",
+    "def control_contract():\n",
+    "    mc= dict()\n",
+    "    mc = {\"InputVars\":[\"p\"],\n",
+    "        \"OutputVars\":[\n",
+    "            \"P\"\n",
+    "        ],\n",
+    "        \"assumptions\":\n",
+    "        [\n",
+    "            {\"coefficients\":{\"p\":1},\n",
+    "            \"constant\":1},\n",
+    "            {\"coefficients\":{\"p\":-1},\n",
+    "            \"constant\":0}\n",
+    "        ],\n",
+    "        \"guarantees\":\n",
+    "        [\n",
+    "          {\"coefficients\":{\"P\":1, \"p\":-5},\n",
+    "          \"constant\":-4},\n",
+    "          {\"coefficients\":{\"P\":-1, \"p\":5},\n",
+    "          \"constant\":4}\n",
+    "        ]}\n",
+    "    return mc\n",
+    "\n",
+    "\n",
+    "\n",
+    "Cs = readContract(system_contract())\n",
+    "Ck = readContract(control_contract())\n",
+    "\n",
+    "print(\"Overall System Contract:\\n\" + str(Cs)+\"\\n\")\n",
+    "print(\"Controller Contract:\\n\" + str(Ck))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d56d0d17",
+   "metadata": {},
+   "source": [
+    "### Applying Quotient Operator\n",
+    "Now, we synthesize the contract $(A_P, G_P)$ for the object detection module using the quotient operator: $\\mathcal{C}_{S}\\backslash \\mathcal{C}_{K}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d7192d94",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Quotient Contract:\n",
+      "InVars: [<Var x_e>]\n",
+      "OutVars:[<Var p>]\n",
+      "A: -1*x_e <= -1, 1*x_e <= 1\n",
+      "G: -5*p <= -4.99000000000000, 1*p <= 1\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "Cp = Cs.quotient(Ck)\n",
+    "print(\"Quotient Contract:\\n\" + str(Cp)+\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c1aee7c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Tags",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/duties.py b/duties.py
index 9c2da18e..2e7d9b15 100644
--- a/duties.py
+++ b/duties.py
@@ -260,6 +260,9 @@ def docs_serve(ctx, host="127.0.0.1", port=8000):
         host: The host to serve the docs from.
         port: The port to serve the docs on.
     """
+    if os.path.exists("docs/case_studies"):
+        ctx.run("rm -f docs/case_studies")
+    ctx.run("ln -sf ../case_studies docs/case_studies")
     ctx.run(f"mkdocs serve -a {host}:{port}", title="Serving documentation", capture=False)
 
 
@@ -271,6 +274,9 @@ def docs_deploy(ctx):
     Arguments:
         ctx: The context instance (passed automatically).
     """
+    if os.path.exists("docs/case_studies"):
+        ctx.run("rm -f docs/case_studies")
+    ctx.run("ln -sf ../case_studies docs/case_studies")
     ctx.run("mkdocs gh-deploy", title="Deploying documentation")
 
 
diff --git a/examples/AND logic gate.ipynb b/examples/AND_logic_gate.ipynb
similarity index 70%
rename from examples/AND logic gate.ipynb
rename to examples/AND_logic_gate.ipynb
index 3180aaf0..8a914329 100644
--- a/examples/AND logic gate.ipynb
+++ b/examples/AND_logic_gate.ipynb
@@ -11,14 +11,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import gear.iocontract as iocontract\n",
-    "import gear.polyhedralterm as polyhedralterm\n",
-    "from gear.gear import getVarset\n",
-    "from gear.gear import readContract, writeContract"
+    "from gear.terms.polyhedra import *"
    ]
   },
   {
@@ -30,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -85,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
@@ -93,13 +90,13 @@
      "output_type": "stream",
      "text": [
       "Contract1:\n",
-      "InVars: {<Var u_1>}\n",
-      "OutVars:{<Var x_1>}\n",
+      "InVars: [<Var u_1>]\n",
+      "OutVars:[<Var x_1>]\n",
       "A: -1*u_1 <= -1\n",
       "G: -1*x_1 <= -1.5\n",
       "Contract2:\n",
-      "InVars: {<Var u_2>}\n",
-      "OutVars:{<Var x_2>}\n",
+      "InVars: [<Var u_2>]\n",
+      "OutVars:[<Var x_2>]\n",
       "A: -1*u_2 <= -1\n",
       "G: -1*x_2 <= -0.30000000000000004\n"
      ]
@@ -122,7 +119,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -131,20 +128,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var u_2>, <Var u_1>}\n",
-      "OutVars:{<Var x_1>, <Var x_2>}\n",
-      "A: -1*u_1 <= -1, -1*u_2 <= -1\n",
-      "G: -1*x_1 <= -1.5, -1*x_2 <= -0.30000000000000004\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(contract_comp)"
    ]
@@ -158,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -167,25 +153,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'InputVars': ['u_2', 'u_1'],\n",
-       " 'OutputVars': ['x_1', 'x_2'],\n",
-       " 'assumptions': [{'constant': '-1', 'coefficients': {'u_1': '-1'}},\n",
-       "  {'constant': '-1', 'coefficients': {'u_2': '-1'}}],\n",
-       " 'guarantees': [{'constant': '-1.5', 'coefficients': {'x_1': '-1'}},\n",
-       "  {'constant': '-0.30000000000000004', 'coefficients': {'x_2': '-1'}}]}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "contract12"
    ]
@@ -199,7 +169,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -228,21 +198,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Contract3:\n",
-      "InVars: {<Var x_1>, <Var x_2>}\n",
-      "OutVars:{<Var y>}\n",
-      "A: -1*x_1 <= -1.5, -1*x_2 <= -0.3\n",
-      "G: -1*y <= -1.5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "c3 = readContract(contract3)\n",
     "print(\"Contract3:\\n\" + str(c3))"
@@ -257,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -266,20 +224,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var u_2>, <Var u_1>}\n",
-      "OutVars:{<Var y>}\n",
-      "A: -1*u_1 <= -1, -1*u_2 <= -1\n",
-      "G: -1*y <= -1.5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(and_gate_contract)"
    ]
@@ -295,7 +242,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -304,20 +251,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var x_1>, <Var x_2>}\n",
-      "OutVars:{<Var y>}\n",
-      "A: -1*x_1 <= -1.5, -1*x_2 <= -0.30000000000000004\n",
-      "G: -1*y <= -1.5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(synthesized_c3)"
    ]
@@ -333,7 +269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -342,20 +278,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var u_1>}\n",
-      "OutVars:{<Var x_1>}\n",
-      "A: -1*u_1 <= -1\n",
-      "G: -1*x_1 <= -1.5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(synthesize_c1)"
    ]
@@ -369,7 +294,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -378,20 +303,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var u_2>}\n",
-      "OutVars:{<Var x_2>}\n",
-      "A: -1*u_2 <= -1\n",
-      "G: -1*x_2 <= -0.30000000000000004\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(synthesize_c2)"
    ]
@@ -405,7 +319,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -414,27 +328,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "InVars: {<Var u_2>, <Var u_1>}\n",
-      "OutVars:{<Var x_1>, <Var x_2>}\n",
-      "A: -1*u_1 <= -1, -1*u_2 <= -1\n",
-      "G: -1*x_1 <= -1.5, -1*x_2 <= -0.30000000000000004\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(synthesize_c12)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -443,28 +346,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(synthesize_c1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "InVars: {<Var u_1>}\n",
-      "OutVars:{<Var x_1>}\n",
-      "A: -1*u_1 <= -1.0\n",
-      "G: -1*x_1 <= -1.5\n"
+      "Success\n"
      ]
     }
    ],
    "source": [
-    "print(synthesize_c1)"
+    "print('Success')"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3.10.4 64-bit",
    "language": "python",
    "name": "python3"
   },
@@ -478,7 +394,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.10.4"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"
+   }
   }
  },
  "nbformat": 4,
diff --git a/mkdocs.yml b/mkdocs.yml
index 2a67e887..de30bd36 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -15,10 +15,11 @@ nav:
   - License: license.md
 # defer to gen-files + literate-nav
 - Case Studies:
-  - Autonomous Systems: case_studies/autonomous.md
-  - Multi-agent Coordination: case_studies/multi_agent.md
-  - Signal Processing in Digital ICs: case_studies/signal_processing_ic.md
-  - Synthetic Biology: case_studies/synthbio.md
+  - Autonomous Systems:
+    - Simple script: case_studies/evaluating_perception/simple_script.ipynb
+  #- Multi-agent Coordination: case_studies/multi_agent.md
+  #- Signal Processing in Digital ICs: case_studies/signal_processing_ic.md
+  #- Synthetic Biology: case_studies/synthbio.md
 - Documentation: #reference/
   - IoContract: iocontract.md
   - PolyhedralTerms : Polyhedral.md
@@ -90,6 +91,7 @@ extra_javascript:
 
 plugins:
 - search
+- mkdocs-jupyter:
 - markdown-exec
 - gen-files:
     scripts:
diff --git a/pyproject.toml b/pyproject.toml
index 2c27bcd3..0978f714 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -33,6 +33,7 @@ editable-backend = "editables"
 duty = ["duty>=0.7"]
 docs = [
     "mkdocs>=1.3",
+    "mkdocs-jupyter",
     "mkdocs-coverage>=0.2",
     "mkdocs-gen-files>=0.3",
     "mkdocs-literate-nav>=0.4",
diff --git a/src/gear/terms/polyhedra/__init__.py b/src/gear/terms/polyhedra/__init__.py
index d8559cd1..e797ed8c 100644
--- a/src/gear/terms/polyhedra/__init__.py
+++ b/src/gear/terms/polyhedra/__init__.py
@@ -1,1 +1,2 @@
 from .polyhedra import PolyhedralTerm, PolyhedralTermList
+from .loaders import readContract, writeContract
\ No newline at end of file
diff --git a/src/gear/terms/polyhedra/loaders.py b/src/gear/terms/polyhedra/loaders.py
index fcc3b365..b2b7d965 100644
--- a/src/gear/terms/polyhedra/loaders.py
+++ b/src/gear/terms/polyhedra/loaders.py
@@ -20,7 +20,7 @@ def readContract(contract):
     list_iocontracts = []
     for c in contract:
         if type(c) is not dict:
-            return ValueError("A dict type contract is expected.")
+            raise ValueError("A dict type contract is expected.")
         reqs = []
         for key in ["assumptions", "guarantees"]:
             reqs.append([PolyhedralTerm(term["coefficients"], term["constant"]) for term in c[key]])
@@ -37,7 +37,7 @@ def readContract(contract):
         return list_iocontracts
 
 
-def writeContract(contract, filename: str = None):
+def writeContract(contract, filename: str=None):
     """
     Converts a gear.IoContract to a dictionary. If a list of iocontracts is passed,
     then a list of dicts is returned.
@@ -60,11 +60,11 @@ def writeContract(contract, filename: str = None):
         contract_dict["InputVars"] = [str(var) for var in c.inputvars]
         contract_dict["OutputVars"] = [str(var) for var in c.outputvars]
         contract_dict["assumptions"] = [
-            {"constant": str(term.constant), "coefficients": {str(k): str(v) for k, v in term.variables.items()}}
+            {"constant":term.constant, "coefficients": {str(k): v for k, v in term.variables.items()}}
             for term in c.a.terms
         ]
         contract_dict["guarantees"] = [
-            {"constant": str(term.constant), "coefficients": {str(k): str(v) for k, v in term.variables.items()}}
+            {"constant": term.constant, "coefficients": {str(k): v for k, v in term.variables.items()}}
             for term in c.g.terms
         ]
         contract_list.append(contract_dict)


Test patch:
diff --git a/tests/test_examples.py b/tests/test_examples.py
new file mode 100644
index 00000000..aa140f20
--- /dev/null
+++ b/tests/test_examples.py
@@ -0,0 +1,6 @@
+import pytest
+import os
+
+def test_examples():
+    result = os.popen("jupyter nbconvert --to script --execute --stdout examples/AND_logic_gate.ipynb | python3").read()
+    assert result[-1] == '\n'
\ No newline at end of file
diff --git a/tests/test_iocontract.py b/tests/test_iocontract.py
index b96db048..67f64ef6 100644
--- a/tests/test_iocontract.py
+++ b/tests/test_iocontract.py
@@ -1,12 +1,30 @@
 import gear.iocontract as iocontract
-
+from gear.terms.polyhedra.loaders import readContract
 
 def validate_iocontract(contract):
-    assert isinstance(contract, iocontract.IoContract)
-
+    return isinstance(contract, iocontract.IoContract)
 
+def create_contracts(num=1):
+    """
+    Creates `num` number of contracts and returns a list of dicts
+    """
+    contracts = []
+    for i in range(num):
+        c = {
+            "InputVars": ["i" + str(i)],
+            "OutputVars": ["o" + str(i)],
+            "assumptions": [{"coefficients": {"i" + str(i): 1}, "constant": i}],
+            "guarantees": [{"coefficients": {"o" + str(i): 1}, "constant": 1}],
+        }
+        contracts.append(c)
+    if num == 1:
+        return contracts[0]
+    else:
+        return contracts
+    
 def test_validate_iocontract():
-    exit()
+    c1, c2 = readContract(create_contracts(num=2))
+    print(type(c1))
     assert validate_iocontract(c1)
     assert validate_iocontract(c2)
 
diff --git a/tests/test_polyhedral_terms.py b/tests/test_polyhedral_terms.py
index 140a7aa5..f6e0663e 100644
--- a/tests/test_polyhedral_terms.py
+++ b/tests/test_polyhedral_terms.py
@@ -115,17 +115,17 @@ def test_polyhedral_deduce_7():
     assert reference.terms == expected.terms
 
 
-def test_polyhedral_abduce_8():
-    # a term that can be simplified with one element of the context
-    y = Var("y")
-    z = Var("z")
-    reference = to_pts(["x + -z + y <= -1"])
-    context = to_pts(["4*y - 9*z <= -2", "5*y - z <= 2"])
-    # the expected value is wrong
-    expected = to_pts(["x <= -0.2"])
-    vars_elim = {y, z}
-    reference = reference.abduce_with_context(context, vars_elim)
-    assert reference.terms == expected.terms
+#def test_polyhedral_abduce_8():
+#    # a term that can be simplified with one element of the context
+#    y = Var("y")
+#    z = Var("z")
+#    reference = to_pts(["x + -z + y <= -1"])
+#    context = to_pts(["4*y - 9*z <= -2", "5*y - z <= 2"])
+#    # the expected value is wrong
+#    expected = to_pts(["x <= -0.2"])
+#    vars_elim = {y, z}
+#    reference = reference.abduce_with_context(context, vars_elim)
+#    assert reference.terms == expected.terms
 
 
 def test_simplify_1():
diff --git a/tests/test_py_loaders.py b/tests/test_py_loaders.py
index 7750cdef..82054d2a 100644
--- a/tests/test_py_loaders.py
+++ b/tests/test_py_loaders.py
@@ -1,9 +1,7 @@
-import pytest
-from test_iocontract import validate_iocontract
-
 import gear.iocontract as iocontract
 from gear.terms.polyhedra.loaders import readContract, writeContract
-
+from test_iocontract import validate_iocontract
+import pytest
 
 def create_contracts(num=1):
     """
@@ -25,9 +23,10 @@ def create_contracts(num=1):
 
 
 def test_read_contract():
+    # Create 1 contract and read it
     c = create_contracts(1)
-    io_c = readContract(c)
-    assert isinstance(io_c, iocontract.IoContract)
+    validate_iocontract(readContract(c))
+    # Create 5 contracts and read 
     c = create_contracts(5)
     io_contracts = readContract(c)
     assert len(io_contracts) == 5
@@ -36,12 +35,13 @@ def test_read_contract():
         assert validate_iocontract(io_c)
     # Ensure that all contracts are dictionaries
     c = [("InputVars", "u"), ("OutputVars", "x")]
-    with pytest.raises(ValueError, "A dict type contract is expected."):
+    with pytest.raises(ValueError, match="A dict type contract is expected."):
         readContract(c)
 
-
 def test_write_contract():
     c = create_contracts(1)
     io_c = readContract(c)
     assert c == writeContract(io_c)
     all_contracts = create_contracts(5)
+    io_contracts = readContract(all_contracts)
+    assert all_contracts == writeContract(io_contracts)