diff --git a/analysis_and_scripts/Analysis_07MAY2019_old.ipynb b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
index afd68c061c69998237840fac2a892b6ef9aae3b8..e0e53d27d177d03e940d0fa27d88eb79f434a520 100644
--- a/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
+++ b/analysis_and_scripts/Analysis_07MAY2019_old.ipynb
@@ -56,7 +56,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -221,7 +221,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
index 3f501023444e62555540e0a8378515e2be1d76c2..7af029a0470e6ce72887d5341f611e62970fb013 100644
--- a/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
+++ b/analysis_and_scripts/Analysis_25JUN2019_modular.ipynb
@@ -7,7 +7,7 @@
    },
    "source": [
     "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
-    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data-generation-modules\" data-toc-modified-id=\"Data-generation-modules-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Data generation modules</a></span></li><li><span><a href=\"#Decider-modules\" data-toc-modified-id=\"Decider-modules-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Decider modules</a></span></li><li><span><a href=\"#Evaluator-modules\" data-toc-modified-id=\"Evaluator-modules-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Evaluator modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convenience-functions\" data-toc-modified-id=\"Convenience-functions-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Convenience functions</a></span></li><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Evaluators\" data-toc-modified-id=\"Evaluators-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Evaluators</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>With unobservables in the data</a></span></li></ul></li></ul></div>"
+    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Data-generation-modules\" data-toc-modified-id=\"Data-generation-modules-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Data generation modules</a></span></li><li><span><a href=\"#Decider-modules\" data-toc-modified-id=\"Decider-modules-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Decider modules</a></span></li><li><span><a href=\"#Evaluator-modules\" data-toc-modified-id=\"Evaluator-modules-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Evaluator modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Convenience-functions\" data-toc-modified-id=\"Convenience-functions-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Convenience functions</a></span></li><li><span><a href=\"#Contraction-algorithm\" data-toc-modified-id=\"Contraction-algorithm-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Contraction algorithm</a></span></li><li><span><a href=\"#Evaluators\" data-toc-modified-id=\"Evaluators-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Evaluators</a></span></li></ul></li><li><span><a href=\"#Performance-comparison\" data-toc-modified-id=\"Performance-comparison-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Performance comparison</a></span><ul class=\"toc-item\"><li><span><a href=\"#Without-unobservables-in-the-data\" data-toc-modified-id=\"Without-unobservables-in-the-data-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Without unobservables in the data</a></span></li><li><span><a href=\"#With-unobservables-in-the-data\" data-toc-modified-id=\"With-unobservables-in-the-data-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>With unobservables in the data</a></span></li></ul></li><li><span><a href=\"#Bayesian-sampling\" data-toc-modified-id=\"Bayesian-sampling-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Bayesian sampling</a></span></li></ul></div>"
    ]
   },
   {
@@ -19,7 +19,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -68,14 +68,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 94,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def sigmoid(x):\n",
-    "    '''Return value of sigmoid function (inverse of logit) at x.'''\n",
+    "def inv_logit(x):\n",
+    "    '''Return value of inverse of logit function (logistic / sigmoid) at x.'''\n",
+    "\n",
+    "    return 1.0 / (1.0 + np.exp(-1.0 * x))\n",
     "\n",
-    "    return 1 / (1 + np.exp(-1 * x))\n",
+    "\n",
+    "def logit(p):\n",
+    "    return np.log(p) - np.log(1 - p)\n",
     "\n",
     "\n",
     "def coinFlipDGWithoutUnobservables(N_total=50000):\n",
@@ -85,11 +89,11 @@
     "    # Sample feature X from standard Gaussian distribution, N(0, 1).\n",
     "    df = df.assign(X=npr.normal(size=N_total))\n",
     "\n",
-    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
-    "    df = df.assign(probabilities_Y=sigmoid(df.X))\n",
+    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = inv_logit(X)\n",
+    "    df = df.assign(probabilities_Y=inv_logit(df.X))\n",
     "\n",
-    "    # Draw Y ~ Bernoulli(1 - sigmoid(X))\n",
-    "    # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - sigmoid(X)\n",
+    "    # Draw Y ~ Bernoulli(1 - inv_logit(X))\n",
+    "    # Note: P(Y=1|X=x) = 1 - P(Y=0|X=x) = 1 - inv_logit(X)\n",
     "    results = npr.binomial(n=1, p=1 - df.probabilities_Y, size=N_total)\n",
     "\n",
     "    df = df.assign(result_Y=results)\n",
@@ -107,7 +111,7 @@
     "    df = df.assign(W=npr.normal(size=N_total))\n",
     "\n",
     "    # Calculate P(Y=0|X, Z, W)\n",
-    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
+    "    probabilities_Y = inv_logit(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
     "\n",
     "    df = df.assign(probabilities_Y=probabilities_Y)\n",
     "\n",
@@ -129,15 +133,13 @@
     "    df = df.assign(Z=npr.normal(size=N_total))\n",
     "    df = df.assign(W=npr.normal(size=N_total))\n",
     "\n",
-    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = sigmoid(X)\n",
-    "    probabilities_Y = sigmoid(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
+    "    # Calculate P(Y=0|X=x) = 1 / (1 + exp(-X)) = inv_logit(X)\n",
+    "    probabilities_Y = inv_logit(beta_X * df.X + beta_Z * df.Z + beta_W * df.W)\n",
     "\n",
     "    df = df.assign(probabilities_Y=probabilities_Y)\n",
     "\n",
     "    # Draw Y from Bernoulli distribution\n",
-    "    results = npr.binomial(n=1,\n",
-    "                           p=1 - df.probabilities_Y,\n",
-    "                           size=N_total)\n",
+    "    results = npr.binomial(n=1, p=1 - df.probabilities_Y, size=N_total)\n",
     "\n",
     "    df = df.assign(result_Y=results)\n",
     "\n",
@@ -153,17 +155,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [],
    "source": [
     "def humanDeciderLakkaraju(df,\n",
     "                          result_Y,\n",
     "                          featureX_col,\n",
-    "                          featureZ_col,\n",
+    "                          featureZ_col=None,\n",
     "                          nJudges_M=100,\n",
     "                          beta_X=1,\n",
     "                          beta_Z=1,\n",
+    "                          add_epsilon=True,\n",
     "                          hide_unobserved=True):\n",
     "\n",
     "    # Assert that every judge will have the same number of subjects.\n",
@@ -182,8 +185,14 @@
     "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
     "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
     "\n",
-    "    probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
-    "    probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
     "\n",
     "    df = df.assign(probabilities_T=probabilities_T)\n",
     "\n",
@@ -203,7 +212,7 @@
     "    df['decision_T'] = np.where((df.index.values % nSubjects_N) <\n",
     "                                ((1 - df['acceptanceRate_R']) * nSubjects_N),\n",
     "                                0, 1)\n",
-    "    \n",
+    "\n",
     "    if hide_unobserved:\n",
     "        df.loc[df.decision_T == 0, result_Y] = np.nan\n",
     "\n",
@@ -212,10 +221,11 @@
     "\n",
     "def coinFlipDecider(df,\n",
     "                    featureX_col,\n",
-    "                    featureZ_col,\n",
+    "                    featureZ_col=None,\n",
     "                    nJudges_M=100,\n",
     "                    beta_X=1,\n",
     "                    beta_Z=1,\n",
+    "                    add_epsilon=False,\n",
     "                    hide_unobserved=True):\n",
     "\n",
     "    # Assert that every judge will have the same number of subjects.\n",
@@ -227,18 +237,20 @@
     "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
     "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
     "\n",
-    "    # Sample acceptance rates uniformly from a closed interval\n",
-    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
-    "    #acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
-    "    \n",
-    "    # No real leniency here???\n",
-    "    acceptance_rates = np.ones(nJudges_M)*0.5\n",
-    "    \n",
+    "    # No real leniency here -> set to 0.5.\n",
+    "    acceptance_rates = np.ones(nJudges_M) * 0.5\n",
+    "\n",
     "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
     "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
     "\n",
-    "    probabilities_T = sigmoid(beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
-    "    #probabilities_T += np.sqrt(0.1) * npr.normal(size=nJudges_M * nSubjects_N)\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
     "\n",
     "    df = df.assign(probabilities_T=probabilities_T)\n",
     "\n",
@@ -246,10 +258,64 @@
     "    decisions = npr.binomial(n=1, p=1 - df.probabilities_T, size=df.shape[0])\n",
     "\n",
     "    df = df.assign(decision_T=decisions)\n",
-    "    \n",
+    "\n",
     "    if hide_unobserved:\n",
     "        df.loc[df.decision_T == 0, 'result_Y'] = np.nan\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "def quantileDecider(df,\n",
+    "                    featureX_col,\n",
+    "                    featureZ_col=None,\n",
+    "                    nJudges_M=100,\n",
+    "                    beta_X=1,\n",
+    "                    beta_Z=1,\n",
+    "                    add_epsilon=False,\n",
+    "                    hide_unobserved=True,\n",
+    "                    N_sim = int(1e7)):\n",
+    "\n",
+    "    # Assert that every judge will have the same number of subjects.\n",
+    "    assert df.shape[0] % nJudges_M == 0, \"Can't assign subjets evenly!\"\n",
+    "\n",
+    "    # Compute the number of subjects allocated for each judge.\n",
+    "    nSubjects_N = int(df.shape[0] / nJudges_M)\n",
+    "\n",
+    "    # Assign judge IDs as running numbering from 0 to nJudges_M - 1\n",
+    "    df = df.assign(judgeID_J=np.repeat(range(0, nJudges_M), nSubjects_N))\n",
+    "\n",
+    "    # Sample acceptance rates uniformly from a closed interval\n",
+    "    # from 0.1 to 0.9 and round to tenth decimal place.\n",
+    "    acceptance_rates = np.round(npr.uniform(.1, .9, nJudges_M), 10)\n",
+    "\n",
+    "    # Replicate the rates so they can be attached to the corresponding judge ID.\n",
+    "    df = df.assign(acceptanceRate_R=np.repeat(acceptance_rates, nSubjects_N))\n",
+    "\n",
+    "    if featureZ_col is None:\n",
+    "        probabilities_T = inv_logit(beta_X * df[featureX_col])\n",
+    "    else:\n",
+    "        probabilities_T = inv_logit(\n",
+    "            beta_X * df[featureX_col] + beta_Z * df[featureZ_col])\n",
+    "\n",
+    "    if add_epsilon:\n",
+    "        probabilities_T += np.sqrt(0.1) * npr.normal(size=df.shape[0])\n",
+    "\n",
+    "    df = df.assign(probabilities_T=probabilities_T)\n",
+    "\n",
+    "    # Construct the quantile function by sampling from two Gaussians and using\n",
+    "    # their sum through the inverse of logit.\n",
+    "    probs = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "    # Now if P(Y=0|X, Z) (named 'probabilities_T') is greater than Q(r), a.k.a\n",
+    "    # the rth quantile of 'probs', T will be 0 and 1 otherwise.\n",
+    "    df = df.assign(quantile_bounds = np.quantile(probs, df.acceptanceRate_R))\n",
     "    \n",
+    "    df = df.assign(decision_T=np.where(\n",
+    "        df.probabilities_T >= df.quantile_bounds, 0, 1))\n",
+    "\n",
+    "    if hide_unobserved:\n",
+    "        df.loc[df.decision_T == 0, 'result_Y'] = np.nan\n",
+    "\n",
     "    return df"
    ]
   },
@@ -264,7 +330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -385,7 +451,7 @@
     "    y_values = scs.norm.pdf(x_values)\n",
     "\n",
     "    results = np.zeros(x_0.shape[0])\n",
-    "    print(\"en loop\")\n",
+    "\n",
     "    for i in range(x_0.shape[0]):\n",
     "\n",
     "        y_copy = y_values.copy()\n",
@@ -393,7 +459,7 @@
     "        y_copy[x_preds > prediction_x_0[i]] = 0\n",
     "        \n",
     "        results[i] = si.simps(y_copy, x=x_values)\n",
-    "    print(\"jlk loop\")\n",
+    "\n",
     "    return results\n",
     "\n",
     "\n",
@@ -457,7 +523,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -519,7 +585,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 218,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -559,7 +625,7 @@
     "\n",
     "    test.sort_values(by='B_prob_0_model', inplace=True, ascending=True)\n",
     "\n",
-    "    to_release = int(round(test.shape[0] * r / 10))\n",
+    "    to_release = int(round(test.shape[0] * r))\n",
     "\n",
     "    return np.sum(test[resultY_col][0:to_release] == 0) / test.shape[0]\n",
     "\n",
@@ -581,7 +647,7 @@
     "                                              inplace=False,\n",
     "                                              ascending=True)\n",
     "\n",
-    "    to_release = int(round(test_observed.shape[0] * r / 10))\n",
+    "    to_release = int(round(test_observed.shape[0] * r))\n",
     "\n",
     "    return np.sum(\n",
     "        test_observed[resultY_col][0:to_release] == 0) / test.shape[0]\n",
@@ -591,7 +657,7 @@
     "                             accRateR_col, r):\n",
     "\n",
     "    # Get judges with correct leniency as list\n",
-    "    is_correct_leniency = df[accRateR_col].round(1) == r / 10\n",
+    "    is_correct_leniency = df[accRateR_col].round(1) == r\n",
     "\n",
     "    correct_leniency_list = df.loc[is_correct_leniency, judgeIDJ_col]\n",
     "\n",
@@ -614,9 +680,58 @@
     "\n",
     "    test = test.assign(B_prob_0_model=predictions)\n",
     "\n",
-    "    released = cdf(test[featureX_col], B_model, 0) < r / 10\n",
+    "    released = cdf(test[featureX_col], B_model, 0) < r\n",
     "\n",
-    "    return np.mean(test.B_prob_0_model * released)"
+    "    return np.mean(test.B_prob_0_model * released)\n",
+    "\n",
+    "\n",
+    "def monteCarloEvaluator(df,\n",
+    "                        featureX_col,\n",
+    "                        decisionT_col,\n",
+    "                        resultY_col,\n",
+    "                        accRateR_col,\n",
+    "                        r,\n",
+    "                        N_sim=int(1e6)):\n",
+    "\n",
+    "    train, test = train_test_split(df, test_size=0.5)\n",
+    "\n",
+    "    B_model, predictions = fitPredictiveModel(\n",
+    "        train.loc[train[decisionT_col] == 1, featureX_col],\n",
+    "        train.loc[train[decisionT_col] == 1, resultY_col], test[featureX_col],\n",
+    "        0)\n",
+    "\n",
+    "    test = test.assign(B_prob_0_model=predictions)\n",
+    "\n",
+    "    quants = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "    Z = npr.normal(size=N_sim)\n",
+    "    e = np.sqrt(0.1) * npr.normal(size=N_sim)\n",
+    "    test = test.assign(predicted_Y=np.zeros_like(test[featureX_col]))\n",
+    "\n",
+    "    q_r = np.quantile(quants, test[accRateR_col])\n",
+    "\n",
+    "    test = test.assign(bounds=logit(q_r) - test[featureX_col])\n",
+    "\n",
+    "    for i in range(test.shape[0]):\n",
+    "        Zp = []\n",
+    "        if test[decisionT_col].iloc[i] == 0:\n",
+    "            Zp = Z[Z + e > test.bounds.iloc[i]]\n",
+    "        else:\n",
+    "            Zp = Z[Z + e < test.bounds.iloc[i]]\n",
+    "\n",
+    "        test.iloc[i, test.columns == 'predicted_Y'] = inv_logit(\n",
+    "            test[featureX_col].iloc[i] + np.mean(Zp))\n",
+    "\n",
+    "    predictions = npr.binomial(n=1, p=1-test.predicted_Y, size=test.shape[0])\n",
+    "\n",
+    "    test[resultY_col] = np.where(\n",
+    "        test[decisionT_col] == 0, predictions, test[resultY_col])\n",
+    "\n",
+    "    test.sort_values(by='B_prob_0_model', inplace=True, ascending=True)\n",
+    "\n",
+    "    to_release = int(round(test.shape[0] * r))\n",
+    "\n",
+    "    return np.sum(test[resultY_col][0:to_release] == 0) / test.shape[0]"
    ]
   },
   {
@@ -630,186 +745,182 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "heading_collapsed": true
-   },
+   "metadata": {},
    "source": [
-    "### Without unobservables in the data\n",
-    "\n",
-    "The underlying figure is attached to the preliminary paper. When conducting finalization, last analysis should be conducted with a preset random seed."
+    "### Without unobservables in the data"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 217,
    "metadata": {
-    "hidden": true,
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1] 0 1 2 3 4 5 6 7 8 9 [2] 0 1 2 3 4 5 6 7 8 9 [3] 0 1 2 3 4 5 6 7 8 9 [4] 0 1 2 3 4 5 6 7 8 9 [5] 0 1 2 3 4 5 6 7 8 9 [6] 0 1 2 3 4 5 6 7 8 9 [7] 0 1 2 3 4 5 6 7 8 9 [8] 0 1 2 3 4 5 6 7 8 9 "
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[0.015424   0.005856   0.00700873 0.01609152 0.015964  ]\n",
+      " [0.042124   0.015944   0.02125723 0.04435839 0.043916  ]\n",
+      " [0.075464   0.02872    0.04810652 0.07724867 0.08046   ]\n",
+      " [0.1153     0.043196   0.10059008 0.10665967 0.124604  ]\n",
+      " [0.163496   0.0588     0.16363783 0.15052531 0.177884  ]\n",
+      " [0.216236   0.079128   0.24141272 0.21342228 0.236504  ]\n",
+      " [0.275828   0.101944   0.31497867 0.28211075 0.299696  ]\n",
+      " [0.341464   0.1261     0.40679724 0.33790021 0.37086   ]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.09820600000000002\n",
+      "0.025143988486187003\n",
+      "0.004869733260249362\n",
+      "0.013068999999999989\n"
+     ]
+    }
+   ],
    "source": [
-    "# f_rates = np.zeros((8, 5))\n",
-    "# f_sems = np.zeros((8, 5))\n",
+    "failure_rates = np.zeros((8, 5))\n",
+    "failure_sems = np.zeros((8, 5))\n",
     "\n",
-    "# nIter = 15\n",
+    "nIter = 10\n",
     "\n",
-    "# #npr.seed(0)\n",
+    "for r in np.arange(1, 9):\n",
     "\n",
-    "# for r in np.arange(1, 9):\n",
+    "    print(\"[\", r, \"]\", sep='', end=\" \")\n",
     "\n",
-    "#     print(\"[\", r, \"]\", sep='', end=\" \")\n",
+    "    f_rate_true = np.zeros(nIter)\n",
+    "    f_rate_label = np.zeros(nIter)\n",
+    "    f_rate_human = np.zeros(nIter)\n",
+    "    f_rate_cont = np.zeros(nIter)\n",
+    "    f_rate_caus = np.zeros(nIter)\n",
     "\n",
-    "#     s_f_rate_true = np.zeros(nIter)\n",
-    "#     s_f_rate_labeled = np.zeros(nIter)\n",
-    "#     s_f_rate_human = np.zeros(nIter)\n",
-    "#     s_f_rate_cont = np.zeros(nIter)\n",
-    "#     s_f_rate_caus = np.zeros(nIter)\n",
+    "    for i in range(nIter):\n",
     "\n",
-    "#     for i in range(nIter):\n",
+    "        print(i, end=\" \")\n",
+    "\n",
+    "        # Create data\n",
+    "        df = coinFlipDGWithoutUnobservables()\n",
+    "\n",
+    "        # Decider\n",
+    "        df_labeled = quantileDecider(df,\n",
+    "                                     featureX_col=\"X\",\n",
+    "                                     featureZ_col=None,\n",
+    "                                     nJudges_M=100,\n",
+    "                                     beta_X=1,\n",
+    "                                     beta_Z=1,\n",
+    "                                     hide_unobserved=True)\n",
+    "\n",
+    "        df_unlabeled = quantileDecider(df,\n",
+    "                                       featureX_col=\"X\",\n",
+    "                                       featureZ_col=None,\n",
+    "                                       nJudges_M=100,\n",
+    "                                       beta_X=1,\n",
+    "                                       beta_Z=1,\n",
+    "                                       hide_unobserved=False)\n",
+    "\n",
+    "        # True evaluation\n",
     "\n",
-    "#         print(i, end=\" \")\n",
+    "        f_rate_true[i] = trueEvaluationEvaluator(df_unlabeled, 'X',\n",
+    "                                                 'decision_T', 'result_Y',\n",
+    "                                                 r / 10)\n",
     "\n",
-    "#         s_train_labeled, s_train, s_test_labeled, s_test, s_df = dataWithoutUnobservables(sigma=2)\n",
+    "        # Labeled outcomes only\n",
     "\n",
-    "#         s_logreg, predictions = fitPredictiveModel(\n",
-    "#             s_train_labeled.dropna().X,\n",
-    "#             s_train_labeled.dropna().result_Y, s_test.X, 0)\n",
-    "#         s_test = s_test.assign(B_prob_0_model=predictions)\n",
+    "        f_rate_label[i] = labeledOutcomesEvaluator(df_labeled, 'X',\n",
+    "                                                   'decision_T', 'result_Y',\n",
+    "                                                   r / 10)\n",
     "\n",
-    "#         s_logreg, predictions_labeled = fitPredictiveModel(\n",
-    "#             s_train_labeled.dropna().X,\n",
-    "#             s_train_labeled.dropna().result_Y, s_test_labeled.X, 0)\n",
-    "#         s_test_labeled = s_test_labeled.assign(\n",
-    "#             B_prob_0_model=predictions_labeled)\n",
+    "        # Human evaluation\n",
     "\n",
-    "#         #### True evaluation\n",
-    "#         # Sort by actual failure probabilities, subjects with the smallest risk are first.\n",
-    "#         s_sorted = s_test.sort_values(by='B_prob_0_model',\n",
-    "#                                       inplace=False,\n",
-    "#                                       ascending=True)\n",
-    "\n",
-    "#         to_release = int(round(s_sorted.shape[0] * r / 10))\n",
-    "\n",
-    "#         # Calculate failure rate as the ratio of failures to successes among those\n",
-    "#         # who were given a positive decision, i.e. those whose probability of negative\n",
-    "#         # outcome was low enough.\n",
-    "#         s_f_rate_true[i] = np.sum(\n",
-    "#             s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
-    "\n",
-    "#         #### Labeled outcomes\n",
-    "#         # Sort by estimated failure probabilities, subjects with the smallest risk are first.\n",
-    "#         s_sorted = s_test_labeled.sort_values(by='B_prob_0_model',\n",
-    "#                                               inplace=False,\n",
-    "#                                               ascending=True)\n",
-    "\n",
-    "#         to_release = int(round(s_test_labeled.dropna().shape[0] * r / 10))\n",
-    "\n",
-    "#         # Calculate failure rate as the ratio of failures to successes among those\n",
-    "#         # who were given a positive decision, i.e. those whose probability of negative\n",
-    "#         # outcome was low enough.\n",
-    "#         s_f_rate_labeled[i] = np.sum(\n",
-    "#             s_sorted.result_Y[0:to_release] == 0) / s_sorted.shape[0]\n",
-    "\n",
-    "#         #### Human error rate\n",
-    "#         # Get judges with correct leniency as list\n",
-    "#         correct_leniency_list = s_test_labeled.judgeID_J[\n",
-    "#             s_test_labeled['acceptanceRate_R'].round(1) == r / 10].values\n",
-    "\n",
-    "#         # Released are the people they judged and released, T = 1\n",
-    "#         released = s_test_labeled[\n",
-    "#             s_test_labeled.judgeID_J.isin(correct_leniency_list)\n",
-    "#             & (s_test_labeled.decision_T == 1)]\n",
-    "\n",
-    "#         # Get their failure rate, aka ratio of reoffenders to number of people judged in total\n",
-    "#         s_f_rate_human[i] = np.sum(\n",
-    "#             released.result_Y == 0) / correct_leniency_list.shape[0]\n",
-    "\n",
-    "#         #### Contraction\n",
-    "#         s_f_rate_cont[i] = contraction(s_test_labeled, 'judgeID_J',\n",
-    "#                                        'decision_T', 'result_Y',\n",
-    "#                                        'B_prob_0_model', 'acceptanceRate_R',\n",
-    "#                                        r / 10)\n",
-    "#         #### Causal model\n",
-    "\n",
-    "#         #released = bailIndicator(r * 10, s_logreg, s_train.X, s_test.X)\n",
-    "#         released=0\n",
-    "#         #released = cdf(s_test.X, s_logreg, 0) < r / 10\n",
-    "\n",
-    "#         s_f_rate_caus[i] = np.mean(s_test.B_prob_0_model * released)\n",
-    "\n",
-    "#         ########################\n",
-    "#         #percentiles = estimatePercentiles(s_train_labeled.X, s_logreg)\n",
-    "\n",
-    "#         #def releaseProbability(x):\n",
-    "#         #    return calcReleaseProbabilities(r * 10,\n",
-    "#         #                                     s_train_labeled.X,\n",
-    "#         #                                     x,\n",
-    "#         #                                     s_logreg,\n",
-    "#         #                                     percentileMatrix=percentiles)\n",
-    "\n",
-    "#         #def integrand(x):\n",
-    "#         #    p_y0 = s_logreg.predict_proba(x.reshape(-1, 1))[:, 0]\n",
-    "\n",
-    "#         #    p_t1 = releaseProbability(x)\n",
-    "\n",
-    "#         #    p_x = scs.norm.pdf(x)\n",
-    "\n",
-    "#         #    return p_y0 * p_t1 * p_x\n",
-    "\n",
-    "#         #s_f_rate_caus[i] = si.quad(lambda x: integrand(np.ones((1, 1)) * x),\n",
-    "#         #                           -10, 10)[0]\n",
-    "\n",
-    "#     f_rates[r - 1, 0] = np.mean(s_f_rate_true)\n",
-    "#     f_rates[r - 1, 1] = np.mean(s_f_rate_labeled)\n",
-    "#     f_rates[r - 1, 2] = np.mean(s_f_rate_human)\n",
-    "#     f_rates[r - 1, 3] = np.mean(s_f_rate_cont)\n",
-    "#     f_rates[r - 1, 4] = np.mean(s_f_rate_caus)\n",
-    "\n",
-    "#     f_sems[r - 1, 0] = scs.sem(s_f_rate_true)\n",
-    "#     f_sems[r - 1, 1] = scs.sem(s_f_rate_labeled)\n",
-    "#     f_sems[r - 1, 2] = scs.sem(s_f_rate_human)\n",
-    "#     f_sems[r - 1, 3] = scs.sem(s_f_rate_cont)\n",
-    "#     f_sems[r - 1, 4] = scs.sem(s_f_rate_caus)\n",
-    "\n",
-    "# x_ax = np.arange(0.1, 0.9, 0.1)\n",
-    "\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 0],\n",
-    "#              label='True Evaluation',\n",
-    "#              c='green',\n",
-    "#              yerr=f_sems[:, 0])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 1],\n",
-    "#              label='Labeled outcomes',\n",
-    "#              c='magenta',\n",
-    "#              yerr=f_sems[:, 1])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 2],\n",
-    "#              label='Human evaluation',\n",
-    "#              c='red',\n",
-    "#              yerr=f_sems[:, 2])\n",
-    "# plt.errorbar(x_ax,\n",
-    "#              f_rates[:, 3],\n",
-    "#              label='Contraction, log.',\n",
-    "#              c='blue',\n",
-    "#              yerr=f_sems[:, 3])\n",
-    "# # plt.errorbar(x_ax,\n",
-    "# #              f_rates[:, 4],\n",
-    "# #              label='Causal model, ep',\n",
-    "# #              c='black',\n",
-    "# #              yerr=f_sems[:, 4])\n",
-    "\n",
-    "# plt.title('Failure rate vs. Acceptance rate without unobservables')\n",
-    "# plt.xlabel('Acceptance rate')\n",
-    "# plt.ylabel('Failure rate')\n",
-    "# plt.legend()\n",
-    "# plt.grid()\n",
-    "# plt.show()\n",
-    "\n",
-    "# print(f_rates)\n",
-    "# print(\"\\nMean absolute errors:\")\n",
-    "# for i in range(1, f_rates.shape[1]):\n",
-    "#     print(np.mean(np.abs(f_rates[:, 0] - f_rates[:, i])))"
+    "        f_rate_human[i] = humanEvaluationEvaluator(df_labeled, 'judgeID_J',\n",
+    "                                                   'decision_T', 'result_Y',\n",
+    "                                                   'acceptanceRate_R', r / 10)\n",
+    "\n",
+    "        # Contraction\n",
+    "\n",
+    "        f_rate_cont[i] = contractionEvaluator(df_labeled, 'X', 'judgeID_J',\n",
+    "                                              'decision_T', 'result_Y',\n",
+    "                                              'acceptanceRate_R', r / 10)\n",
+    "\n",
+    "        # Causal model - empirical performance\n",
+    "\n",
+    "        #f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "        #                                 'result_Y', r / 10)\n",
+    "\n",
+    "        f_rate_caus[i] = monteCarloEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "                                             'result_Y', 'acceptanceRate_R',\n",
+    "                                             r / 10, N_sim=int(1e5))\n",
+    "\n",
+    "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
+    "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
+    "    failure_rates[r - 1, 2] = np.mean(f_rate_human)\n",
+    "    failure_rates[r - 1, 3] = np.mean(f_rate_cont)\n",
+    "    failure_rates[r - 1, 4] = np.mean(f_rate_caus)\n",
+    "\n",
+    "    failure_sems[r - 1, 0] = scs.sem(f_rate_true)\n",
+    "    failure_sems[r - 1, 1] = scs.sem(f_rate_label)\n",
+    "    failure_sems[r - 1, 2] = scs.sem(f_rate_human)\n",
+    "    failure_sems[r - 1, 3] = scs.sem(f_rate_cont)\n",
+    "    failure_sems[r - 1, 4] = scs.sem(f_rate_caus)\n",
+    "\n",
+    "x_ax = np.arange(0.1, 0.9, 0.1)\n",
+    "\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 0],\n",
+    "             label='True Evaluation',\n",
+    "             c='green',\n",
+    "             yerr=failure_sems[:, 0])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 1],\n",
+    "             label='Labeled outcomes',\n",
+    "             c='magenta',\n",
+    "             yerr=failure_sems[:, 1])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 2],\n",
+    "             label='Human evaluation',\n",
+    "             c='red',\n",
+    "             yerr=failure_sems[:, 2])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 3],\n",
+    "             label='Contraction',\n",
+    "             c='blue',\n",
+    "             yerr=failure_sems[:, 3])\n",
+    "plt.errorbar(x_ax,\n",
+    "             failure_rates[:, 4],\n",
+    "             label='Monte Carlo',\n",
+    "             c='black',\n",
+    "             yerr=failure_sems[:, 4])\n",
+    "\n",
+    "plt.title('Failure rate vs. Acceptance rate without Z (modular)')\n",
+    "plt.xlabel('Acceptance rate')\n",
+    "plt.ylabel('Failure rate')\n",
+    "plt.legend()\n",
+    "plt.grid()\n",
+    "plt.show()\n",
+    "\n",
+    "print(failure_rates)\n",
+    "print(\"\\nMean absolute errors:\")\n",
+    "for i in range(1, failure_rates.shape[1]):\n",
+    "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
    ]
   },
   {
@@ -823,7 +934,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 216,
    "metadata": {
     "scrolled": false
    },
@@ -832,44 +943,39 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[1] 0 en loop\n"
+      "[1] 0 1 2 3 4 5 6 7 8 9 [2] 0 1 2 3 4 5 6 7 8 9 [3] 0 1 2 3 4 5 6 7 8 9 [4] 0 1 2 3 4 5 6 7 8 9 [5] 0 1 2 3 4 5 6 7 8 9 [6] 0 1 2 3 4 5 6 7 8 9 [7] 0 1 2 3 4 5 6 7 8 9 [8] 0 1 2 3 4 5 6 7 8 9 "
      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
-     ]
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "jlk loop\n",
-      "1 en loop\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/rikulain/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:78: RuntimeWarning: invalid value encountered in long_scalars\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-97-03cd8a3c6103>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m         f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n\u001b[0;32m---> 67\u001b[0;31m                                          'result_Y', r / 10)\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0mfailure_rates\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mr\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_rate_true\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m<ipython-input-96-4ef6c6b281a2>\u001b[0m in \u001b[0;36mcausalEvaluator\u001b[0;34m(df, featureX_col, decisionT_col, resultY_col, r)\u001b[0m\n\u001b[1;32m     90\u001b[0m     \u001b[0mtest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0massign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB_prob_0_model\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpredictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m     \u001b[0mreleased\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcdf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfeatureX_col\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB_model\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     94\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mB_prob_0_model\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mreleased\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m<ipython-input-94-f0303c92af6c>\u001b[0m in \u001b[0;36mcdf\u001b[0;34m(x_0, model, class_value)\u001b[0m\n\u001b[1;32m    123\u001b[0m         \u001b[0my_copy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx_preds\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mprediction_x_0\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 125\u001b[0;31m         \u001b[0mresults\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_copy\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx_values\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    126\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"jlk loop\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36msimps\u001b[0;34m(y, x, dx, axis, even)\u001b[0m\n\u001b[1;32m    477\u001b[0m                 \u001b[0mfirst_dx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    478\u001b[0m             \u001b[0mval\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfirst_dx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 479\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0m_basic_simps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    480\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0meven\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'avg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    481\u001b[0m             \u001b[0mval\u001b[0m \u001b[0;34m/=\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/scipy/integrate/quadrature.py\u001b[0m in \u001b[0;36m_basic_simps\u001b[0;34m(y, start, stop, x, dx, axis)\u001b[0m\n\u001b[1;32m    358\u001b[0m         \u001b[0mh0divh1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mh0\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mh1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    359\u001b[0m         tmp = hsum/6.0 * (y[slice0]*(2-1.0/h0divh1) +\n\u001b[0;32m--> 360\u001b[0;31m                           \u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mslice1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mhsum\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mhprod\u001b[0m \u001b[0;34m+\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    361\u001b[0m                           y[slice2]*(2-h0divh1))\n\u001b[1;32m    362\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+      "[[0.019332   0.007024   0.01164503 0.02060147 0.0186    ]\n",
+      " [0.049196   0.01716    0.02757158 0.04587469 0.048304  ]\n",
+      " [0.0849     0.029032   0.05524133 0.0797729  0.083684  ]\n",
+      " [0.12758    0.04208    0.09012099 0.1207086  0.127128  ]\n",
+      " [0.175592   0.055572   0.14012835 0.17227871 0.173824  ]\n",
+      " [0.22782    0.076412   0.19436587 0.22492832 0.227844  ]\n",
+      " [0.285572   0.09602    0.25768682 0.28237595 0.286128  ]\n",
+      " [0.349356   0.107448   0.32420604 0.34169562 0.354052  ]]\n",
+      "\n",
+      "Mean absolute errors:\n",
+      "0.111075\n",
+      "0.02729774880878927\n",
+      "0.004206334614321109\n",
+      "0.0012920000000000015\n"
      ]
     }
    ],
@@ -877,7 +983,7 @@
     "failure_rates = np.zeros((8, 5))\n",
     "failure_sems = np.zeros((8, 5))\n",
     "\n",
-    "nIter = 8\n",
+    "nIter = 10\n",
     "\n",
     "for r in np.arange(1, 9):\n",
     "\n",
@@ -897,7 +1003,7 @@
     "        df = coinFlipDGWithUnobservables()\n",
     "\n",
     "        # Decider\n",
-    "        df_labeled = coinFlipDecider(df,\n",
+    "        df_labeled = quantileDecider(df,\n",
     "                                     featureX_col=\"X\",\n",
     "                                     featureZ_col=\"Z\",\n",
     "                                     nJudges_M=100,\n",
@@ -905,7 +1011,7 @@
     "                                     beta_Z=1,\n",
     "                                     hide_unobserved=True)\n",
     "\n",
-    "        df_unlabeled = coinFlipDecider(df,\n",
+    "        df_unlabeled = quantileDecider(df,\n",
     "                                       featureX_col=\"X\",\n",
     "                                       featureZ_col=\"Z\",\n",
     "                                       nJudges_M=100,\n",
@@ -939,8 +1045,12 @@
     "\n",
     "        # Causal model - empirical performance\n",
     "\n",
-    "        f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
-    "                                         'result_Y', r / 10)\n",
+    "        #f_rate_caus[i] = causalEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "        #                                 'result_Y', r / 10)\n",
+    "\n",
+    "        f_rate_caus[i] = monteCarloEvaluator(df_labeled, 'X', 'decision_T',\n",
+    "                                             'result_Y', 'acceptanceRate_R',\n",
+    "                                             r / 10, N_sim=int(1e5))\n",
     "\n",
     "    failure_rates[r - 1, 0] = np.mean(f_rate_true)\n",
     "    failure_rates[r - 1, 1] = np.mean(f_rate_label)\n",
@@ -973,16 +1083,16 @@
     "             yerr=failure_sems[:, 2])\n",
     "plt.errorbar(x_ax,\n",
     "             failure_rates[:, 3],\n",
-    "             label='Contraction, log.',\n",
+    "             label='Contraction',\n",
     "             c='blue',\n",
     "             yerr=failure_sems[:, 3])\n",
     "plt.errorbar(x_ax,\n",
     "             failure_rates[:, 4],\n",
-    "             label='Causal model, ep',\n",
+    "             label='Monte Carlo',\n",
     "             c='black',\n",
     "             yerr=failure_sems[:, 4])\n",
     "\n",
-    "plt.title('Failure rate vs. Acceptance rate with unobservables')\n",
+    "plt.title('Failure rate vs. Acceptance rate with Z (modular)')\n",
     "plt.xlabel('Acceptance rate')\n",
     "plt.ylabel('Failure rate')\n",
     "plt.legend()\n",
@@ -995,75 +1105,101 @@
     "    print(np.mean(np.abs(failure_rates[:, 0] - failure_rates[:, i])))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bayesian sampling"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {
-    "scrolled": true
+    "scrolled": false
    },
    "outputs": [],
    "source": [
-    "import pystan\n",
-    "\n",
-    "code = \"\"\"\n",
-    "functions{\n",
-    "  // below taken from https://discourse.mc-stan.org/t/quantile-function-in-stan/3642/13\n",
-    "  // as Stan doesn't have a quantile function nor supports real-to-int conversion.\n",
-    "  int ub(real x) {\n",
-    "    int ub = 1;\n",
-    "    while (ub < x) ub *= 2;\n",
-    "    return ub;\n",
-    "  }\n",
-    "\n",
-    "  int closest(real x, int a, int b) {\n",
-    "    return fabs(x - a) < fabs(x - b) ? a : b;\n",
-    "  }\n",
-    "\n",
-    "  // L <= x <= U\n",
-    "  int to_int_bsearch(real x, int L, int U);\n",
-    "\n",
-    "  int to_int_bsearch(real x, int L, int U) {\n",
-    "    int mid = (L + U) / 2;\n",
-    "    if (L == U) return L;\n",
-    "    if (L + 1 == U) return closest(x, L, U);\n",
-    "    return x <= mid? to_int_bsearch(x, L, mid) : to_int_bsearch(x, mid, U);\n",
-    "  }\n",
-    "\n",
-    "  int to_int(real x);\n",
-    "\n",
-    "  int to_int(real x) {\n",
-    "    if (fabs(x) >= 2^31) reject(\"to_int arugment must be < 2^31, found x = \", x);\n",
-    "    if (x < 0) return -to_int(-x);\n",
-    "    return to_int_bsearch(x, 0, ub(x));\n",
-    "  }\n",
-    "}\n",
-    "\n",
-    "data {\n",
-    "  int<lower=0> N;\n",
-    "  int<lower=0> N_quantiles;\n",
-    "  real<lower=0, upper=1> r;\n",
-    "  int<lower=0, upper=1> decision[N];\n",
-    "  real X[N];\n",
-    "  real<lower=0, upper=1> quantiles[N_quantiles];\n",
-    "}\n",
-    "\n",
-    "parameters {\n",
-    "  real Z[N];\n",
-    "}\n",
-    "\n",
-    "model {\n",
-    "  Z ~ normal(0, 1);\n",
+    "# import pystan\n",
+    "\n",
+    "# code = \"\"\"\n",
+    "# functions{\n",
+    "#   // below taken from https://discourse.mc-stan.org/t/quantile-function-in-stan/3642/13\n",
+    "#   // as Stan doesn't have a quantile function nor supports real-to-int conversion.\n",
+    "#   int ub(real x) {\n",
+    "#     int ub = 1;\n",
+    "#     while (ub < x) ub *= 2;\n",
+    "#     return ub;\n",
+    "#   }\n",
+    "\n",
+    "#   int closest(real x, int a, int b) {\n",
+    "#     return fabs(x - a) < fabs(x - b) ? a : b;\n",
+    "#   }\n",
+    "\n",
+    "#   // L <= x <= U\n",
+    "#   int to_int_bsearch(real x, int L, int U);\n",
+    "\n",
+    "#   int to_int_bsearch(real x, int L, int U) {\n",
+    "#     int mid = (L + U) / 2;\n",
+    "#     if (L == U) return L;\n",
+    "#     if (L + 1 == U) return closest(x, L, U);\n",
+    "#     return x <= mid? to_int_bsearch(x, L, mid) : to_int_bsearch(x, mid, U);\n",
+    "#   }\n",
+    "\n",
+    "#   int to_int(real x);\n",
+    "\n",
+    "#   int to_int(real x) {\n",
+    "#     if (fabs(x) >= 2^31) reject(\"to_int arugment must be < 2^31, found x = \", x);\n",
+    "#     if (x < 0) return -to_int(-x);\n",
+    "#     return to_int_bsearch(x, 0, ub(x));\n",
+    "#   }\n",
+    "# }\n",
+    "\n",
+    "# data {\n",
+    "#   int<lower=0> N;\n",
+    "#   int<lower=0> N_quantiles;\n",
+    "#   real<lower=0, upper=1> r[N];\n",
+    "#   int<lower=0, upper=1> decision[N];\n",
+    "#   real X[N];\n",
+    "#   real<lower=0, upper=1> quantiles[N_quantiles];\n",
+    "# }\n",
+    "\n",
+    "# parameters {\n",
+    "#   real Z[N];\n",
+    "#   real<lower=0, upper=1> p;\n",
+    "# }\n",
+    "\n",
+    "# model {\n",
+    "#   Z ~ normal(0, 1);\n",
     "  \n",
-    "  for(i in 1:N){\n",
-    "    decision ~ bernoulli(inv_logit(X[i] + Z[i]) >= quantiles[to_int(r*N_quantiles)] ? 1 : 0);\n",
-    "  }\n",
-    "}\n",
-    "\"\"\"\n",
-    "\n",
-    "dat = dict()\n",
-    "\n",
-    "sm = pystan.StanModel(model_code=code)\n",
-    "fit = sm.sampling(data=dat, iter=4000, chains=4)"
+    "#   for(i in 1:N){\n",
+    "#     if (inv_logit(X[i] + Z[i]) <= quantiles[to_int(r[i]*N_quantiles)])\n",
+    "#       decision ~ bernoulli(p);\n",
+    "#     else\n",
+    "#       decision ~ bernoulli(1-p);\n",
+    "#   }\n",
+    "# }\n",
+    "# \"\"\"\n",
+    "# # Create data\n",
+    "# df = coinFlipDGWithUnobservables(N_total=500)\n",
+    "\n",
+    "# # Decider\n",
+    "# df = quantileDecider(df, featureX_col=\"X\", featureZ_col=\"Z\", nJudges_M=10,\n",
+    "#                              beta_X=1, beta_Z=1, hide_unobserved=True)\n",
+    "\n",
+    "# N_sim = int(1e8)\n",
+    "\n",
+    "# quants = inv_logit(npr.normal(size=N_sim) + npr.normal(size=N_sim))\n",
+    "\n",
+    "# dat = dict(N = df.shape[0],\n",
+    "#            N_quantiles = 100001,\n",
+    "#            r = df.acceptanceRate_R,\n",
+    "#            decision = df.decision_T,\n",
+    "#            X = df.X,\n",
+    "#            quantiles = np.quantile(quants, np.linspace(0, 1, 100001)))\n",
+    "\n",
+    "# sm = pystan.StanModel(model_code=code)\n",
+    "# fit = sm.sampling(data=dat, iter=4000, chains=4)"
    ]
   }
  ],
diff --git a/analysis_and_scripts/notes.tex b/analysis_and_scripts/notes.tex
index 3721511329f047e294ac8c4a992f45a34e8972b5..96667c968e2dd65a9805c2d682c8123362bd6413 100644
--- a/analysis_and_scripts/notes.tex
+++ b/analysis_and_scripts/notes.tex
@@ -1,8 +1,8 @@
 \documentclass[11pt,a4paper]{amsart}
-\usepackage{geometry}                % See geometry.pdf to learn the layout options. There are lots.
+\usepackage[margin=1in]{geometry}                % See geometry.pdf to learn the layout options. There are lots.
 %\geometry{a4paper}                   % ... or letterpaper or a5paper or ... 
 %\geometry{landscape}                % Activate for for rotated page geometry 
-\usepackage[parfill]{parskip}    % Activate to begin paragraphs with an empty line rather than an indent
+%\usepackage[parfill]{parskip}    % Activate to begin paragraphs with an empty line rather than an indent
 \usepackage{graphicx}
 \usepackage{amssymb}
 \usepackage{epstopdf}
@@ -249,29 +249,28 @@ Given the above framework, the goal is to create an evaluation algorithm that ca
 \end{wrapfigure}
 
 \emph{Below is the framework as was written on the whiteboard, then RL presents his own remarks on how he understood this.}
-
+~ \\
 \begin{description}
 
-\item[Data generation:] ~ \\ 
+\item[Data generation:] 
 	~ \\
-	\hskip 3em \textbf{Input:} [none] \\ ~ \\
-			 \textbf{Output:} $X, Z, W, Y$ as specified by $\M$
+	\hskip 3em \textbf{Input:} [none] \\ 
+			 \textbf{Output:} $X, Z, W, Y$ as specified by $\M$~ \\ 
 
-\item[Decider:] single vs. batch \\ 
+\item[Decider:] single vs. batch 
 	~ \\
 	\hskip 3em \textbf{Input:}  
 		\begin{itemize}  
 			\item one defendant 
 			\item $\M$ 
 		\end{itemize} 
-	
 	\textbf{Output:} 
 		\begin{itemize}  
 			\item argmax likelihood  $y$ 
 			\item $\pr(Y=0~|~input)$
-			\item order
+			\item order \\
 		\end{itemize} 
-\item[Evaluator:] ~ \\ 
+\item[Evaluator:] 
 	~ \\
 	\hskip 3em \textbf{Input:} 
 		\begin{itemize}  
@@ -638,17 +637,59 @@ Given our framework defined in section \ref{sec:framework}, the results presente
     \label{fig:random_predictions}
 \end{figure}
 
+\subsection{Modular framework -- Monte Carlo evaluator} \label{sec:modules_mc}
+
+For these results, data was generated with module in algorithm \ref{alg:dg:coinflip_with_z} ("coin-flip results") and decisions were assigned using module in algorithm \ref{alg:decider:quantile}. Curves were computed with algorithms \ref{alg:eval:true_eval}, \ref{alg:eval:labeled_outcomes}, \ref{alg:eval:human_eval}, \ref{alg:eval:contraction} and \ref{alg:eval:mc} are presented in figure \ref{fig:modules_mc}. The corresponding MAEs are presented in table \ref{tab:modules_mc}.
+
+\begin{table}[H]
+\centering
+\caption{Mean absolute error (MAE) w.r.t true evaluation. See modules used in section \ref{sec:modules_mc}}
+\begin{tabular}{l | c c}
+Method & MAE with Z \\ \hline
+Labeled outcomes 	& 0.111075\\
+Human evaluation 	& 0.027298\\
+Contraction 		& 0.004206\\
+Monte Carlo	 	& 0.001292\\
+\end{tabular}
+\label{tab:modules_mc}
+\end{table}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.75\textwidth]{sl_with_Z_10iter_coinflip_quantile_defaults_mc}
+    \caption{Failure rate vs. acceptance rate with varying levels of leniency. Data was generated with unobservables. See modules used in section \ref{sec:modules_mc}}
+    \label{fig:modules_mc}
+\end{figure}
+
+%\begin{figure}[H]
+%    \centering
+%    \begin{subfigure}[b]{0.475\textwidth}
+%        \includegraphics[width=\textwidth]{sl_without_Z_10iter_coinflip_quantile_defaults_mc}
+%        \caption{Data without unobservables. PLACEHOLDER}
+%        \label{fig:modules_mc_without_Z}
+%    \end{subfigure}
+%    \quad %add desired spacing between images, e. g. ~, \quad, \qquad, \hfill etc. 
+%      %(or a blank line to force the subfigure onto a new line)
+%    \begin{subfigure}[b]{0.475\textwidth}
+%        \includegraphics[width=\textwidth]{sl_with_Z_10iter_coinflip_quantile_defaults_mc}
+%        \caption{Data with unobservables.}
+%        \label{fig:modules_mc_with_Z}
+%    \end{subfigure}
+%    \caption{Failure rate vs. acceptance rate with varying levels of leniency. See modules used in section \ref{sec:modules_mc}}
+%    \label{fig:modules_mc}
+%\end{figure}z
+
 \section{Modules}
 
 Different types of modules are presented in this section. Summary table is presented last.
 
-\subsection{Data generation modules}
-
-Data generation modules usually take only some generative parameters as input.
+\begin{itemize}
+\item Data generation modules usually take only some generative parameters as input.
+\end{itemize}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "coin-flip results" without unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:coinflip_without_z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total}$
 \ENSURE
