docs/tutorials/02_converters_for_quadratic_programs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Converters for Quadratic Programs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optimization problems in Qiskit optimization module are represented with the `QuadraticProgram` class, which is a generic and powerful representation for optimization problems. In general, optimization algorithms are defined for a certain formulation of a quadratic program, and we need to convert our problem to the right type.\n",
    "\n",
    "For instance, Qiskit optimization provides several optimization algorithms that can handle [Quadratic Unconstrained Binary Optimization](https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization) (QUBO) problems. These are mapped to Ising Hamiltonians, for which Qiskit optimization uses the `qiskit.quantum_info.SparsePauliOp` object, and then their ground state is approximated. For this optimization, commonly known algorithms such as VQE or QAOA can be used as underlying routine. See the following tutorial about the [Minimum Eigen Optimizer](./03_minimum_eigen_optimizer.ipynb) for more detail. Note that also other algorithms exist that work differently, such as the `GroverOptimizer`.\n",
    "\n",
    "To map a problem to the correct input format, the optimization module of Qiskit optimization offers a variety of converters. In this tutorial we're providing an overview on this functionality. Currently, Qiskit optimization contains the following converters.\n",
    "\n",
    "- `InequalityToEquality`: convert inequality constraints into equality constraints with additional slack variables.\n",
    "- `IntegerToBinary`: convert integer variables into binary variables and corresponding coefficients.\n",
    "- `LinearEqualityToPenalty`: convert equality constraints into additional terms of the objective function.\n",
    "- `LinearInequalityToPenalty`: convert inequality constraints into additional terms of the objective function.\n",
    "- `MaximizeToMinimize`: convert to the equivalent minimization problem.\n",
    "- `MinimizeToMaximize`: convert to the equivalent maximization problem.\n",
    "- `QuadraticProgramToQubo`: a wrapper that includes `InequalityToEquality`, `IntegerToBinary`, `LinearEqualityToPenalty`, `LinearInequalityToPenalty`, and `MaximizeToMinimize` for convenience."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## InequalityToEquality\n",
    "`InequalityToEqualityConverter` converts inequality constraints into equality constraints with additional slack variables to remove inequality constraints from `QuadraticProgram`. The upper bounds and the lower bounds of slack variables will be calculated from the difference between the left sides and the right sides of constraints. Signs of slack variables depend on symbols in constraints such as $\\leq$ and $\\geq$.\n",
    "\n",
    "The following is an example of a maximization problem with two inequality constraints. Variable $x$ and $y$ are binary variables and variable $z$ is an integer variable.\n",
    "\n",
    "\\begin{aligned}\n",
    "   & \\text{maximize}\n",
    "       & 3x + 2y + z\\\\\n",
    "   & \\text{subject to:}\n",
    "       & x+y+z \\leq 5.5\\\\\n",
    "       & & x+y+z \\geq 2.5\\\\\n",
    "       & & x, y \\in \\{0,1\\}\\\\\n",
    "       & & z \\in \\{0,1,2,3,4,5,6,7\\} \\\\\n",
    "\\end{aligned}\n",
    "\n",
    "With `QuadraticProgram`, an optimization model of the problem is written as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization import QuadraticProgram\n",
    "from qiskit_optimization.translators.docplex_mp import to_docplex_mp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  3*x + 2*y + z\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (2)\n",
      "    x + y + z <= 5.5  'xyz_leq'\n",
      "    x + y + z >= 2.5  'xyz_geq'\n",
      "\n",
      "  Integer variables (1)\n",
      "    0 <= z <= 7\n",
      "\n",
      "  Binary variables (2)\n",
      "    x y\n",
      "\n"
     ]
    }
   ],
   "source": [
    "qp = QuadraticProgram()\n",
    "qp.binary_var(\"x\")\n",
    "qp.binary_var(\"y\")\n",
    "qp.integer_var(lowerbound=0, upperbound=7, name=\"z\")\n",
    "\n",
    "qp.maximize(linear={\"x\": 3, \"y\": 2, \"z\": 1})\n",
    "qp.linear_constraint(linear={\"x\": 1, \"y\": 1, \"z\": 1}, sense=\"LE\", rhs=5.5, name=\"xyz_leq\")\n",
    "qp.linear_constraint(linear={\"x\": 1, \"y\": 1, \"z\": 1}, sense=\"GE\", rhs=2.5, name=\"xyz_geq\")\n",
    "print(qp.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call `convert` method of `InequalityToEquality` to convert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization.converters import InequalityToEquality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  3*x + 2*y + z\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (2)\n",
      "    x + xyz_leq@int_slack + y + z == 5  'xyz_leq'\n",
      "    x - xyz_geq@int_slack + y + z == 3  'xyz_geq'\n",
      "\n",
      "  Integer variables (3)\n",
      "    0 <= z <= 7\n",
      "    0 <= xyz_leq@int_slack <= 5\n",
      "    0 <= xyz_geq@int_slack <= 6\n",
      "\n",
      "  Binary variables (2)\n",
      "    x y\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ineq2eq = InequalityToEquality()\n",
    "qp_eq = ineq2eq.convert(qp)\n",
    "print(qp_eq.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After converting, the formulation of the problem looks like the above output. As we can see, the inequality constraints are replaced with equality constraints with additional integer slack variables, $xyz\\_leg\\text{@}int\\_slack$ and $xyz\\_geq\\text{@}int\\_slack$. \n",
    "\n",
    "Let us explain how the conversion works. For example, the lower bound of the left side of the first constraint is $0$ which is the case of $x=0$, $y=0$, and $z=0$. Thus, the upper bound of the additional integer variable must be $5$ to be able to satisfy even the case of $x=0$, $y=0$, and $z=0$. Note that we cut off the part after the decimal point in the converted formulation since the left side of the first constraint in the original formulation can be only integer values. For the second constraint, basically we apply the same approach. However, the symbol in the second constraint is $\\geq$, so we add minus before $xyz\\_geq\\text{@}int\\_slack$ to be able to satisfy even the case of $x=1, y=1$, and $z=7$.\n",
    "\n",
    "\\begin{aligned}\n",
    "   & \\text{maximize}\n",
    "       & 3x + 2y + z\\\\\n",
    "   & \\text{subject to:}\n",
    "       & x+y+z+ xyz\\_leg\\text{@}int\\_slack= 5\\\\\n",
    "       & & x+y+z+xyz\\_geq\\text{@}int\\_slack= 3\\\\\n",
    "       & & x, y \\in \\{0,1\\}\\\\\n",
    "       & & z \\in \\{0,1,2,3,4,5,6,7\\} \\\\\n",
    "       & & xyz\\_leg\\text{@}int\\_slack \\in \\{0,1,2,3,4,5\\} \\\\\n",
    "       & & xyz\\_geq\\text{@}int\\_slack \\in \\{0,1,2,3,4,5,6\\} \\\\\n",
    "\\end{aligned}\n",
    "\n",
    "Let us see how the `interpret` method works. The purpose of this method is to convert the solution of the converted problem back to that of the original problem. To use this method, we would first require to solve the problem. For the purpose of this tutorial, we will use docplex to solve. We will first translate the quadratic problem into a docplex.mp model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization.algorithms import CplexOptimizer\n",
    "\n",
    "cplex_optimizer = CplexOptimizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z=3.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_orig = cplex_optimizer.solve(qp)\n",
    "print(result_orig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z=3.0, xyz_leq@int_slack=0.0, xyz_geq@int_slack=2.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_eq = cplex_optimizer.solve(qp_eq)\n",
    "print(result_eq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result `result_eq` of `qp_eq` has 5 variable values (`x=1.0, y=1.0, z=3.0, xyz_leq@int_slack=0.0, xyz_geq@int_slack=2.0`) while result `result_orig` of the original `qp` has three values (`x=1.0, y=1.0, z=3.0`).\n",
    "We can call `InequalityToEquality.interpret` method by passing a list or an array to the method that has values of `qp_eq.variables` as follows.\n",
    "`result_eq.x` has the list of values that each variable takes in the solution in correspondence to their position in the variable list `qp_eq.variables`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interpreting values of result_eq: [1. 1. 3.]\n",
      "values of result_orig: [1. 1. 3.]\n"
     ]
    }
   ],
   "source": [
    "print(\"interpreting values of result_eq:\", ineq2eq.interpret(result_eq.x))\n",
    "print(\"values of result_orig:\", result_orig.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice that $[1., 1., 3.]$ are the values taken in the solution of the converted problem for the common variables between converted and original problems (variables: $x$, $y$, $z$). The interpret method shows the same values are the solution of the original problem. This is because the objective function for the converted and original problems is exactly the same. The slack variables are just ensuring equality in the constraints of the converted problem, where the constraints are also exactly same between the original and converted problems, except that the original problem has inequality constraints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IntegerToBinary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`IntegerToBinary` converts integer variables into binary variables and coefficients to remove integer variables from `QuadraticProgram`. For converting, bounded-coefficient encoding proposed in [arxiv:1706.01945](https://arxiv.org/abs/1706.01945) (Eq. (5)) is used. For more detail of the encoding method, please see the paper.\n",
    "\n",
    "We use the output of `InequalityToEquality` as a starting point. Variables $x$ and $y$ are binary variables, while the variable $z$ and the slack variables $xyz\\_leq\\text{@}int\\_slack$ and $xyz\\_geq\\text{@}int\\_slack$ are integer variables. We print the problem again for reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  3*x + 2*y + z\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (2)\n",
      "    x + xyz_leq@int_slack + y + z == 5  'xyz_leq'\n",
      "    x - xyz_geq@int_slack + y + z == 3  'xyz_geq'\n",
      "\n",
      "  Integer variables (3)\n",
      "    0 <= z <= 7\n",
      "    0 <= xyz_leq@int_slack <= 5\n",
      "    0 <= xyz_geq@int_slack <= 6\n",
      "\n",
      "  Binary variables (2)\n",
      "    x y\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(qp_eq.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call `convert` method of `IntegerToBinary` to convert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization.converters import IntegerToBinary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  3*x + 2*y + z@0 + 2*z@1 + 4*z@2\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (2)\n",
      "    x + xyz_leq@int_slack@0 + 2*xyz_leq@int_slack@1 + 2*xyz_leq@int_slack@2 + y\n",
      "    + z@0 + 2*z@1 + 4*z@2 == 5  'xyz_leq'\n",
      "    x - xyz_geq@int_slack@0 - 2*xyz_geq@int_slack@1 - 3*xyz_geq@int_slack@2 + y\n",
      "    + z@0 + 2*z@1 + 4*z@2 == 3  'xyz_geq'\n",
      "\n",
      "  Binary variables (11)\n",
      "    x y z@0 z@1 z@2 xyz_leq@int_slack@0 xyz_leq@int_slack@1 xyz_leq@int_slack@2\n",
      "    xyz_geq@int_slack@0 xyz_geq@int_slack@1 xyz_geq@int_slack@2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "int2bin = IntegerToBinary()\n",
    "qp_eq_bin = int2bin.convert(qp_eq)\n",
    "print(qp_eq_bin.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After converting, the integer variable $z$ is replaced with three binary variables $z\\text{@}0$, $z\\text{@}1$ and $z\\text{@}2$ with coefficients 1, 2 and 4, respectively as the above. \n",
    "The slack variables $xyz\\_leq\\text{@}int\\_slack$ and $xyz\\_geq\\text{@}int\\_slack$ that were introduced by `InequalityToEquality` are also both replaced with three binary variables with coefficients 1, 2, 2, and  1, 2, 3, respectively.\n",
    "\n",
    "Note: Essentially the coefficients mean that the sum of these binary variables with coefficients can be the sum of a subset of $\\{1, 2, 4\\}$, $\\{1, 2, 2\\}$, and $\\{1, 2, 3\\}$ to represent that acceptable values $\\{0, \\ldots, 7\\}$, $\\{0, \\ldots, 5\\}$, and $\\{0, \\ldots, 6\\}$, which respects the lower bound and the upper bound of original integer variables correctly.\n",
    "\n",
    "`IntegerToBinary` also provides `interpret` method that is the functionality to translate a given binary result back to the original integer representation. Let us see how the `interpret` method works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z=3.0, xyz_leq@int_slack=0.0, xyz_geq@int_slack=2.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_eq = cplex_optimizer.solve(qp_eq)\n",
    "print(result_eq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z@0=1.0, z@1=1.0, z@2=0.0, xyz_leq@int_slack@0=0.0, xyz_leq@int_slack@1=0.0, xyz_leq@int_slack@2=0.0, xyz_geq@int_slack@0=0.0, xyz_geq@int_slack@1=1.0, xyz_geq@int_slack@2=0.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_eq_bin = cplex_optimizer.solve(qp_eq_bin)\n",
    "print(result_eq_bin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`result_eq_bin` has more binary variables due to the conversion by `IntegerToBinary.convert`.\n",
    "`IntegerToBinary.interpret` translates them back to the integer values by aggregating binary variables values associated with the original integer variables of `qp_eq`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interpreting values of result_eq_bin: [1. 1. 3. 0. 2.]\n",
      "values of result_eq: [1. 1. 3. 0. 2.]\n"
     ]
    }
   ],
   "source": [
    "print(\"interpreting values of result_eq_bin:\", int2bin.interpret(result_eq_bin.x))\n",
    "print(\"values of result_eq:\", result_eq.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LinearEqualityToPenalty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`LinearEqualityToPenalty` converts linear equality constraints into additional quadratic penalty terms of the objective function to map `QuadraticProgram` to an unconstrained form.\n",
    "An input to the converter has to be a `QuadraticProgram` with only linear equality constraints. Those equality constraints, e.g. $\\sum_i a_i x_i  = b$ where $a_i$ and $b$ are numbers and $x_i$ is a variable, will be added to the objective function in the form of $M(b - \\sum_i a_i x_i)^2$ where $M$ is a large number as penalty factor. \n",
    "By default $M= 1e5$. The sign of the term depends on whether the problem type is a maximization or minimization.\n",
    "\n",
    "We use the output of `IntegerToBinary` as a starting point, where all variables are binary variables and all inequality constraints have been mapped to equality constraints. \n",
    "We print the problem again for reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  3*x + 2*y + z@0 + 2*z@1 + 4*z@2\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (2)\n",
      "    x + xyz_leq@int_slack@0 + 2*xyz_leq@int_slack@1 + 2*xyz_leq@int_slack@2 + y\n",
      "    + z@0 + 2*z@1 + 4*z@2 == 5  'xyz_leq'\n",
      "    x - xyz_geq@int_slack@0 - 2*xyz_geq@int_slack@1 - 3*xyz_geq@int_slack@2 + y\n",
      "    + z@0 + 2*z@1 + 4*z@2 == 3  'xyz_geq'\n",
      "\n",
      "  Binary variables (11)\n",
      "    x y z@0 z@1 z@2 xyz_leq@int_slack@0 xyz_leq@int_slack@1 xyz_leq@int_slack@2\n",
      "    xyz_geq@int_slack@0 xyz_geq@int_slack@1 xyz_geq@int_slack@2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(qp_eq_bin.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call `convert` method of `LinearEqualityToPenalty` to convert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_optimization.converters import LinearEqualityToPenalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Maximize\n",
      "  -26*x^2 + 26*x*xyz_geq@int_slack@0 + 52*x*xyz_geq@int_slack@1\n",
      "  + 78*x*xyz_geq@int_slack@2 - 26*x*xyz_leq@int_slack@0\n",
      "  - 52*x*xyz_leq@int_slack@1 - 52*x*xyz_leq@int_slack@2 - 52*x*y - 52*x*z@0\n",
      "  - 104*x*z@1 - 208*x*z@2 - 13*xyz_geq@int_slack@0^2\n",
      "  - 52*xyz_geq@int_slack@0*xyz_geq@int_slack@1\n",
      "  - 78*xyz_geq@int_slack@0*xyz_geq@int_slack@2 - 52*xyz_geq@int_slack@1^2\n",
      "  - 156*xyz_geq@int_slack@1*xyz_geq@int_slack@2 - 117*xyz_geq@int_slack@2^2\n",
      "  - 13*xyz_leq@int_slack@0^2 - 52*xyz_leq@int_slack@0*xyz_leq@int_slack@1\n",
      "  - 52*xyz_leq@int_slack@0*xyz_leq@int_slack@2 - 52*xyz_leq@int_slack@1^2\n",
      "  - 104*xyz_leq@int_slack@1*xyz_leq@int_slack@2 - 52*xyz_leq@int_slack@2^2\n",
      "  + 26*y*xyz_geq@int_slack@0 + 52*y*xyz_geq@int_slack@1\n",
      "  + 78*y*xyz_geq@int_slack@2 - 26*y*xyz_leq@int_slack@0\n",
      "  - 52*y*xyz_leq@int_slack@1 - 52*y*xyz_leq@int_slack@2 - 26*y^2 - 52*y*z@0\n",
      "  - 104*y*z@1 - 208*y*z@2 + 26*z@0*xyz_geq@int_slack@0\n",
      "  + 52*z@0*xyz_geq@int_slack@1 + 78*z@0*xyz_geq@int_slack@2\n",
      "  - 26*z@0*xyz_leq@int_slack@0 - 52*z@0*xyz_leq@int_slack@1\n",
      "  - 52*z@0*xyz_leq@int_slack@2 - 26*z@0^2 - 104*z@0*z@1 - 208*z@0*z@2\n",
      "  + 52*z@1*xyz_geq@int_slack@0 + 104*z@1*xyz_geq@int_slack@1\n",
      "  + 156*z@1*xyz_geq@int_slack@2 - 52*z@1*xyz_leq@int_slack@0\n",
      "  - 104*z@1*xyz_leq@int_slack@1 - 104*z@1*xyz_leq@int_slack@2 - 104*z@1^2\n",
      "  - 416*z@1*z@2 + 104*z@2*xyz_geq@int_slack@0 + 208*z@2*xyz_geq@int_slack@1\n",
      "  + 312*z@2*xyz_geq@int_slack@2 - 104*z@2*xyz_leq@int_slack@0\n",
      "  - 208*z@2*xyz_leq@int_slack@1 - 208*z@2*xyz_leq@int_slack@2 - 416*z@2^2\n",
      "  + 211*x - 78*xyz_geq@int_slack@0 - 156*xyz_geq@int_slack@1\n",
      "  - 234*xyz_geq@int_slack@2 + 130*xyz_leq@int_slack@0 + 260*xyz_leq@int_slack@1\n",
      "  + 260*xyz_leq@int_slack@2 + 210*y + 209*z@0 + 418*z@1 + 836*z@2 - 442\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (11)\n",
      "    x y z@0 z@1 z@2 xyz_leq@int_slack@0 xyz_leq@int_slack@1 xyz_leq@int_slack@2\n",
      "    xyz_geq@int_slack@0 xyz_geq@int_slack@1 xyz_geq@int_slack@2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lineq2penalty = LinearEqualityToPenalty()\n",
    "qubo = lineq2penalty.convert(qp_eq_bin)\n",
    "print(qubo.prettyprint())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After converting, the equality constraints are added to the objective function as additional terms with the default penalty factor provided by Qiskit optimization.\n",
    "The resulting problem is now a QUBO and compatible with many quantum optimization algorithms such as VQE, QAOA and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives the same result as before."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like we did for the other converters, let us see how `interpret` method works for this case. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z@0=1.0, z@1=1.0, z@2=0.0, xyz_leq@int_slack@0=0.0, xyz_leq@int_slack@1=0.0, xyz_leq@int_slack@2=0.0, xyz_geq@int_slack@0=0.0, xyz_geq@int_slack@1=1.0, xyz_geq@int_slack@2=0.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_eq_bin = cplex_optimizer.solve(qp_eq_bin)\n",
    "print(result_eq_bin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fval=8.0, x=1.0, y=1.0, z@0=1.0, z@1=1.0, z@2=0.0, xyz_leq@int_slack@0=0.0, xyz_leq@int_slack@1=0.0, xyz_leq@int_slack@2=0.0, xyz_geq@int_slack@0=0.0, xyz_geq@int_slack@1=1.0, xyz_geq@int_slack@2=0.0, status=SUCCESS\n"
     ]
    }
   ],
   "source": [
    "result_qubo = cplex_optimizer.solve(qubo)\n",
    "print(result_qubo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "interpreting values of result_eq_bin: [1. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0.]\n",
      "values of result_eq_bin: [1. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0.]\n"
     ]
    }
   ],
   "source": [
    "print(\"interpreting values of result_eq_bin:\", lineq2penalty.interpret(result_qubo.x))\n",
    "print(\"values of result_eq_bin:\", result_eq_bin.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the result of the `interpret` method implies that both the original and converted problems have exactly the same solution. This is expected because the converted problem has exactly the same variables as the original problem, the objective has been modified in such a way that we do not have the constraints anymore in the converted problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let us see how we interpret the result of QUBO back to the solution of the original problem `qp`. The following code shows that the interpreted values are equivalent to the result of the original problem `qp`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result_orig.x [1. 1. 3.]\n",
      "interpreting result_qubo.x [1. 1. 3.]\n"
     ]
    }
   ],
   "source": [
    "print(\"result_orig.x\", result_orig.x)\n",
    "\n",
    "x = result_qubo.x\n",
    "for conv in [lineq2penalty, int2bin, ineq2eq]:\n",
    "    x = conv.interpret(x)\n",
    "print(\"interpreting result_qubo.x\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.44.1</td></tr><tr><td><code>qiskit-terra</code></td><td>0.45.0.dev0+dcec79e</td></tr><tr><td><code>qiskit_optimization</code></td><td>0.6.0</td></tr><tr><td><code>qiskit_algorithms</code></td><td>0.3.0</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.10.13</td></tr><tr><td>Python compiler</td><td>Clang 14.0.3 (clang-1403.0.22.14.1)</td></tr><tr><td>Python build</td><td>main, Aug 24 2023 22:36:46</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>10</td></tr><tr><td>Memory (Gb)</td><td>64.0</td></tr><tr><td colspan='2'>Thu Sep 07 12:33:31 2023 JST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tutorial_magics\n",
    "\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}