constrainedQAOA_benchmarking.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e916047",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "\\********************************************************************************\n",
    "* Copyright (c) 2024 the Qrisp authors\n",
    "*\n",
    "* This program and the accompanying materials are made available under the\n",
    "* terms of the Eclipse Public License 2.0 which is available at\n",
    "* http://www.eclipse.org/legal/epl-2.0.\n",
    "*\n",
    "* This Source Code may also be made available under the following Secondary\n",
    "* Licenses when the conditions for such availability set forth in the Eclipse\n",
    "* Public License, v. 2.0 are satisfied: GNU General Public License, version 2\n",
    "* with the GNU Classpath Exception which is\n",
    "* available at https://www.gnu.org/software/classpath/license.html.\n",
    "*\n",
    "* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0\n",
    "********************************************************************************/\n",
    "\"\"\"\n",
    "\n",
    "from state_preparation_parametrized import *\n",
    "from qrisp.quantum_backtracking import OHQInt\n",
    "from classical_cost_func import cost_function, format_coeffs, cost_symp\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from encode_PBS_problem import PBS_graph, N, M, cost_coeff\n",
    "\n",
    "tot_coeff = format_coeffs(cost_coeff, N)\n",
    "\n",
    "####################\n",
    "# Compute optimal solution via unstructured search (brute force method)\n",
    "####################\n",
    "\n",
    "qtype = OHQInt(N)\n",
    "q_array_2 = QuantumArray(qtype = qtype, shape = (M))\n",
    "\n",
    "uniform_state = prepare_pbs_state(PBS_graph, 0, N, q_array_2)\n",
    "meas_res = uniform_state.get_measurement()\n",
    "\n",
    "cl_cost = cost_function(tot_coeff,PBS_graph)\n",
    "\n",
    "solutions = {}\n",
    "for k,v in meas_res.items():\n",
    "    c = cl_cost({k:1})  \n",
    "    solutions[k] = c\n",
    "sorted_solutions = sorted(solutions.items(), key=lambda item: item[1])\n",
    "min_cost = sorted_solutions[0][1]\n",
    "optimal_solution = sorted_solutions[0][0]\n",
    "\n",
    "print('###  Best assignment (brute force): ###')\n",
    "print('   Cost:  ',sorted_solutions[0][1])\n",
    "print('   State: ',sorted_solutions[0][0])\n",
    "print('   Number of admissible states: ',len(sorted_solutions))\n",
    "\n",
    "####################\n",
    "####################\n",
    "\n",
    "qtype = OHQInt(N)\n",
    "q_array = QuantumArray(qtype = qtype, shape = (M))\n",
    "\n",
    "# Cost function as SymPy polynomial\n",
    "C,S = cost_symp(tot_coeff,M,N,PBS_graph)\n",
    "ord_symbs=list(S.values())\n",
    "\n",
    "def cost_op(q_array, gamma):\n",
    "    app_sb_phase_polynomial(q_array, C, ord_symbs, t=-gamma)\n",
    "\n",
    "# Initialization function\n",
    "init_func = pbs_state_init(PBS_graph, 0 , N)\n",
    "\n",
    "# Inverse state preparation operator\n",
    "def inv_init_func(q_array):\n",
    "    with invert():\n",
    "        init_func(q_array)\n",
    "\n",
    "# Define mixer operator\n",
    "def mixer_op(q_array, beta):\n",
    "    with conjugate(inv_init_func)(q_array):\n",
    "        for i in range(len(q_array)):\n",
    "            mcp(beta, q_array[i], ctrl_state = 0)\n",
    "\n",
    "# Classical cost function\n",
    "#values = []\n",
    "cl_cost = cost_function(tot_coeff,PBS_graph)\n",
    "\n",
    "# Define QAOA problem\n",
    "from qrisp.qaoa import *\n",
    "qaoaPBS = QAOAProblem(cost_operator=cost_op ,mixer=mixer_op, cl_cost_function=cl_cost, init_type='tqa')\n",
    "qaoaPBS.set_init_function(init_func)\n",
    "#depth = 3\n",
    "#res = qaoaPBS.run(q_array, depth,  max_iter = 100)\n",
    "benchmark = qaoaPBS.benchmark(q_array, [0,1,2,3,4], [5000], [100], optimal_solution, init_type='tqa')\n",
    "\n",
    "#benchmark.save(\"data/constrainedQAOA_(1,0),(2,0),(3,1)_4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a3c8eeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ProbabilityApproximation10(res,cl_cost,optimal_solution):\n",
    "    prob = 0\n",
    "    optiomal_cost = cl_cost({optimal_solution:1})\n",
    "    for k,v in res.items():\n",
    "        c = cl_cost({k:1})\n",
    "        if c < 1.1*optiomal_cost:\n",
    "            prob += v\n",
    "    return prob\n",
    "\n",
    "def Approximation(res,cl_cost,optimal_solution):\n",
    "    return cl_cost(res)/cl_cost(optimal_solution)\n",
    "\n",
    "def ProbabilityArrgegated(res,cl_cost):\n",
    "    costs = list(set([round(cl_cost({item[0]:1.0}),2) for item in res.items()]))\n",
    "    probs = [0]*len(costs)\n",
    "    for k,v in res.items():\n",
    "        cost = round(cl_cost({k:1.0}),2)\n",
    "        probs[costs.index(cost)] += v\n",
    "    return costs, probs\n",
    "\n",
    "cl_cost = benchmark.cost_function\n",
    "optimal_solution = benchmark.optimal_solution\n",
    "layers = benchmark.layer_depth\n",
    "results = benchmark.counts\n",
    "\n",
    "\n",
    "x1, y1 = ProbabilityArrgegated(results[2],cl_cost)\n",
    "\n",
    "x2 = layers\n",
    "y2 = [ProbabilityApproximation10(res,cl_cost,optimal_solution) for res in results]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3617278",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import scipy\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1,2, figsize = (12.5, 4))\n",
    "\n",
    "# First Plot (ProbabilityArrgegated)\n",
    "ax1.set_xlabel(\"Cost\", fontsize=15, color=\"#444444\", fontname=\"Segoe UI\")\n",
    "ax1.set_ylabel(\"Probability\", fontsize=15, color=\"#444444\", fontname=\"Segoe UI\")\n",
    "ax1.set_xticks(ticks = range(8, 27, 4))\n",
    "ax1.bar(x1, y1, width=0.1, color='#20306f')\n",
    "#ax1.legend(fontsize=14, labelcolor='linecolor')\n",
    "ax1.grid()\n",
    "\n",
    "\n",
    "# Second Plot (ProbabilityApproximation10)\n",
    "ax2.set_xlabel(\"Layers\", fontsize=15, color=\"#444444\", fontname=\"Segoe UI\")\n",
    "ax2.set_ylabel(\"Probability\", fontsize=15, color=\"#444444\", fontname=\"Segoe UI\")\n",
    "ax2.set_xticks(ticks = range(0, 5, 1))\n",
    "ax2.plot(x2, y2, c='#20306f', marker=\"o\", linestyle='solid', linewidth=3, zorder=3)\n",
    "#ax2.legend(fontsize=14, labelcolor='linecolor')\n",
    "ax2.grid()\n",
    "\n",
    "# Show both plots side by side\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4b61ba4",
   "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.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}