@@ -662,9 +703,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithm}
 
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "results by threshold" with unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:threshold_with_Z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
 \ENSURE
@@ -677,9 +718,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Data generation module: "coin-flip results" with unobservables} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:dg:coinflip_with_z} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Parameters: Total number of subjects $N_{total},~\beta_X=1,~\beta_Z=1$ and $\beta_W=0.2$.
 \ENSURE
@@ -692,17 +733,15 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Decider modules}
-
 %For decider modules, input as terms of knowledge and parameters should be as explicitly specified as possible.
 
-\begin{algorithm}[H] 			% enter the algorithm environment
-\caption{Decider module: human judge as specified by Lakkaraju et al.} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: human judge as specified by Lakkaraju et al. \cite{lakkaraju17}} 		% give the algorithm a caption
+\label{alg:decider:human} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $M=100, \beta_X=1, \beta_Z=1$.
 \ENSURE
-\STATE Sample acceptance rates for each M judges from $U(0.1; 0.9)$ and round to tenth decimal place.
+\STATE Sample acceptance rates for each M judges from Uniform$(0.1; 0.9)$ and round to tenth decimal place.
 \STATE Assign each observation to a judge at random.
 \STATE Calculate $P(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ) + \epsilon$ for each observation and attach to data.
 \STATE Sort the data by (1) the judges' and (2) by probabilities $P(T=0|X, Z)$ in descending order. 
