From b2f1e95953f926962d3f9684b161e227f524d721 Mon Sep 17 00:00:00 2001
From: murraybj <129555910+murraybj@users.noreply.github.com>
Date: Sat, 30 Mar 2024 16:40:30 -0400
Subject: [PATCH 1/2] Added first LP_IP python notebook

---
 notebooks_py/1_LP_IP_python.ipynb | 687 ++++++++++++++++++++++++++++++
 1 file changed, 687 insertions(+)
 create mode 100644 notebooks_py/1_LP_IP_python.ipynb

diff --git a/notebooks_py/1_LP_IP_python.ipynb b/notebooks_py/1_LP_IP_python.ipynb
new file mode 100644
index 0000000..b2be9e7
--- /dev/null
+++ b/notebooks_py/1_LP_IP_python.ipynb
@@ -0,0 +1,687 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a name=\"top\" id=\"top\"></a>\n",
+    "\n",
+    "<div align=\"center\">\n",
+    "    <h1>Linear and Integer Programming</h1>\n",
+    "    <a href=\"https://github.com/bernalde\">David E. Bernal Neira</a>\n",
+    "    <br>\n",
+    "    <i>Davidson School of Chemical Engineering, Purdue University</i>\n",
+    "    <br>\n",
+    "    <i>Universities Space Research Association</i>\n",
+    "    <br>\n",
+    "    <i>NASA QuAIL</i>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <a href=\"https://github.com/pedromxavier\">Pedro Maciel Xavier</a>\n",
+    "    <br>\n",
+    "    <i>Davidson School of Chemical Engineering, Purdue University</i>\n",
+    "    <br>\n",
+    "    <i>Computer Science &amp; Systems Engineering Program, Federal University of Rio de Janeiro</i>\n",
+    "    <br>\n",
+    "    <i>PSR Energy Consulting &amp; Analytics</i>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <a href=\"https://github.com/murraybj\">Benjamin J. L. Murray</a>\n",
+    "    <br>\n",
+    "    <i>Davidson School of Chemical Engineering, Purdue University</i>\n",
+    "    <br>\n",
+    "    <i>Undergraduate Research Assistant</i>\n",
+    "    <br>\n",
+    "    <br>\n",
+    "    <a href=\"https://colab.research.google.com/github/pedromxavier/QUBO-notebooks/blob/main/notebooks/1-LP_IP.ipynb\" target=\"_parent\">\n",
+    "        <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
+    "    </a>\n",
+    "    <a href=\"#installation\">\n",
+    "        <img src=\"https://img.shields.io/badge/⚙️-Installation_Instructions-blue\" alt=\"Installation Instructions\"/>\n",
+    "    </a>\n",
+    "    <a href=\"https://bernalde.github.io/\">\n",
+    "        <img src=\"https://img.shields.io/badge/⚗️-Bernal_Lab-blue\" alt=\"Bernal Lab\"/>\n",
+    "    </a>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Introduction to Mathematical Programming\n",
+    "### Modeling\n",
+    "The solution of optimization problems requires the development of a mathematical model. Here we will model an example given in the lecture and see how an integer program can be solved practically. This example will use as modeling language **[Pyomo](http://www.pyomo.org/)**, an open-source Python package, which provides a flexible access to different solvers and a general modeling framework for linear and nonlinear integer programs.\n",
+    "The examples solved here will make use of open-source solvers **[GLPK](https://www.gnu.org/software/glpk/)** and **[CLP/CBC](https://projects.coin-or.org/Cbc)** for linear and mixed-integer linear programming, **[IPOPT](https://coin-or.github.io/Ipopt/)** for interior point (non)linear programming, **[BONMIN](https://www.coin-or.org/Bonmin/)** for convex integer nonlinear programming and **[COUENNE](https://projects.coin-or.org/Couenne)** for nonconvex (global) integer nonlinear programming."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# If using this on Google collab, we need to install the packages\n",
+    "try:\n",
+    "  import google.colab\n",
+    "  IN_COLAB = True\n",
+    "except:\n",
+    "  IN_COLAB = False\n",
+    "\n",
+    "# Let's start with Pyomo\n",
+    "if IN_COLAB:\n",
+    "    !pip install -q pyomo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import the Pyomo library, which can be installed via pip, conda or from Github https://github.com/Pyomo/pyomo\n",
+    "import pyomo.environ as pyo\n",
+    "# Import Matplotlib to generate plots\n",
+    "import matplotlib.pyplot as plt\n",
+    "# Import numpy and scipy for certain numerical calculations below\n",
+    "import numpy as np\n",
+    "from scipy.special import gamma\n",
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Problem statement\n",
+    "\n",
+    "Suppose there is a company that produces two different products, A and B, which can be sold at different values, $\\$5.5$ and $\\$2.1$ per unit, respectively.\n",
+    "The company only counts with a single machine with electricity usage of at most 17kW/day. Producing each A and B consumes $8\\text{kW}/\\text{day}$ and $2\\text{kW}/\\text{day}$, respectively.\n",
+    "Besides, the company can only produce at most $2$ more units of B than A per day."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Linear Programming\n",
+    "This is a valid model, but it would be easier to solve if we had a mathematical representation.\n",
+    "Assuming the units produced of A are $x_1$ and of B are $x_2$ we have\n",
+    "\n",
+    "$$\n",
+    "\\begin{array}{rl}\n",
+    "    \\displaystyle%\n",
+    "    \\max_{x_1, x_2} & 5.5x_1 + 2.1x_2 \\\\\n",
+    "    \\textrm{s.t.}   & x_2 \\le x_1 + 2 \\\\\n",
+    "                    & 8x_1 + 2x_2 \\le 17 \\\\\n",
+    "                    & x_1, x_2 \\ge 0\n",
+    "\\end{array}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate the feasible region plot of this problem\n",
+    "\n",
+    "# Define meshgrid for feasible region\n",
+    "d = np.linspace(-0.5,3.5,300)\n",
+    "x1,x2 = np.meshgrid(d,d)\n",
+    "\n",
+    "# Define the lines for the constraints\n",
+    "x = np.linspace(x1.min(), x1.max(), 2000)\n",
+    "# x2 <= x1 + 2\n",
+    "x21 = x + 2\n",
+    "# 8*x1 + 2*x2 <= 17\n",
+    "x22 = (17-8*x)/2.0\n",
+    "# obj: min 7.3x1 + 2.1x2\n",
+    "Z = 5.5*x1 + 2.1*x2\n",
+    "\n",
+    "# generate heatmap from objective function\n",
+    "objective_heatmap = np.fromfunction(lambda i, j:5.5 * i + 2.1 * j,(300,300), dtype=float)\n",
+    "\n",
+    "# Plot feasible region\n",
+    "fig, ax = plt.subplots()\n",
+    "feas_reg = ax.imshow( (\n",
+    "    (x1>=0) &           # Bound 1 \n",
+    "    (x2>=0) &           # Bound 2\n",
+    "    (x2 <= x1 + 2) &    # Constraint 1\n",
+    "    (8*x1 + 2*x2 <= 17) # Constraint 2\n",
+    "    ).astype(int) \n",
+    "    * objective_heatmap, # objective function\n",
+    "                extent=(x1.min(),x1.max(),x2.min(),x2.max()),origin=\"lower\", cmap=\"OrRd\", alpha = 1)\n",
+    "\n",
+    "# Make plots of constraints\n",
+    "ax.plot(x, x21, label=r'$x_2 \\leq x_1 + 2$')\n",
+    "ax.plot(x, x22, label=r'$8x_1 + 2x_2 \\leq 17$')\n",
+    "\n",
+    "# Nonnegativitivy constraints\n",
+    "plt.plot(x, np.zeros_like(x), label=r'$x_2 \\geq 0$')\n",
+    "plt.plot(np.zeros_like(x), x, label=r'$x_1 \\geq 0$')\n",
+    "\n",
+    "# Optimal solution LP\n",
+    "ax.scatter(1.3,3.3,color='r', label='optimal solution LP')\n",
+    "\n",
+    "# plot formatting\n",
+    "plt.title(\"LP Feasible Region \\n max $z = 5.5x_{1} + 2.1x_{2}$\",fontsize=10,y=1)\n",
+    "plt.xlim(x1.min(),x1.max())\n",
+    "plt.ylim(x2.min(),x2.max())\n",
+    "plt.legend(loc='upper right', prop={'size': 6})\n",
+    "plt.xlabel(r'$x_1$')\n",
+    "plt.ylabel(r'$x_2$')\n",
+    "plt.grid(alpha=0.2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the model\n",
+    "model = pyo.ConcreteModel(name='Simple example LP, 47-779 QuIP')\n",
+    "# Define the variables\n",
+    "model.x = pyo.Var([1,2], domain=pyo.NonNegativeReals)\n",
+    "# Define the objective function\n",
+    "def _obj(m):\n",
+    "    return 5.5*m.x[1] + 2.1*m.x[2]\n",
+    "\n",
+    "model.obj = pyo.Objective(rule = _obj, sense=pyo.maximize)\n",
+    "# Define the constraints\n",
+    "def _constraint1(m):\n",
+    "    return m.x[2] <= m.x[1] + 2\n",
+    "\n",
+    "def _constraint2(m):\n",
+    "    return 8*m.x[1] + 2*m.x[2] <= 17\n",
+    "    \n",
+    "model.Constraint1 = pyo.Constraint(rule = _constraint1)\n",
+    "\n",
+    "model.Constraint2 = pyo.Constraint(rule = _constraint2)\n",
+    "# Print the model\n",
+    "model.pprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's install the LP/MIP solvers GLPK and CBC\n",
+    "if IN_COLAB:\n",
+    "    !apt-get install -y -qq glpk-utils\n",
+    "    !apt-get install -y -qq coinor-cbc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Define the solver GLPK\n",
+    "if IN_COLAB:\n",
+    "    opt_glpk = pyo.SolverFactory('glpk', executable='/usr/bin/glpsol')\n",
+    "    opt_cbc = pyo.SolverFactory('cbc', executable='/usr/bin/cbc')\n",
+    "else:\n",
+    "    opt_glpk = pyo.SolverFactory('glpk')\n",
+    "    opt_cbc = pyo.SolverFactory('cbc')\n",
+    "# Here we could use another solver, e.g. gurobi or cplex\n",
+    "# opt_gurobi = pyo.SolverFactory('gurobi')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here we solve the optimization problem, the option tee=True prints the solver output\n",
+    "result_obj = opt_glpk.solve(model, tee=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Display solution of the problem\n",
+    "model.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We observe that the optimal solution of this problem is $x_1 = 1.3$, $x_2 = 3.3$, leading to a profit of $14.08$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We obtain the same solution with CBC\n",
+    "result_obj = opt_cbc.solve(model, tee=False)\n",
+    "model.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The solvers GLPK and CLP implement the simplex method (with many improvements) by default but we can also use an interior point method thorugh the solver IPOPT (interior point optimizer). IPOPT is able to not only solve linear but also nonlinear problems."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the solver IPOPT\n",
+    "if IN_COLAB:\n",
+    "    !wget -N -q \"https://ampl.com/dl/open/ipopt/ipopt-linux64.zip\"\n",
+    "    !unzip -o -q ipopt-linux64\n",
+    "    opt_ipopt = pyo.SolverFactory('ipopt', executable='/content/ipopt')\n",
+    "else:\n",
+    "    opt_ipopt = pyo.SolverFactory('ipopt')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here we solve the optimization problem, the option tee=True prints the solver output\n",
+    "result_obj_ipopt = opt_ipopt.solve(model, tee=False)\n",
+    "model.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We obtain the same result as previously, but notice that the interior point method reports some solution subject to certain tolerance, given by its convergence properties when it can get infinitesimally close (but not directly at) the boundary of the feasible region."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's go back to the slides"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Integer Programming\n",
+    "Now let's consider that only integer units of each product can be produced, namely\n",
+    "$$\n",
+    "\\max_{x_1, x_2} 5.5x_1 + 2.1x_2 \\\\\n",
+    "s.t. x_2 \\leq x_1 + 2 \\\\\n",
+    "8x_1 + 2x_2 \\leq 17 \\\\\n",
+    "x_1, x_2 \\geq 0 \\\\\n",
+    "x_1, x_2 \\in \\mathbb{Z}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define grid for integer points\n",
+    "x1_int, x2_int = np.meshgrid(range(math.ceil(x1.max())), range(math.ceil(x2.max())))\n",
+    "idx = ((x1_int>=0) & (x2_int <= x1_int + 2) & (8*x1_int + 2*x2_int <= 17) & (x2_int>=0))\n",
+    "x1_int, x2_int = x1_int[idx], x2_int[idx]\n",
+    "ax.scatter(x1_int,x2_int,color='k', label='integer points')\n",
+    "\n",
+    "# Plotting optimal solution IP\n",
+    "# plt.title(\"LP Feasible Region \\n max $z = 5.5x_{1} + 2.1x_{2}$\",fontsize=10,y=1)\n",
+    "ax.set_title(\"ILP Feasible Region \\n max $z = 5.5x_{1} + 2.1x_{2}$\")\n",
+    "ax.scatter(1,3,color='c', label='optimal solution ILP')\n",
+    "ax.get_legend().remove()\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
+    "fig.canvas.draw()\n",
+    "fig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the integer model\n",
+    "model_ilp = pyo.ConcreteModel(name='Simple example IP, 47-779 QuIP')\n",
+    "#Define the variables\n",
+    "model_ilp.x = pyo.Var([1,2], domain=pyo.Integers)\n",
+    "# Define the objective function\n",
+    "model_ilp.obj = pyo.Objective(rule = _obj, sense=pyo.maximize)\n",
+    "# Define the constraints\n",
+    "model_ilp.Constraint1 = pyo.Constraint(rule = _constraint1)\n",
+    "\n",
+    "model_ilp.Constraint2 = pyo.Constraint(rule = _constraint2)\n",
+    "# Print the model\n",
+    "model_ilp.pprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here we solve the optimization problem, the option tee=True prints the solver output\n",
+    "result_obj_ilp = opt_cbc.solve(model_ilp, tee=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_ilp.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here the solution becomes $x_1 = 1, x_2 = 3$ with an objective of $11.8$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's go back to the slides"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Enumeration\n",
+    "Enumerating all the possible solutions in this problem might be very efficient (there are only 8 feasible solutions), this this we only know from the plot. Assuming that we had as upper bounds for the variables 4, the possible solutions would be 16. With a larger number of variables the enumeration turns to be impractical. For $n$ binary variables (wee can always \"binarize\" the integer variables) the number of possible solutions is $2^n$.\n",
+    "\n",
+    "In many other applications, the possible solutions come from permutations of the integer variables (e.g. assignment problems), which grow as $n!$ with the size of the input.\n",
+    "\n",
+    "This growth makes the problem grow out of control fairly quickly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig2, ax2 = plt.subplots()\n",
+    "n = np.arange(1,100,1)\n",
+    "ax2.plot(n,np.exp(n*np.log(2)), label=r'$2^n$')\n",
+    "ax2.plot(n,gamma(n), label=r'$n!$')\n",
+    "\n",
+    "ax2.plot(n,3.154E16*np.ones_like(n), 'g--', label=r'ns in a year')\n",
+    "ax2.plot(n,4.3E26*np.ones_like(n), 'k--', label=r'age of the universe in ns')\n",
+    "ax2.plot(n,6E79*np.ones_like(n), 'r--', label=r'atoms in the universe')\n",
+    "plt.yscale('log')\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.xlabel(r'$n$')\n",
+    "plt.ylabel('Possible solutions')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's go back to the slides"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Integer convex nonlinear programming\n",
+    "The following constraint \"the production of B minus 1 squared can only be smaller than 2 minus the production of A\" can be incorporated  in the following convex integer nonlinear program\n",
+    "$$\n",
+    "\\max_{x_1, x_2} 5.5x_1 + 2.1x_2 \\\\\n",
+    "s.t. x_2 \\leq x_1 + 2 \\\\\n",
+    "8x_1 + 2x_2 \\leq 17 \\\\\n",
+    "(x_2-1)^2 \\leq 2-x_1\\\\\n",
+    "x_1, x_2 \\geq 0 \\\\\n",
+    "x_1, x_2 \\in \\mathbb{Z}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define grid for integer points\n",
+    "feas_reg.remove()\n",
+    "feas_reg = ax.imshow( (\n",
+    "    (x1>=0) &           # Bound 1 \n",
+    "    (x2>=0) &           # Bound 2\n",
+    "    (x2 <= x1 + 2) &    # Constraint 1\n",
+    "    (8*x1 + 2*x2 <= 17) & # Constraint 2\n",
+    "    ((x2-1)**2 <= 2-x1) & # Nonlinear constraint\n",
+    "    ((x2-1)**2 >= x1+0.5) # Nonlinear constraint 2\n",
+    "    ).astype(int) \n",
+    "    * objective_heatmap, # objective function, \n",
+    "                extent=(x1.min(),x1.max(),x2.min(),x2.max()),origin=\"lower\", cmap=\"OrRd\", alpha = .8)\n",
+    "\n",
+    "\n",
+    "x1nl = 2- (x - 1)**2\n",
+    "# Nonlinear constraint\n",
+    "nl_const = ax.plot(x1nl, x, label=r'$(x_2-1)^2 \\leq 2-x_1$')\n",
+    "\n",
+    "# Plotting optimal solution INLP\n",
+    "ax.scatter(1,2,color='m', label='optimal solution convex INLP')\n",
+    "ax.set_title(\"INCLP Feasible Region \\n max $z = 5.5x_{1} + 2.1x_{2}$\")\n",
+    "ax.get_legend().remove()\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
+    "fig.canvas.draw()\n",
+    "fig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the solver BONMIN\n",
+    "if IN_COLAB:\n",
+    "    !wget -N -q \"https://ampl.com/dl/open/bonmin/bonmin-linux64.zip\"\n",
+    "    !unzip -o -q bonmin-linux64\n",
+    "    \n",
+    "opt_bonmin = pyo.SolverFactory('bonmin', executable='/content/bonmin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Here we solve the optimization problem, the option tee=True prints the solver output\n",
+    "result_obj_cinlp = opt_bonmin.solve(model_cinlp, tee=False)\n",
+    "model_cinlp.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this case the optimal solution becomes $x_1 = 1, x_2 = 2$ with an objective of $9.7$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Integer non-convex programming\n",
+    "The last constraint \"the production of B minus 1 squared can only be greater than the production of A plus one half\" can be incorporated  in the following convex integer nonlinear program\n",
+    "$$\n",
+    "\\max_{x_1, x_2} 5.5x_1 + 2.1x_2 \\\\\n",
+    "s.t. x_2 \\leq x_1 + 2 \\\\\n",
+    "8x_1 + 2x_2 \\leq 17 \\\\\n",
+    "(x_2-1)^2 \\leq 2-x_1\\\\\n",
+    "(x_2-1)^2 \\geq 1/2+x_1\\\\\n",
+    "x_1, x_2 \\geq 0 \\\\\n",
+    "x_1, x_2 \\in \\mathbb{Z}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define grid for integer points\n",
+    "feas_reg.remove()\n",
+    "feas_reg = ax.imshow( (\n",
+    "    (x1>=0) &           # Bound 1 \n",
+    "    (x2>=0) &           # Bound 2\n",
+    "    (x2 <= x1 + 2) &    # Constraint 1\n",
+    "    (8*x1 + 2*x2 <= 17) & # Constraint 2\n",
+    "    ((x2-1)**2 <= 2-x1) & # Nonlinear constraint 1\n",
+    "    ((x2-1)**2 >= x1+0.5) # Nonlinear constraint 2\n",
+    "    ).astype(int) \n",
+    "    * objective_heatmap,  # objective function,\n",
+    "                extent=(x1.min(),x1.max(),x2.min(),x2.max()),origin=\"lower\", cmap=\"OrRd\", alpha = .8)\n",
+    "\n",
+    "\n",
+    "x1nl = -1/2 + (x - 1)**2\n",
+    "# Nonlinear constraint\n",
+    "nl_const = ax.plot(x1nl, x, label=r'$(x_2-1)^2 \\geq x_1 + 1/2$')\n",
+    "\n",
+    "# Plotting optimal solution INLP\n",
+    "ax.scatter(0,2,color='g', label='optimal solution nonconvex INLP')\n",
+    "\n",
+    "ax.get_legend().remove()\n",
+    "ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
+    "fig.canvas.draw()\n",
+    "fig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the integer model\n",
+    "model_ncinlp = pyo.ConcreteModel(name='Simple example non-convex INP, 47-779 QuIP')\n",
+    "#Define the variables\n",
+    "model_ncinlp.x = pyo.Var([1,2], domain=pyo.Integers)\n",
+    "# Define the objective function\n",
+    "model_ncinlp.obj = pyo.Objective(rule = _obj, sense=pyo.maximize)\n",
+    "# Define the constraints\n",
+    "model_ncinlp.Constraint1 = pyo.Constraint(rule = _constraint1)\n",
+    "\n",
+    "model_ncinlp.Constraint2 = pyo.Constraint(rule = _constraint2)\n",
+    "\n",
+    "model_ncinlp.Constraint3 = pyo.Constraint(expr = (model_ncinlp.x[2]-1)**2 <= 2 - model_ncinlp.x[1])\n",
+    "\n",
+    "model_ncinlp.Constraint4 = pyo.Constraint(expr = (model_ncinlp.x[2]-1)**2 >= 1/2 + model_ncinlp.x[1])\n",
+    "\n",
+    "\n",
+    "# Print the model\n",
+    "model_ncinlp.pprint()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Trying to solve the problem with BONMIN we might obtain the optimal solution, but we have no guarantees\n",
+    "result_obj_ncinlp = opt_bonmin.solve(model_ncinlp, tee=False)\n",
+    "model_ncinlp.display()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the solver COUENNE\n",
+    "if IN_COLAB:\n",
+    "    !wget -N -q \"https://ampl.com/dl/open/couenne/couenne-linux64.zip\"\n",
+    "    !unzip -o -q couenne-linux64\n",
+    "    \n",
+    "opt_couenne = pyo.SolverFactory('couenne', executable='/content/couenne')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Trying to solve the problem with global MINLP solver COUENNE\n",
+    "result_obj_ncinlp = opt_couenne.solve(model_ncinlp, tee=False)\n",
+    "model_ncinlp.display()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We are able to solve non-convex MINLP problems but the complexity of this problems leads to great challenges that need to be overcomed."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Powerful commercial solver installation\n",
+    "\n",
+    "#### Gurobi Installation\n",
+    "Gurobi is one of the most powerful LP and MIP solvers available today. They provide free academic licences. In order to install the software visit their **[Website](https://www.gurobi.com/)**, create an account (preferably with your CMU email), and obtain a license. Once you do that you can download and use the software.\n",
+    "\n",
+    "#### BARON Installation\n",
+    "BARON is one of the most powerful MINLP solvers available today. CMU students are given a free license given the association of BARON's developer (Prof. Nick Sahinidis) to CMU. In order to install the software visit their **[Website](https://www.minlp.com/home)**, create an account (with your CMU email), and obtain a license. Once you do that you can download and use the software."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 79783bb369e3b07135303a42569514f5f8ba35a6 Mon Sep 17 00:00:00 2001
From: murraybj <129555910+murraybj@users.noreply.github.com>
Date: Sat, 30 Mar 2024 18:25:32 -0400
Subject: [PATCH 2/2] fixed issues with initializing models

