mbo.ipynb

{
 "cells":[
  {
   "cell_type":"markdown",
   "source":[
    "# Mixed Binary Optimization applied to Transaction Settlement\n",
    "### Reference: https:\/\/arxiv.org\/abs\/1910.05788"
   ],
   "attachments":{
    
   },
   "metadata":{
    "datalore":{
     "node_id":"nzoS09OnKkSsWBexhgp2ul",
     "type":"MD",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Importing the libraries\n",
    "from qiskit_optimization import QuadraticProgram\n",
    "from qiskit_optimization.converters import InequalityToEquality, LinearEqualityToPenalty\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
    "from qiskit import IBMQ\n",
    "from qiskit.utils import algorithm_globals, QuantumInstance\n",
    "from qiskit.algorithms import QAOA, NumPyMinimumEigensolver\n",
    "from qiskit.algorithms.optimizers import COBYLA\n",
    "from qiskit.opflow import CVaRExpectation"
   ],
   "execution_count":1,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"s39whfTNdfue9osNFLElMF",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating a Quadratic Program for the Qubit-based Transaction Settlement Problem\n",
    "# Test case 1:\n",
    "test_case_1 = QuadraticProgram(\"test_case_1\")\n",
    "print(test_case_1.prettyprint())"
   ],
   "execution_count":2,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  No variables\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"MxuDxdTuRQB4OrHFw1tMD9",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the variables to the Quadratic Program\n",
    "test_case_1.binary_var(\"x1\")\n",
    "test_case_1.binary_var(\"x2\")\n",
    "test_case_1.binary_var(\"x3\")\n",
    "print(test_case_1.prettyprint())"
   ],
   "execution_count":3,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"tTwwPPBRYuybJqBbB0CIZj",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the objective function to the Quadratic Program\n",
    "test_case_1.maximize(linear=[1, 1, 1])\n",
    "print(test_case_1.prettyprint())"
   ],
   "execution_count":4,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"waKwILkSdHVI4EXRag2AM0",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the constraints to the Quadratic Program\n",
    "test_case_1.linear_constraint(linear=[-1, 0, -1], sense=\">=\", rhs=-2, name=\"p1_c\")\n",
    "test_case_1.linear_constraint(linear=[2, 0, 2], sense=\">=\", rhs=0, name=\"p1_s\")\n",
    "test_case_1.linear_constraint(linear=[1, 1, 0], sense=\">=\", rhs=0, name=\"p2_c\")\n",
    "test_case_1.linear_constraint(linear=[-2, -2, 0], sense=\">=\", rhs=-3, name=\"p2_s\")\n",
    "test_case_1.linear_constraint(linear=[0, -1, 1], sense=\">=\", rhs=0, name=\"p3_c\")\n",
    "test_case_1.linear_constraint(linear=[0, 2, -2], sense=\">=\", rhs=0, name=\"p3_s\")\n",
    "print(test_case_1.prettyprint())"
   ],
   "execution_count":5,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (6)\n",
      "    -x1 - x3 >= -2  'p1_c'\n",
      "    2*x1 + 2*x3 >= 0  'p1_s'\n",
      "    x1 + x2 >= 0  'p2_c'\n",
      "    -2*x1 - 2*x2 >= -3  'p2_s'\n",
      "    -x2 + x3 >= 0  'p3_c'\n",
      "    2*x2 - 2*x3 >= 0  'p3_s'\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"Ndf1B1mqlXwBFpZXfQhCSv",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting the Quadratic Program to an Equality Constraint Program\n",
    "ineq2eq = InequalityToEquality()\n",
    "test_case_1_eq = ineq2eq.convert(test_case_1)\n",
    "print(test_case_1_eq.prettyprint())"
   ],
   "execution_count":6,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (6)\n",
      "    -p1_c@int_slack - x1 - x3 == -2  'p1_c'\n",
      "    -p1_s@int_slack + 2*x1 + 2*x3 == 0  'p1_s'\n",
      "    -p2_c@int_slack + x1 + x2 == 0  'p2_c'\n",
      "    -p2_s@int_slack - 2*x1 - 2*x2 == -3  'p2_s'\n",
      "    -p3_c@int_slack - x2 + x3 == 0  'p3_c'\n",
      "    -p3_s@int_slack + 2*x2 - 2*x3 == 0  'p3_s'\n",
      "\n",
      "  Integer variables (6)\n",
      "    0 <= p1_c@int_slack <= 2\n",
      "    0 <= p1_s@int_slack <= 4\n",
      "    0 <= p2_c@int_slack <= 2\n",
      "    0 <= p2_s@int_slack <= 3\n",
      "    0 <= p3_c@int_slack <= 1\n",
      "    0 <= p3_s@int_slack <= 2\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"VKHFbqIzabMyQeHLcHppOE",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting Equality Constraints to Penalty Functions\n",
    "linear_eq2penalty = LinearEqualityToPenalty(penalty=1e3)\n",
    "qubo = linear_eq2penalty.convert(test_case_1_eq)\n",
    "print(qubo.prettyprint())"
   ],
   "execution_count":7,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_1\n",
      "\n",
      "Maximize\n",
      "  -1000*p1_c@int_slack^2 - 1000*p1_s@int_slack^2 - 1000*p2_c@int_slack^2\n",
      "  - 1000*p2_s@int_slack^2 - 1000*p3_c@int_slack^2 - 1000*p3_s@int_slack^2\n",
      "  - 2000*x1*p1_c@int_slack + 4000*x1*p1_s@int_slack + 2000*x1*p2_c@int_slack\n",
      "  - 4000*x1*p2_s@int_slack - 10000*x1^2 - 10000*x1*x2 - 10000*x1*x3\n",
      "  + 2000*x2*p2_c@int_slack - 4000*x2*p2_s@int_slack - 2000*x2*p3_c@int_slack\n",
      "  + 4000*x2*p3_s@int_slack - 10000*x2^2 + 10000*x2*x3 - 2000*x3*p1_c@int_slack\n",
      "  + 4000*x3*p1_s@int_slack + 2000*x3*p3_c@int_slack - 4000*x3*p3_s@int_slack\n",
      "  - 10000*x3^2 + 4000*p1_c@int_slack + 6000*p2_s@int_slack + 16001*x1 + 12001*x2\n",
      "  + 4001*x3 - 13000\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Integer variables (6)\n",
      "    0 <= p1_c@int_slack <= 2\n",
      "    0 <= p1_s@int_slack <= 4\n",
      "    0 <= p2_c@int_slack <= 2\n",
      "    0 <= p2_s@int_slack <= 3\n",
      "    0 <= p3_c@int_slack <= 1\n",
      "    0 <= p3_s@int_slack <= 2\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"BYLTb3dN3UGI9nZLcBvoiC",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Loading the IBMQ Backend\n",
    "provider = IBMQ.enable_account(\"your-token-here\")"
   ],
   "execution_count":10,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"dlm5we5SQgTvm0E1zXlIJw",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "backend = provider.get_backend(\"simulator_statevector\")\n",
    "# backend = provider.get_backend(\"ibmq_qasm_simulator\")\n",
    "print(backend.name())"
   ],
   "execution_count":11,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "simulator_statevector\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"E8WZxOctupLb6ez86nAeDv",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating a Quantum Instance\n",
    "algorithm_globals.random_seed = 1234\n",
    "quantum_instance = QuantumInstance(backend,\n",
    "                                   shots=8192,\n",
    "                                   seed_simulator=algorithm_globals.random_seed,\n",
    "                                   seed_transpiler=algorithm_globals.random_seed)"
   ],
   "execution_count":12,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"9fMvsiC38RgAPG9QtW7krA",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Initializing the MinimumEigenSolver\n",
    "qaoa_mes = QAOA(optimizer=COBYLA(maxiter=150), expectation=CVaRExpectation(alpha=0.25),\n",
    "                quantum_instance=quantum_instance)\n",
    "exact_mes = NumPyMinimumEigensolver()"
   ],
   "execution_count":13,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"MyGXlXyHadqvoiHCiJGn9C",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating the MinimumEigenOptimizer for the MinimumEigenSolver\n",
    "qaoa = MinimumEigenOptimizer(qaoa_mes)\n",
    "exact = MinimumEigenOptimizer(exact_mes)"
   ],
   "execution_count":14,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"mcVuneTRF6OU5rKB1p86Tn",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "exact_result = exact.solve(qubo)\n",
    "print(exact_result.prettyprint())"
   ],
   "execution_count":null,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: 2.0\n",
      "variable values: x1=0.0, x2=1.0, x3=1.0, p1_c@int_slack=1.0, p1_s@int_slack=2.0, p2_c@int_slack=1.0, p2_s@int_slack=1.0, p3_c@int_slack=0.0, p3_s@int_slack=0.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"MbCYyP9cKBenJ699ZLoDvE",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Solving the Quadratic Program using the MinimumEigenOptimizer\n",
    "qaoa_result = qaoa.solve(qubo)\n",
    "print(qaoa_result.prettyprint())"
   ],
   "execution_count":null,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: 2.0\n",
      "variable values: x1=0.0, x2=1.0, x3=1.0, p1_c@int_slack=1.0, p1_s@int_slack=2.0, p2_c@int_slack=1.0, p2_s@int_slack=1.0, p3_c@int_slack=0.0, p3_s@int_slack=0.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"YULzsz78kl8I7OePLI1pJi",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating a Quadratic Program for the Qubit-based Transaction Settlement Problem\n",
    "# Test case 2:\n",
    "test_case_2 = QuadraticProgram(\"test_case_2\")\n",
    "print(test_case_2.prettyprint())"
   ],
   "execution_count":15,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  No variables\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"r409WIrxri3PRRxY3DzFZa",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the variables to the Quadratic Program\n",
    "test_case_2.binary_var_list([\"1\", \"2\", \"3\"])\n",
    "# upper bounds calculated by reading the paper\n",
    "test_case_2.integer_var(name=\"lc\", lowerbound=-2, upperbound=0)\n",
    "test_case_2.integer_var(name=\"ls\", lowerbound=0, upperbound=1)\n",
    "print(test_case_2.prettyprint())"
   ],
   "execution_count":16,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Integer variables (2)\n",
      "    -2 <= lc <= 0\n",
      "    0 <= ls <= 1\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"4HTzGyTejAad1cEL0iKlsb",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the objective function to the Quadratic Program\n",
    "test_case_2.maximize(linear=[1] * 3)\n",
    "print(test_case_2.prettyprint())"
   ],
   "execution_count":17,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Integer variables (2)\n",
      "    -2 <= lc <= 0\n",
      "    0 <= ls <= 1\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"9tV94XiJtdYa2aj7wic8mS",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the constraints to the Quadratic Program\n",
    "test_case_2.linear_constraint(linear={\"x1\": -1, \"x3\": -1, \"lc\": -1}, sense=\">=\", rhs=0, name=\"p1_c\")\n",
    "test_case_2.linear_constraint(linear={\"x1\": 2, \"x3\": 2, \"ls\": -1}, sense=\">=\", rhs=-1, name=\"p1_s\")\n",
    "test_case_2.linear_constraint(linear={\"lc\": 1, \"ls\": 2}, sense=\"==\", rhs=0, name=\"f1\")\n",
    "test_case_2.linear_constraint(linear=[1, 1], sense=\">=\", rhs=0, name=\"p2_c\")\n",
    "test_case_2.linear_constraint(linear=[-2, -2], sense=\">=\", rhs=-3, name=\"p2_s\")\n",
    "test_case_2.linear_constraint(linear=[0, -1, 1], sense=\">=\", rhs=0, name=\"p3_c\")\n",
    "test_case_2.linear_constraint(linear=[0, 2, -2], sense=\">=\", rhs=0, name=\"p3_s\")\n",
    "print(test_case_2.prettyprint())"
   ],
   "execution_count":18,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (7)\n",
      "    -lc - x1 - x3 >= 0  'p1_c'\n",
      "    -ls + 2*x1 + 2*x3 >= -1  'p1_s'\n",
      "    lc + 2*ls == 0  'f1'\n",
      "    x1 + x2 >= 0  'p2_c'\n",
      "    -2*x1 - 2*x2 >= -3  'p2_s'\n",
      "    -x2 + x3 >= 0  'p3_c'\n",
      "    2*x2 - 2*x3 >= 0  'p3_s'\n",
      "\n",
      "  Integer variables (2)\n",
      "    -2 <= lc <= 0\n",
      "    0 <= ls <= 1\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"d23gH2TzYr047SWNjHoViN",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting the Quadratic Program to an Equality Constraint Program\n",
    "ineq2eq = InequalityToEquality()\n",
    "test_case_2_eq = ineq2eq.convert(test_case_2)\n",
    "print(test_case_2_eq.prettyprint())"
   ],
   "execution_count":19,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (7)\n",
      "    -lc - p1_c@int_slack - x1 - x3 == 0  'p1_c'\n",
      "    -ls - p1_s@int_slack + 2*x1 + 2*x3 == -1  'p1_s'\n",
      "    lc + 2*ls == 0  'f1'\n",
      "    -p2_c@int_slack + x1 + x2 == 0  'p2_c'\n",
      "    -p2_s@int_slack - 2*x1 - 2*x2 == -3  'p2_s'\n",
      "    -p3_c@int_slack - x2 + x3 == 0  'p3_c'\n",
      "    -p3_s@int_slack + 2*x2 - 2*x3 == 0  'p3_s'\n",
      "\n",
      "  Integer variables (8)\n",
      "    -2 <= lc <= 0\n",
      "    0 <= ls <= 1\n",
      "    0 <= p1_c@int_slack <= 2\n",
      "    0 <= p1_s@int_slack <= 5\n",
      "    0 <= p2_c@int_slack <= 2\n",
      "    0 <= p2_s@int_slack <= 3\n",
      "    0 <= p3_c@int_slack <= 1\n",
      "    0 <= p3_s@int_slack <= 2\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"6OCdD2s8jCsjiUhoNJoyYO",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting Equality Constraints to Penalty Functions\n",
    "linear_eq2penalty = LinearEqualityToPenalty(penalty=1e3)\n",
    "qubo_2 = linear_eq2penalty.convert(test_case_2_eq)\n",
    "print(qubo_2.prettyprint())"
   ],
   "execution_count":20,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_2\n",
      "\n",
      "Maximize\n",
      "  -2000*lc^2 - 4000*lc*ls - 2000*lc*p1_c@int_slack - 5000*ls^2\n",
      "  - 2000*ls*p1_s@int_slack - 1000*p1_c@int_slack^2 - 1000*p1_s@int_slack^2\n",
      "  - 1000*p2_c@int_slack^2 - 1000*p2_s@int_slack^2 - 1000*p3_c@int_slack^2\n",
      "  - 1000*p3_s@int_slack^2 - 2000*x1*lc + 4000*x1*ls - 2000*x1*p1_c@int_slack\n",
      "  + 4000*x1*p1_s@int_slack + 2000*x1*p2_c@int_slack - 4000*x1*p2_s@int_slack\n",
      "  - 10000*x1^2 - 10000*x1*x2 - 10000*x1*x3 + 2000*x2*p2_c@int_slack\n",
      "  - 4000*x2*p2_s@int_slack - 2000*x2*p3_c@int_slack + 4000*x2*p3_s@int_slack\n",
      "  - 10000*x2^2 + 10000*x2*x3 - 2000*x3*lc + 4000*x3*ls - 2000*x3*p1_c@int_slack\n",
      "  + 4000*x3*p1_s@int_slack + 2000*x3*p3_c@int_slack - 4000*x3*p3_s@int_slack\n",
      "  - 10000*x3^2 + 2000*ls + 2000*p1_s@int_slack + 6000*p2_s@int_slack + 8001*x1\n",
      "  + 12001*x2 - 3999*x3 - 10000\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Integer variables (8)\n",
      "    -2 <= lc <= 0\n",
      "    0 <= ls <= 1\n",
      "    0 <= p1_c@int_slack <= 2\n",
      "    0 <= p1_s@int_slack <= 5\n",
      "    0 <= p2_c@int_slack <= 2\n",
      "    0 <= p2_s@int_slack <= 3\n",
      "    0 <= p3_c@int_slack <= 1\n",
      "    0 <= p3_s@int_slack <= 2\n",
      "\n",
      "  Binary variables (3)\n",
      "    x1 x2 x3\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"kVr2kSMOYgiUgDA1q7Lcur",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "algorithm_globals.massive = True\n",
    "exact_result_2 = exact.solve(qubo_2)\n",
    "print(exact_result_2.prettyprint())"
   ],
   "execution_count":21,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: 2.0\n",
      "variable values: x1=0.0, x2=1.0, x3=1.0, lc=-2.0, ls=1.0, p1_c@int_slack=1.0, p1_s@int_slack=2.0, p2_c@int_slack=1.0, p2_s@int_slack=1.0, p3_c@int_slack=0.0, p3_s@int_slack=0.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"nyetStDQ8IavIqGwmkzPEA",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Solving the Quadratic Program using the MinimumEigenOptimizer\n",
    "qaoa_result_2 = qaoa.solve(qubo_2)\n",
    "print(qaoa_result_2.prettyprint())"
   ],
   "execution_count":22,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: 2.0\n",
      "variable values: x1=0.0, x2=1.0, x3=1.0, lc=-2.0, ls=1.0, p1_c@int_slack=1.0, p1_s@int_slack=2.0, p2_c@int_slack=1.0, p2_s@int_slack=1.0, p3_c@int_slack=0.0, p3_s@int_slack=0.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"tURyDRWzkvs84e8594fcvI",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating a Quadratic Program for the Qubit-based Transaction Settlement Problem\n",
    "# Test case 3:\n",
    "test_case_3 = QuadraticProgram(\"test_case_3\")\n",
    "print(test_case_3.prettyprint())"
   ],
   "execution_count":23,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  No variables\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"xP4bkSASFFTTl7c9xjnQn6",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the variables to the Quadratic Program\n",
    "test_case_3.binary_var_list([\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\"])\n",
    "print(test_case_3.prettyprint())"
   ],
   "execution_count":24,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Minimize\n",
      "  0\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (7)\n",
      "    x1 x2 x3 x4 x5 x6 x7\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"R8dBX8kam0NhNtpqwcqRzn",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the objective function to the Quadratic Program\n",
    "test_case_3.maximize(linear=[1] * 7)\n",
    "print(test_case_3.prettyprint())"
   ],
   "execution_count":25,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3 + x4 + x5 + x6 + x7\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (7)\n",
      "    x1 x2 x3 x4 x5 x6 x7\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"CNQPgwrtXk83ao1wOL6Msw",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Adding the constraints to the Quadratic Program\n",
    "# Ignored P3 and P4 as mentioned in the paper\n",
    "test_case_3.linear_constraint(linear=[-4, -3, -2, 0, 0, 0, 0], sense=\">=\", rhs=-5, name=\"p1\")\n",
    "test_case_3.linear_constraint(linear=[4, 0, 0, -3, -3, 0, 0], sense=\">=\", rhs=-1, name=\"p2\")\n",
    "test_case_3.linear_constraint(linear={\"x4\": 3, \"x6\": -6, \"x7\": 4}, sense=\">=\", rhs=-2, name=\"p5\")\n",
    "test_case_3.linear_constraint(linear=[0, 0, 0, 0, 3, 6, -4], sense=\">=\", rhs=-1, name=\"p6\")\n",
    "print(test_case_3.prettyprint())"
   ],
   "execution_count":26,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3 + x4 + x5 + x6 + x7\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (4)\n",
      "    -4*x1 - 3*x2 - 2*x3 >= -5  'p1'\n",
      "    4*x1 - 3*x4 - 3*x5 >= -1  'p2'\n",
      "    3*x4 - 6*x6 + 4*x7 >= -2  'p5'\n",
      "    3*x5 + 6*x6 - 4*x7 >= -1  'p6'\n",
      "\n",
      "  Binary variables (7)\n",
      "    x1 x2 x3 x4 x5 x6 x7\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"JDcTB3XEbP01g0kmzn2ij9",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting the Quadratic Program to an Equality Constraint Program\n",
    "ineq2eq = InequalityToEquality()\n",
    "test_case_3_eq = ineq2eq.convert(test_case_3)\n",
    "print(test_case_3_eq.prettyprint())"
   ],
   "execution_count":27,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Maximize\n",
      "  x1 + x2 + x3 + x4 + x5 + x6 + x7\n",
      "\n",
      "Subject to\n",
      "  Linear constraints (4)\n",
      "    -p1@int_slack - 4*x1 - 3*x2 - 2*x3 == -5  'p1'\n",
      "    -p2@int_slack + 4*x1 - 3*x4 - 3*x5 == -1  'p2'\n",
      "    -p5@int_slack + 3*x4 - 6*x6 + 4*x7 == -2  'p5'\n",
      "    -p6@int_slack + 3*x5 + 6*x6 - 4*x7 == -1  'p6'\n",
      "\n",
      "  Integer variables (4)\n",
      "    0 <= p1@int_slack <= 5\n",
      "    0 <= p2@int_slack <= 5\n",
      "    0 <= p5@int_slack <= 9\n",
      "    0 <= p6@int_slack <= 10\n",
      "\n",
      "  Binary variables (7)\n",
      "    x1 x2 x3 x4 x5 x6 x7\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"MYzDK5Mcri2R41AbRTEQrI",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Converting Equality Constraints to Penalty Functions\n",
    "linear_eq2penalty = LinearEqualityToPenalty(penalty=1e3)\n",
    "qubo_3 = linear_eq2penalty.convert(test_case_3_eq)\n",
    "print(qubo_3.prettyprint())"
   ],
   "execution_count":28,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "Problem name: test_case_3\n",
      "\n",
      "Maximize\n",
      "  -1000*p1@int_slack^2 - 1000*p2@int_slack^2 - 1000*p5@int_slack^2\n",
      "  - 1000*p6@int_slack^2 - 8000*x1*p1@int_slack + 8000*x1*p2@int_slack\n",
      "  - 32000*x1^2 - 24000*x1*x2 - 16000*x1*x3 + 24000*x1*x4 + 24000*x1*x5\n",
      "  - 6000*x2*p1@int_slack - 9000*x2^2 - 12000*x2*x3 - 4000*x3*p1@int_slack\n",
      "  - 4000*x3^2 - 6000*x4*p2@int_slack + 6000*x4*p5@int_slack - 18000*x4^2\n",
      "  - 18000*x4*x5 + 36000*x4*x6 - 24000*x4*x7 - 6000*x5*p2@int_slack\n",
      "  + 6000*x5*p6@int_slack - 18000*x5^2 - 36000*x5*x6 + 24000*x5*x7\n",
      "  - 12000*x6*p5@int_slack + 12000*x6*p6@int_slack - 72000*x6^2 + 96000*x6*x7\n",
      "  + 8000*x7*p5@int_slack - 8000*x7*p6@int_slack - 32000*x7^2\n",
      "  + 10000*p1@int_slack + 2000*p2@int_slack + 4000*p5@int_slack\n",
      "  + 2000*p6@int_slack + 32001*x1 + 30001*x2 + 20001*x3 - 5999*x4 + x5 + 12001*x6\n",
      "  - 7999*x7 - 31000\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Integer variables (4)\n",
      "    0 <= p1@int_slack <= 5\n",
      "    0 <= p2@int_slack <= 5\n",
      "    0 <= p5@int_slack <= 9\n",
      "    0 <= p6@int_slack <= 10\n",
      "\n",
      "  Binary variables (7)\n",
      "    x1 x2 x3 x4 x5 x6 x7\n",
      "\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"xj43DTlrWYZwxRsbfg7awS",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Initializing the MinimumEigenSolver\n",
    "qaoa_mes = QAOA(optimizer=COBYLA(maxiter=300), expectation=CVaRExpectation(alpha=0.25),\n",
    "                quantum_instance=quantum_instance)\n",
    "exact_mes = NumPyMinimumEigensolver()"
   ],
   "execution_count":29,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"hMwWkuviYow3P6smXg9Nef",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Creating the MinimumEigenOptimizer for the MinimumEigenSolver\n",
    "qaoa = MinimumEigenOptimizer(qaoa_mes)\n",
    "exact = MinimumEigenOptimizer(exact_mes)"
   ],
   "execution_count":30,
   "outputs":[
    
   ],
   "metadata":{
    "datalore":{
     "node_id":"YZgaBqBpaljZcw0OoTONM1",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "algorithm_globals.massive = True\n",
    "exact_result_3 = exact.solve(qubo_3)\n",
    "print(exact_result_3.prettyprint())"
   ],
   "execution_count":null,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: 4.0\n",
      "variable values: x1=1.0, x2=0.0, x3=0.0, x4=0.0, x5=1.0, x6=1.0, x7=1.0, p1@int_slack=1.0, p2@int_slack=2.0, p5@int_slack=0.0, p6@int_slack=6.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"jZKKDiDOc9Ba6CvXoMdIxD",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "# Solving the Quadratic Program using the MinimumEigenOptimizer\n",
    "qaoa_result_3 = qaoa.solve(qubo_3)\n",
    "print(qaoa_result_3.prettyprint())"
   ],
   "execution_count":31,
   "outputs":[
    {
     "name":"stdout",
     "text":[
      "objective function value: -996.0\n",
      "variable values: x1=0.0, x2=1.0, x3=1.0, x4=0.0, x5=0.0, x6=1.0, x7=1.0, p1@int_slack=0.0, p2@int_slack=1.0, p5@int_slack=0.0, p6@int_slack=4.0\n",
      "status: SUCCESS\n"
     ],
     "output_type":"stream"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"tyOfW4cI7JJMzX3kN1l5FI",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  },
  {
   "cell_type":"code",
   "source":[
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table"
   ],
   "execution_count":1,
   "outputs":[
    {
     "data":{
      "text\/html":[
       "<h3>Version Information<\/h3><table><tr><th>Qiskit Software<\/th><th>Version<\/th><\/tr><tr><td><code>qiskit-terra<\/code><\/td><td>0.21.0<\/td><\/tr><tr><td><code>qiskit-aer<\/code><\/td><td>0.10.4<\/td><\/tr><tr><td><code>qiskit-ibmq-provider<\/code><\/td><td>0.19.2<\/td><\/tr><tr><td><code>qiskit<\/code><\/td><td>0.37.0<\/td><\/tr><tr><td><code>qiskit-optimization<\/code><\/td><td>0.4.0<\/td><\/tr><tr><th>System information<\/th><\/tr><tr><td>Python version<\/td><td>3.8.12<\/td><\/tr><tr><td>Python compiler<\/td><td>GCC 11.2.0<\/td><\/tr><tr><td>Python build<\/td><td>default, Oct  9 2022 15:59:00<\/td><\/tr><tr><td>OS<\/td><td>Linux<\/td><\/tr><tr><td>CPUs<\/td><td>2<\/td><\/tr><tr><td>Memory (Gb)<\/td><td>3.8291244506835938<\/td><\/tr><tr><td colspan='2'>Thu Oct 13 03:42:28 2022 UTC<\/td><\/tr><\/table>"
      ]
     },
     "metadata":{
      
     },
     "output_type":"display_data"
    }
   ],
   "metadata":{
    "datalore":{
     "node_id":"Sq4l3de9cUnfFsnr69nxWO",
     "type":"CODE",
     "hide_input_from_viewers":false,
     "hide_output_from_viewers":false
    }
   }
  }
 ],
 "metadata":{
  "kernelspec":{
   "display_name":"Python",
   "language":"python",
   "name":"python"
  },
  "datalore":{
   "version":1,
   "computation_mode":"JUPYTER",
   "package_manager":"pip",
   "base_environment":"default",
   "packages":[
    {
     "name":"qiskit",
     "version":"0.37.0",
     "source":"PIP"
    },
    {
     "name":"qiskit-optimization",
     "version":"0.4.0",
     "source":"PIP"
    }
   ]
  }
 },
 "nbformat":4,
 "nbformat_minor":4
}