@@ -713,9 +752,9 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
-\caption{Decider module: "coin-flip decisions"} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: "coin-flip decisions" (pseudo-leniencies set at 0.5)} 		% give the algorithm a caption
+\label{alg:decider:coinflip} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $\beta_X=1, \beta_Z=1$.
 \ENSURE
@@ -728,11 +767,33 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Evaluator modules}
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Decider module: "quantile decisions"} 		% give the algorithm a caption
+\label{alg:decider:quantile} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data with features $X, Z$ of size $N_{total}$, knowledge that both of them affect the outcome Y and that they are independent / Parameters: $\beta_X=1, \beta_Z=1$.
+\ENSURE
+\STATE Sample acceptance rates for each M judges from Uniform$(0.1; 0.9)$ and round to tenth decimal place.
+\STATE Assign each observation to a judge at random.
+\STATE Calculate $\pr(T=0|X, Z) = \sigma(\beta_XX+\beta_ZZ)$ for each observation and attach to data.
+\FORALL{$i$ in $1, \ldots, N_{total}$}
+	\IF{$\sigma(\beta_XX+\beta_ZZ) \geq F^{-1}_{\pr(T=0|X, Z)}(r)$ \footnotemark} % Footnote text below algorithm
+		\STATE {set $t_i=0$} 
+	\ELSE 
+		\STATE{set $t_i=1$} 
+	\ENDIF
+	\STATE Attach to data.
+\ENDFOR 
+\STATE Set $Y=$ NA if decision is negative ($T=0$). \emph{Might not be performed.}
+\RETURN data with decisions.
+\end{algorithmic}
+\end{algorithm}
+
+\footnotetext{The inverse cumulative distribution function (or quantile function) $F^{-1}$ was constructed by first sampling $10^7$ observations from $N(0, 2)$ (sum of two Gaussians) and applying the inverse of logit function $\sigma(x)$. The value of $F^{-1}(r)$ was computed utilizing the previously computed array and numpy's \texttt{quantile} function.}
 
-\begin{algorithm}[H] 			% enter the algorithm environment
+\begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Contraction algorithm \cite{lakkaraju17}} 		% give the algorithm a caption
-%\label{alg:} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:contraction} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -742,16 +803,12 @@ Data generation modules usually take only some generative parameters as input.
 \STATE Let $q$ be the decision-maker with highest acceptance rate in $\D$.
 \STATE $\D_q = \{(x, j, t, y) \in \D|j=q\}$
 \STATE \hskip3.0em $\rhd$ $\D_q$ is the set of all observations judged by $q$