---
 notebooks_py/1_LP_IP_python.ipynb | 148 ++++++++++++++++++++++--------
 1 file changed, 109 insertions(+), 39 deletions(-)

diff --git a/notebooks_py/1_LP_IP_python.ipynb b/notebooks_py/1_LP_IP_python.ipynb
index b2be9e7..06db50a 100644
--- a/notebooks_py/1_LP_IP_python.ipynb
+++ b/notebooks_py/1_LP_IP_python.ipynb
@@ -33,7 +33,7 @@
     "    <i>Undergraduate Research Assistant</i>\n",
     "    <br>\n",
     "    <br>\n",
-    "    <a href=\"https://colab.research.google.com/github/pedromxavier/QUBO-notebooks/blob/main/notebooks/1-LP_IP.ipynb\" target=\"_parent\">\n",
+    "    <a href=\"https://colab.research.google.com/github/SECQUOIA/QUBONotebooks/blob/main/notebooks_py/1_LP_IP_python.ipynb\" target=\"_parent\">\n",
     "        <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
     "    </a>\n",
     "    <a href=\"#installation\">\n",
@@ -57,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -75,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -121,9 +121,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Generate the feasible region plot of this problem\n",
     "\n",
@@ -177,9 +188,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1 Set Declarations\n",
+      "    x_index : Size=1, Index=None, Ordered=Insertion\n",
+      "        Key  : Dimen : Domain : Size : Members\n",
+      "        None :     1 :    Any :    2 : {1, 2}\n",
+      "\n",
+      "1 Var Declarations\n",
+      "    x : Size=2, Index=x_index\n",
+      "        Key : Lower : Value : Upper : Fixed : Stale : Domain\n",
+      "          1 :     0 :  None :  None : False :  True : NonNegativeReals\n",
+      "          2 :     0 :  None :  None : False :  True : NonNegativeReals\n",
+      "\n",
+      "1 Objective Declarations\n",
+      "    obj : Size=1, Index=None, Active=True\n",
+      "        Key  : Active : Sense    : Expression\n",
+      "        None :   True : maximize : 5.5*x[1] + 2.1*x[2]\n",
+      "\n",
+      "2 Constraint Declarations\n",
+      "    Constraint1 : Size=1, Index=None, Active=True\n",
+      "        Key  : Lower : Body              : Upper : Active\n",
+      "        None :  -Inf : x[2] - (x[1] + 2) :   0.0 :   True\n",
+      "    Constraint2 : Size=1, Index=None, Active=True\n",
+      "        Key  : Lower : Body            : Upper : Active\n",
+      "        None :  -Inf : 8*x[1] + 2*x[2] :  17.0 :   True\n",
+      "\n",
+      "5 Declarations: x_index x obj Constraint1 Constraint2\n"
+     ]
+    }
+   ],
    "source": [
     "# Define the model\n",
     "model = pyo.ConcreteModel(name='Simple example LP, 47-779 QuIP')\n",
@@ -206,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -218,27 +261,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Define the solver GLPK\n",
-    "if IN_COLAB:\n",
-    "    opt_glpk = pyo.SolverFactory('glpk', executable='/usr/bin/glpsol')\n",
-    "    opt_cbc = pyo.SolverFactory('cbc', executable='/usr/bin/cbc')\n",
-    "else:\n",
-    "    opt_glpk = pyo.SolverFactory('glpk')\n",
-    "    opt_cbc = pyo.SolverFactory('cbc')\n",
+    "opt_glpk = pyo.SolverFactory('glpk')\n",
+    "opt_cbc = pyo.SolverFactory('cbc')\n",
     "# Here we could use another solver, e.g. gurobi or cplex\n",
     "# opt_gurobi = pyo.SolverFactory('gurobi')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: Could not locate the 'glpsol' executable, which is required for\n",
+      "solver 'glpk'\n"
+     ]
+    },
+    {
+     "ename": "ApplicationError",
+     "evalue": "No executable found for solver 'glpk'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mApplicationError\u001b[0m                          Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[67], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Here we solve the optimization problem, the option tee=True prints the solver output\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m result_obj \u001b[38;5;241m=\u001b[39m \u001b[43mopt_glpk\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtee\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32mc:\\Users\\bmurr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyomo\\opt\\base\\solvers.py:533\u001b[0m, in \u001b[0;36mOptSolver.solve\u001b[1;34m(self, *args, **kwds)\u001b[0m\n\u001b[0;32m    530\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msolve\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds):\n\u001b[0;32m    531\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Solve the problem\"\"\"\u001b[39;00m\n\u001b[1;32m--> 533\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mavailable\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexception_flag\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[0;32m    534\u001b[0m     \u001b[38;5;66;03m#\u001b[39;00m\n\u001b[0;32m    535\u001b[0m     \u001b[38;5;66;03m# If the inputs are models, then validate that they have been\u001b[39;00m\n\u001b[0;32m    536\u001b[0m     \u001b[38;5;66;03m# constructed! Collect suffix names to try and import from solution.\u001b[39;00m\n\u001b[0;32m    537\u001b[0m     \u001b[38;5;66;03m#\u001b[39;00m\n\u001b[0;32m    538\u001b[0m     \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyomo\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcore\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbase\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mblock\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m _BlockData\n",
+      "File \u001b[1;32mc:\\Users\\bmurr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyomo\\opt\\solver\\shellcmd.py:141\u001b[0m, in \u001b[0;36mSystemCallSolver.available\u001b[1;34m(self, exception_flag)\u001b[0m\n\u001b[0;32m    139\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m exception_flag:\n\u001b[0;32m    140\u001b[0m         msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo executable found for solver \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m--> 141\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m ApplicationError(msg \u001b[38;5;241m%\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname)\n\u001b[0;32m    142\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m    143\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n",
+      "\u001b[1;31mApplicationError\u001b[0m: No executable found for solver 'glpk'"
+     ]
+    }
+   ],
    "source": [
     "# Here we solve the optimization problem, the option tee=True prints the solver output\n",
     "result_obj = opt_glpk.solve(model, tee=False)"
@@ -286,12 +346,7 @@
    "outputs": [],
    "source": [
     "# Define the solver IPOPT\n",
-    "if IN_COLAB:\n",
-    "    !wget -N -q \"https://ampl.com/dl/open/ipopt/ipopt-linux64.zip\"\n",
-    "    !unzip -o -q ipopt-linux64\n",
-    "    opt_ipopt = pyo.SolverFactory('ipopt', executable='/content/ipopt')\n",
-    "else:\n",
-    "    opt_ipopt = pyo.SolverFactory('ipopt')"
+    "opt_ipopt = pyo.SolverFactory('ipopt')"
    ]
   },
   {
@@ -478,8 +533,7 @@
     "    (x2>=0) &           # Bound 2\n",
     "    (x2 <= x1 + 2) &    # Constraint 1\n",
     "    (8*x1 + 2*x2 <= 17) & # Constraint 2\n",
-    "    ((x2-1)**2 <= 2-x1) & # Nonlinear constraint\n",
-    "    ((x2-1)**2 >= x1+0.5) # Nonlinear constraint 2\n",
+    "    ((x2-1)**2 <= 2-x1) # Nonlinear constraint\n",
     "    ).astype(int) \n",
     "    * objective_heatmap, # objective function, \n",
     "                extent=(x1.min(),x1.max(),x2.min(),x2.max()),origin=\"lower\", cmap=\"OrRd\", alpha = .8)\n",
@@ -498,6 +552,30 @@
     "fig"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the integer model\n",
+    "model_cinlp = pyo.ConcreteModel(name='Simple example convex INLP, 47-779 QuIP')\n",
+    "#Define the variables\n",
+    "model_cinlp.x = pyo.Var([1,2], domain=pyo.Integers)\n",
+    "# Define the objective function\n",
+    "model_cinlp.obj = pyo.Objective(rule = _obj, sense=pyo.maximize)\n",
+    "# Define the constraints\n",
+    "model_cinlp.Constraint1 = pyo.Constraint(rule = _constraint1)\n",
+    "\n",
+    "model_cinlp.Constraint2 = pyo.Constraint(rule = _constraint2)\n",
+    "\n",
+    "model_cinlp.Constraint3 = pyo.Constraint(expr = (model_cinlp.x[2]-1)**2 <= 2 - model_cinlp.x[1])\n",
+    "\n",
+    "\n",
+    "# Print the model\n",
+    "model_cinlp.pprint()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -505,11 +583,7 @@
    "outputs": [],
    "source": [
     "# Define the solver BONMIN\n",
-    "if IN_COLAB:\n",
-    "    !wget -N -q \"https://ampl.com/dl/open/bonmin/bonmin-linux64.zip\"\n",
-    "    !unzip -o -q bonmin-linux64\n",
-    "    \n",
-    "opt_bonmin = pyo.SolverFactory('bonmin', executable='/content/bonmin')"
+    "opt_bonmin = pyo.SolverFactory('bonmin')"
    ]
   },
   {
@@ -624,11 +698,7 @@
    "outputs": [],
    "source": [
     "# Define the solver COUENNE\n",
-    "if IN_COLAB:\n",
-    "    !wget -N -q \"https://ampl.com/dl/open/couenne/couenne-linux64.zip\"\n",
-    "    !unzip -o -q couenne-linux64\n",
-    "    \n",
-    "opt_couenne = pyo.SolverFactory('couenne', executable='/content/couenne')"
+    "opt_couenne = pyo.SolverFactory('couenne')"
    ]
   },
   {