-\STATE
 \STATE $\RR_q = \{(x, j, t, y) \in \D_q|t=1\}$
 \STATE \hskip3.0em $\rhd$ $\RR_q$ is the set of observations in $\D_q$ with observed outcome labels
-\STATE
 \STATE Sort observations in $\RR_q$ in descending order of confidence scores $\s$ and assign to $\RR_q^{sort}$.
 \STATE \hskip3.0em $\rhd$ Observations deemed as high risk by the black-box model $\mathcal{B}$ are at the top of this list
-\STATE
 \STATE Remove the top $[(1.0-r)|\D_q |]-[|\D_q |-|\RR_q |]$ observations of $\RR_q^{sort}$ and call this list $\mathcal{R_B}$
 \STATE \hskip3.0em $\rhd$ $\mathcal{R_B}$ is the list of observations assigned to $t = 1$ by $\mathcal{B}$
-\STATE
 \STATE Compute $\mathbf{u}=\sum_{i=1}^{|\mathcal{R_B}|} \dfrac{\delta\{y_i=0\}}{| \D_q |}$.
 \RETURN $\mathbf{u}$
 \end{algorithmic}
@@ -759,7 +816,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: True evaluation} 		% give the algorithm a caption
-%\label{alg:true_eval} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:true_eval} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$ and \emph{all outcome labels}, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -775,7 +832,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Labeled outcomes} 		% give the algorithm a caption
-%\label{alg:labeled_outcomes} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:labeled_outcomes} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r, knowledge that X affects Y
 \ENSURE
@@ -792,7 +849,7 @@ Data generation modules usually take only some generative parameters as input.
 
 \begin{algorithm}[] 			% enter the algorithm environment
 \caption{Evaluator module: Human evaluation} 		% give the algorithm a caption
-%\label{alg:human_eval} 			% and a label for \ref{} commands later in the document
+\label{alg:eval:human_eval} 			% and a label for \ref{} commands later in the document
 \begin{algorithmic}[1] 		% enter the algorithmic environment
 \REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r
 \ENSURE
@@ -804,25 +861,72 @@ Data generation modules usually take only some generative parameters as input.
 \end{algorithmic}
 \end{algorithm}
 
-\subsection{Summary}
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Evaluator module: Causal evaluator (?)} 		% give the algorithm a caption
+\label{alg:eval:causal_eval} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data $\D$ with properties $\{x_i, t_i, y_i\}$, acceptance rate r
+\ENSURE
+\STATE Split data to test set and training set.
+\STATE Train a predictive model $\B$ on training data.
+\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
+\FORALL{$i$ in $1, \ldots, N_{total}$}
+	\STATE Evaluate $F(x_i) = \int_{x\in\mathcal{X}} P_X(x)\delta(f(x)<f(x_i)) ~dx$ and assign to $\mathcal{F}_{predictions}$ 
+\ENDFOR
+\STATE Create boolean array $T_{causal} = \mathcal{F}_{predictions} < r$.
+\RETURN $\frac{1}{|\D_{test}|}\sum_{i=1}^{|\D_{test}|} \s_i \cdot T_{i, causal}$ which is equal to $\frac{1}{|\D|}\sum_{x\in\D} f(x)\delta(F(x) < r)$
+\end{algorithmic}
+\end{algorithm}
 
-\begin{table}[H]
+\begin{algorithm}[] 			% enter the algorithm environment
+\caption{Evaluator module: Monte Carlo evaluator, imputation} 		% give the algorithm a caption
+\label{alg:eval:mc} 			% and a label for \ref{} commands later in the document
+\begin{algorithmic}[1] 		% enter the algorithmic environment
+\REQUIRE Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$, acceptance rate r
+\ENSURE
+\STATE Split data to test set and training set.
+\STATE Train a predictive model $\B$ on training data.
+\STATE Estimate probability scores $\s$ using $\B$ for all observations in test data and attach to test data.
+\STATE Sample $N_{sim}$ observations from a standard Gaussian and assign to Z.
+\STATE Sample $N_{sim}$ observations from sum of two standard Gaussians (N(0, 2)) and assign to \texttt{quants}.
+\STATE Transform the values of the samples in \texttt{quants} using the inverse of logit function.
+\STATE Compute the values of the inverse cdf of the observations in \texttt{quants} for the acceptance rates r of each judge and assign to $Q_r$.
+\FORALL{$i$ in $1, \ldots, N_{test}$}
+	\IF{$t_i = 0$}
+		\STATE {Take all $Z > logit(Q_{r,i})-x_i$ \footnotemark} 
+	\ELSE 
+		\STATE{Take all $Z < logit(Q_{r,i})-x_i$}
+	\ENDIF
+	\STATE Draw predictions $\hat{p}_{i,y}$ from Bernoulli($1-logit^{-1}(x_i+\bar{Z})$).
+\ENDFOR
+\STATE Impute missing observations using $\hat{p}_y$.
+\STATE Sort the data by the probabilities $\s$ to ascending order.
+\STATE \hskip3.0em $\rhd$ Now the most dangerous subjects are last.
+\STATE Calculate the number to release $N_{free} = |\D_{test}| \cdot r$.
+\RETURN Compute $\frac{1}{|\D_{test}|}\sum_{i=1}^{N_{free}}\delta\{y_i=0\}$ using the observed and imputed observations.
+\end{algorithmic}
+\end{algorithm}
+
+\footnotetext{$logit^{-1}(x+z)>a \Leftrightarrow x+z > logit(a) \Leftrightarrow z > logit(a)-x$}
+
+\begin{table}[h!]
   \centering
+  \caption{Summary of modules (under construction)}
   \begin{tabular}{lll}
     \toprule
     \multicolumn{3}{c}{Module type} \\[.5\normalbaselineskip]
     \textbf{Data generator} & \textbf{Decider} & \textbf{Evaluator}  \\
     \midrule
-    Without unobservables			& Independent decisions	& {\ul Labeled outcomes} \\
-     					 		& \tabitem $P(T=0|X, Z)$	& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
-    With unobservables        		& \tabitem "threshold rule"	& \tabitem acceptance rate r \\
-    \tabitem $P(Y=0|X, Z, W)$ 		& 					& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+    {\ul Without unobservables}		& Independent decisions		& {\ul Labeled outcomes} \\
+     					 		& 1. flip a coin by 			& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+    {\ul With unobservables}       		& $P(T=0|X, Z)$			& \tabitem acceptance rate r \\
+    \tabitem $P(Y=0|X, Z, W)$ 		& 2. determine with $F^{-1}(r)$	& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
     
-     With unobservables 		&   & {\ul True evaluation} \\
-     \tabitem "threshold rule"	&   & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
-     						&   & and \emph{all outcome labels} \\
-     						&   & \tabitem acceptance rate r \\
-     						&   & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+     {\ul With unobservables}	& Non-independent decisions  	& {\ul True evaluation} \\
+     \tabitem assign Y by		& 3. sort by $P(T=0|X, Z)$		& \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
+     "threshold rule"			& and assign $t$ by $r$  		& and \emph{all outcome labels} \\
+     						&   						& \tabitem acceptance rate r \\
+     						&   						& \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
      
      &  & {\ul Human evaluation} \\
      &  & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
@@ -837,10 +941,14 @@ Data generation modules usually take only some generative parameters as input.
      &  & \tabitem Data $\D$ with properties $\{x_i, t_i, y_i\}$ \\
      &  & \tabitem acceptance rate r \\
      &  & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
+     
+     &  & {\ul Monte Carlo evaluator} \\
+     &  & \tabitem Data $\D$ with properties $\{x_i, j_i, t_i, y_i\}$ \\
+     &  & \tabitem acceptance rate r \\
+     &  & \tabitem knowledge that X affects Y \\[.5\normalbaselineskip]
     \bottomrule
   \end{tabular}
-  \caption{Summary table of modules (under construction)}
-  \label{tab:jotain}
+  \label{tab:modules}
 \end{table}
 
 \begin{thebibliography}{9}
diff --git a/figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png b/figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png
new file mode 100644
index 0000000000000000000000000000000000000000..33df95cc24abfecaa60fb0e241033f236d3dfa58
Binary files /dev/null and b/figures/sl_with_Z_10iter_coinflip_quantile_defaults_mc.png differ