deshayes_lavergne_cs_report.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cMdYU9jMczzj"
   },
   "source": [
    "# Compressed Sensing : Final Project - Semidefinite Relaxations for Integer Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IPjZdTAJrCm5"
   },
   "source": [
    "### Rémy Deshayes and Éric Lavergne\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yp8EdoZNrCm8"
   },
   "source": [
    "*March 25th 2021*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yzEEdRzDvMlj"
   },
   "source": [
    "Our project is based on the work of Franz Rendl in *Semidefinite Relaxations for Integer Programming*. We summarized the main ideas of the article and implemented some of the solutions described in the survey for the two classical problems of maxcut and graph coloring."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "icoxsSMrvnbK"
   },
   "source": [
    "The first part *1. Approachs for Integer Programming* quickly introduces the approaches used in this field. The second part *2. The basics of SemiDefinite Optimization* outlines the main ideas of SDP programming. The third part *3. Famous (COP), SDP relaxation and hyperplane rounding* considers the examples of two classical problems, Max-Cut and Graph coloring, that can be solved thanks to SDP programming. Once a solution of the SDP relaxation has been obtained, the hyperplane rounding algorithm is used to obtain a good solution in the initial space. Finally, in the last part *4. Interior Points methods for SDP programming and more*, we describe methods to compute SDP problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SAlynclHLA4Q"
   },
   "source": [
    "Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ku2yk8Uj151D"
   },
   "outputs": [],
   "source": [
    "import cvxpy as cp\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fgGC1OJN_viw"
   },
   "source": [
    "This notebook involves many graph problems and then some drawings are done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5JX2XySu_vix"
   },
   "outputs": [],
   "source": [
    "def draw_graph_from_np(A):\n",
    "    \"\"\"\n",
    "    draw a graph from its adjacency matrix A\n",
    "    \"\"\"\n",
    "    G = nx.from_numpy_matrix(np.matrix(A))\n",
    "\n",
    "    nx.draw(G, with_labels=True, font_weight='bold')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RfRhZDL7rCm-"
   },
   "source": [
    "# 1  Approachs for Integer Progamming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vLTk0wzVrCnC"
   },
   "source": [
    "## 1.1 The origins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZElQXZtwrCnD"
   },
   "source": [
    "Integer Programming consists of optimization problems where some variables are restricted to be integers. This area of study is closely related to Combinatorial Optimization, and we will study in this report different Combinatorial Optimisation problems that can be expressed in the form of integer programming.\n",
    "\n",
    "Let us recall the general form of a Combinatorial Optimization Problem \\eqref{eqn: cop} :\n",
    "\n",
    "- $E$ is a finite set, each $e \\in E$ has a given cost $c_e \\in \\mathbb{N}$\n",
    "- $\\mathscr{F}$ is a finite family of subsets of $E$ denoting the set of feasible solutions of \\eqref{eqn: cop}\n",
    "\n",
    "The cost function for $F \\in \\mathscr{F}$ is given by : $$ c(F) := \\sum\\limits_{e \\in F} c_e $$ \n",
    "\n",
    "Now, the \\eqref{eqn: cop} problem is about finding a feasible solution $F$ of minimum cost : \n",
    "\\begin{equation}\n",
    "\\tag{COP}\n",
    "\\label{eqn: cop}\n",
    "z^* = \\min\\{ c(F) : F \\in \\mathscr{F} \\}\n",
    "\\end{equation}\n",
    "\n",
    "To solve \\eqref{eqn: cop} one can use the *Polyhedral Approach*. This approach is based on assigning a characteristic vector to each $F \\in \\mathscr{F}$, $x_F \\in \\{ 0,1 \\}^n$ where $(x_F)_e = 1$ if and only if $e \\in F$.     \n",
    "Now, let us introduce $P := \\text{conv}\\{ x_F : F \\in \\mathscr{F} \\}$, the convex hull of the characteristic vectors of feasible solutions.\n",
    "\n",
    "This allows to write \\eqref{eqn: cop} as the following linear program \\eqref{eqn: cop_v2} \n",
    "\\begin{equation} \n",
    "    \\tag{COP V2}\n",
    "    \\label{eqn: cop_v2}\n",
    "    z^* = \\min\\{ c^T x_F : F \\in \\mathscr{F} \\} = \\min\\{ c^T x : x \\in P \\}\n",
    "\\end{equation}\n",
    "\n",
    "For the past five decades or so, NP-hard integer optimization problems have been widely approached with this technique. Indeed, a partial description of $P$ can be exploited by renowned linear programming algorithmic methods and has often yielded good results.        \n",
    "However, the approach \\eqref{eqn: cop_v2} have given some pretty poor results for famous NP-hard problems such as Max-Cut.\n",
    "\n",
    "## 1.2 A new approach : matrix liftings\n",
    "\n",
    "To overcome this disappointment one can use the set of matrices of the form $\\mathscr{M} := \\text{conv}\\{ x_F x_F^T : F \\in \\mathscr{F} \\} $ instead of $P$ defined in approach \\eqref{eqn: cop_v2}.     \n",
    "\n",
    "The underlying intuition is based on the fact that any quadratic constraint on $x \\in P$ translates into a linear constraint on $X \\in \\mathscr{M}$ (e.g $x_ix_j = 0$ becomes $x_{ij} = 0$). Same goes with the cost function. In addition $X \\in \\mathscr{M}$ is positive semidefinite.          \n",
    "\n",
    "A Major consequence of the switch is that this relaxation is conveying a problem lying in the space of symmetric matrices $\\mathscr{S}_n$ instead of the traditional \\eqref{eqn: cop} space $\\mathbb{R}^n$             \n",
    "\n",
    "Finally, if we add the condition that $\\mathscr{M}$ is contained in the cone of positive semidefinite matrices we end up having semidefinite relaxations as approximations of our initial \\eqref{eqn: cop}."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MKSkSSJurCnH"
   },
   "source": [
    "# 2  The basics of Semidefinite Optimization            \n",
    "\n",
    "\n",
    "In part 3, we will dive into more details about the SDP relaxation of a few famous (COP), notably the Max-Cut for which (COP V2) modeling led to poor results and motivated the need to introduce the method seen in 1.2.        \n",
    "\n",
    "But before that, let us recall the general form of the \\eqref{eqn: sdp} program :\n",
    "\n",
    "\\begin{equation}\n",
    "    \\tag{SDP}\n",
    "    \\label{eqn: sdp}\n",
    "    z_p = \\inf \\{ \\langle C, X \\rangle : \\langle A_i, X \\rangle = b_i, i = 1, \\dots, m, X \\succeq 0 \\}\n",
    "\\end{equation}\n",
    "\n",
    "where $C, A_1, \\dots, A_m$ are symmetric of size $n$ and $b \\in \\mathbb{R}^m$                 \n",
    "\n",
    "Noting that \\eqref{eqn: sdp} is a convex optimization problem - indeed, we are optimizing a convex objective function under convex constraints -, let us make a quick comment about the duality gap here.          \n",
    "\n",
    "In general, strong duality (solutions of the primal $z_p$ and dual $z_d$ problems are equal) is not guaranteed. Here the duality gap will be equal to zero if *Slater's* condition hold for the primal problem.         \n",
    "\n",
    "The *Slater's* condition states that strong duality holds if there exists a strictly feasible $X^*$, in other word all constraints are satisfied and the nonlinear constraints are satisfied with strict inequalities.        \n",
    "Thus, \\ref{eqn: sdp} satisfies the *Slater's* condition if there exists $X \\succ 0$ such that $A(X) = b$ where $A(X)$ is the linear operator mapping matrices into $\\mathbb{R}^m$ as follows $A(X)_i = \\langle A_i, X \\rangle$      \n",
    "\n",
    "Finally, we note that if $z_d^* > - \\infty$, the dual problem is feasible (see \\[Boyd\\] part 5.2.3 \"Strong duality and Slater’s constraint qualification\" pages 227-228)       \n",
    "\n",
    "Fortunately, the semidefinite relaxations considered in section 3 all satisfy the conditions discussed in this section.\n",
    "\n",
    "**REFERENCE**    \n",
    "\n",
    "\\[Boyd\\]  Stephen Boyd and Lieven Vandenberghe. 2004. Convex Optimization. Cambridge University Press, USA."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_gisxzgsrCnK"
   },
   "source": [
    "# 3  Famous (COP), SDP relaxation and hyperplane rounding:\n",
    "\n",
    "\n",
    "In section 1 we saw the motivations of using semidefinite relaxations for some famous (COP) notably the Max-Cut.    \n",
    "Now, let us now dive into more details about semidefinite relaxations for the Max-Cut and the graph coloring problems. \n",
    "\n",
    "## 3.1 Max-Cut\n",
    "\n",
    "### 3.1.1 SDP Relaxation\n",
    "\n",
    "Let $G$ be a graph on $n$ vertices. The Max-Cut consists in separating the vertex set $V$ of $G$ into two sets $S, V \\setminus S$ such that the number of edges between the set $S$ and the set  $V \\setminus S$ is as large as possible.          \n",
    "\n",
    "Now let us denote $A$ the adjacency matrix of $G$, the Max-Cut problem \\eqref{eqn :pb_max_cut_1} can be formalized as follows :\n",
    "\n",
    "\\begin{equation}\n",
    "\\tag{MC}\n",
    "\\label{eqn :pb_max_cut_1}\n",
    "    z_{mc} = \\max_{S \\subseteq V} \\sum\\limits_{ij \\in \\delta(S)} a_{ij}\n",
    "\\end{equation} \n",
    "where $\\delta(S)$ is the set of edges $ij$ such that $i \\in S$, $j \\notin S$        \n",
    "\n",
    "Now using the ideas we introduced in part 1.1, let us model subsets $S \\subseteq V$ by characteristic vectors $x \\in \\{ -1, 1 \\}^n$ where $x_i = 1$ if $i \\in S$       \n",
    "\n",
    "We note that $\\text{edge} = ij \\in \\delta(S) $ if $ x_ix_j = -1 $, thus we can rewrite our objective function in \\eqref{eqn :pb_max_cut_1} : $$ \\sum\\limits_{ij \\in \\delta(S)} a_{ij} = \\sum\\limits_{ij \\in E} a_{ij} \\frac{1 - x_ix_j}{2}$$         \n",
    "\n",
    "Now, a way to model the objective function makes use of the Laplacian associated to $A$ : $$ L_A = \\text{Diag}(Ae) - A$$          \n",
    "where $e = (1, \\dots, 1)^T$       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9HXwnUKBrCnN"
   },
   "outputs": [],
   "source": [
    "def Laplacien(A):\n",
    "    \"\"\"\n",
    "    Calculation of the Laplacian of matrix A, i.e. Diag(Ae)-A\n",
    "\n",
    "    A: square matrix, adjacency matrix of a graph\n",
    "\n",
    "    return: square matrix L Laplacian of matrix A\n",
    "    \"\"\"\n",
    "    L = np.diag(np.dot(A,np.ones(len(A)))) - A\n",
    "\n",
    "    return L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PaKmOEQVrCnO"
   },
   "source": [
    "Using $L_A$, we obtain a new equality for the objective function : $$ \\sum\\limits_{ij \\in E} a_{ij} \\frac{1 - x_ix_j}{2} = \\frac{1}{4} x^T L_A x  $$\n",
    "This can be proved by developing the right-hand side of the equality.    \n",
    "\n",
    "We now use those results in (MC) and get :      \n",
    "\n",
    "\\begin{equation*}\n",
    "    z_{mc} = \\max_{x \\in \\{ -1, 1 \\}^n} \\frac{1}{4} x^T L x \n",
    "\\end{equation*}        \n",
    "\n",
    "Now using the 1.2 linearization idea, we introduce $X = xx^T$ in $ x^T L x = \\langle L, xx^T \\rangle = \\langle L, X \\rangle $. Given that $x_i \\in \\{ -1, 1 \\}$, we note that $ \\text{Diag}(X) = e $      \n",
    "\n",
    "We can now conclude with the SDP relaxation of Max-Cut :\n",
    "\n",
    "\\begin{equation}\n",
    "\\tag{MC SDP}\n",
    "\\label{pb_max_cut_sdp}\n",
    "\\begin{split}\n",
    "    &z_{mc, sdp} = \\max \\frac{1}{4} \\langle L, X \\rangle \\\\\n",
    "    \\text{ s.c : } &\\text{Diag}(X) = e\\\\\n",
    "    &X \\succeq 0\n",
    "\\end{split}\n",
    "\\end{equation}       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n7zRQvPGrCnP"
   },
   "source": [
    "This SDP relaxation is implemented below with the CVXPY library :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k_ccys9WrCnS"
   },
   "outputs": [],
   "source": [
    "def solve_sdp_maxcut(L):\n",
    "    \"\"\"\n",
    "    Definition and solving of the SDP relaxation of the maxcut problem\n",
    "    (see (14) in the article of Franz Rendl)\n",
    "\n",
    "    L: square matrix, laplacian of the adjacency matrix of the graph\n",
    "    \n",
    "    return: square matrix X solution of the SDP problem\n",
    "    \"\"\"\n",
    "    n = len(L)\n",
    "    \n",
    "    #define the variable and the constraints of the problem\n",
    "    X = cp.Variable((n,n), symmetric=True)\n",
    "    #X has to be SDP\n",
    "    constraints = [X >> 0]\n",
    "    #Diag(X) = e\n",
    "    constraints += [\n",
    "        X[i][i] == 1 for i in range(n)\n",
    "    ]\n",
    "    #Define the objective\n",
    "    prob = cp.Problem(cp.Maximize(cp.trace((1/4)*L @ X)),\n",
    "                      constraints)\n",
    "    prob.solve()\n",
    "\n",
    "    return X.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "y4XKOHmhrCnT"
   },
   "source": [
    "### 3.1.2 Hyperplane rounding for Max-Cut\n",
    "\n",
    "So far, we used the SDP relaxation as a modeling tool but it can also be used to generate good integer solutions for the problems it is derived from.      \n",
    "\n",
    "One of the most famous example of for (MC) has been introduced by Goemans and Williamson in 1995 (GW95).        \n",
    "\n",
    "To use (GW95) one first need to solve the SDP relaxation of Max-Cut (MC SDP) derived above and obtains $X^*$ the problem relaxation solution. Now since $X^*$ is a symmetric matrix we can write it $X^* = P^T L P$ where $L$ is a diagonal matrix with the all positive eigenvalues of $X^*$ and $P$ the matrix formed by the associated eigenvectors. $$ X^* = P^T L P = P^T (L^{\\frac{1}{2}})^T L^{\\frac{1}{2}} P = V^T V$$         \n",
    "\n",
    "We note that as $\\text{Diag}(X^*) = e$, having written $X^*$ as $V^TV$ we deduce that the Euclidian norm of $v_i$ for any $i \\in \\{ 1, \\dots, n\\}$ is 1 meaning that $v_i$ are on the unit sphere.           \n",
    "This allows to better understand why this approach is called \"hyperplane rounding\". Indeed, we recall that are trying to find an optimal hyperplane, going through the origin, separating the $v_i$ in two, one side in $S$ and the other in $V \\setminus S$ as defined in 3.1.1, one side being encoded as $1$ and the other as $-1$            \n",
    "\n",
    "Now, the geometrical intuition of (GW95) is that if we take a normal vector $r$ to this hyperplan all $v_i$ forming an acute angle with $r$ will be encoded as $1$ and as $-1$ if the angle is obtuse. This geometrical argument looking at angles can be translated in an inner product $r^T v_i = \\lVert r \\rVert \\lVert v_i \\rVert \\cos($*angle between* $ r $ *and* $ v_i)$, the euclidian norms being $1$ for $r$ and $v_i$ as discussed above, we end up keeping the $\\cos$ only.     \n",
    "Which makes it clear why (GW95) is using the sign of the inner product $r^T v_i$ to create its cut.     \n",
    "\n",
    "Now that we have the intuition in mind, the whole algorithm is given by :      \n",
    "\n",
    "**Goemans-Williamson \"hyperplane rounding\" algorithm (GW95)**          \n",
    "*Input*            \n",
    "- $X \\succeq 0 $ and $ \\text{Diag}(X) = e $ given by $X = V^T V$ where $V$ is a squared matrix of size $n$ such that $ V = (v_1, \\dots, v_n) $    \n",
    "\n",
    "*Algorithm* \n",
    "- Randomly draw a vector $r \\in \\mathbb{R}^n$ uniformly distributed on the unit sphere \n",
    "- $ \\xi_i = 1 \\iff r^T v_i \\geq 0$     \n",
    "\n",
    "*Output* \n",
    "-  A bisection $ \\xi \\in \\{ -1, 1 \\}^n$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xm0jNCzS_vjB"
   },
   "source": [
    "To compute the hyperplane rounding we need to compute the Cholesky factorisation of the solution X of the SDP relaxation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4mhyKaBeMjIQ"
   },
   "outputs": [],
   "source": [
    "def V(X):\n",
    "    \"\"\"\n",
    "    Factorisation of a SDP matrix X as X=VtV\n",
    "    \n",
    "    X: SDP matrix\n",
    "\n",
    "    return: square matrix V such as X=VtV\n",
    "    \"\"\"\n",
    "    eig_vals, eig_vecs = np.linalg.eig(X)\n",
    "\n",
    "    #in the case where the matrix is no more SDP because of rounding errors:\n",
    "    eig_vals[eig_vals < 0] = 0\n",
    "\n",
    "    V = np.diag(np.sqrt(eig_vals)) @ eig_vecs.T\n",
    "\n",
    "    return V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1YkvPdbcmWRQ"
   },
   "source": [
    "Below is the Goemans-Williamson algorithm code with the hyperplane rounding idea applied to maxcut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HR1SA5kJSEPS"
   },
   "outputs": [],
   "source": [
    "def GW_algo(V, L, nb_iterations=10):\n",
    "    \"\"\"\n",
    "    Execution of the Goemans-Williamson algorithm for maxcut\n",
    "\n",
    "    V: square matrix such as X=VtV is a solution of the SDP relaxation\n",
    "    A: square matrix, laplacian of the adjacency matrix\n",
    "    used here to compute the performance of the cut\n",
    "    nb_iterations: int, maximum number of iterations of the algorithm\n",
    "\n",
    "    return: vector ksi defining a bisection of the graph of the problem\n",
    "    having good performances for the maxcut (see 3.1.3 below)\n",
    "    \"\"\"\n",
    "    n = len(V)\n",
    "\n",
    "    best_performance = -np.inf\n",
    "    best_ksi = None\n",
    "\n",
    "    #iterate over nb_iterations and keep the best iteration\n",
    "    for i in range(nb_iterations):\n",
    "\n",
    "        #generate r randomly on the unit sphere\n",
    "        r = np.random.normal(0,1,n)\n",
    "        r /= np.linalg.norm(r)\n",
    "        #compute the dot products rTvi between r and vi\n",
    "        rTvis = np.dot(V,r)\n",
    "        #compute the related cut with 1 and -1\n",
    "        ksi = 2*(rTvis>=0)-1\n",
    "        \n",
    "        #compute the performance of the cut\n",
    "        performance = (1/4)*np.dot(ksi.T, np.dot(L, ksi))\n",
    "        \n",
    "        #keep the best iteration\n",
    "        if performance > best_performance:\n",
    "            best_performance = performance\n",
    "            best_ksi = ksi\n",
    "\n",
    "    return best_ksi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g_tE3xKTPkXM"
   },
   "source": [
    "We can test the GW algorithm for some graphs, starting with very simples graphs with respectively two connected vertices and three vertices with two connections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cU8E-njwdQj-",
    "outputId": "03f35b21-d93f-480e-a124-f4f19277259e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjacency matrix :\n",
      "[[0 1]\n",
      " [1 0]]\n",
      "Vector of the cut : [ 1 -1]\n"
     ]
    }
   ],
   "source": [
    "# Adjacency matrix of a graph with two connected vertices\n",
    "A = np.array([[0,1],[1,0]])\n",
    "print(\"Adjacency matrix :\")\n",
    "print(A)\n",
    "#the SDP problem is solved with the Laplacian matrix\n",
    "L = Laplacien(A)\n",
    "X = solve_sdp_maxcut(L)\n",
    "#We can then run the GW algorithm with the solution X\n",
    "print(\"Vector of the cut : {}\".format(GW_algo(V(X), L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 332
    },
    "id": "o6PkW0gNrCng",
    "outputId": "b3f2ef43-a9ea-4858-a946-2dbd1788dd3b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjacency matrix :\n",
      "[[0 1 0]\n",
      " [1 0 2]\n",
      " [0 2 0]]\n",
      "Vector of the cut : [-1  1 -1]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Adjacency matrix of a graph with three vertices connected as a line\n",
    "A = np.array([[0,1,0],[1,0,2],[0,2,0]])\n",
    "print(\"Adjacency matrix :\")\n",
    "print(A)\n",
    "#the SDP problem is solved with the Laplacian matrix\n",
    "L = Laplacien(A)\n",
    "X = solve_sdp_maxcut(L)\n",
    "#We can then run the GW algorithm with the solution X\n",
    "print(\"Vector of the cut : {}\".format(GW_algo(V(X), L)))\n",
    "\n",
    "plt.figure(figsize=(3,3))\n",
    "draw_graph_from_np(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OTuUEZ4rrCnh"
   },
   "source": [
    "We observe that the GW algorithm give finally the good cuts (one vertice a vertex of the graph belongs to one side of the cut if it is 1 and to the other if it is -1). We now test the GW algorithm for a graph with a random adjacency matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2A8gNfynrCnh",
    "outputId": "776384dd-21f7-4142-b878-55364d514cb8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjacency matrix :\n",
      "[[ 0.         -1.34991881 -2.56744235 -1.02561188 -0.12621858  0.23677004]\n",
      " [-1.34991881  0.         -1.18684581  0.93404123  0.128577    0.48067225]\n",
      " [-2.56744235 -1.18684581  0.         -0.73383814 -0.79004163 -0.40545759]\n",
      " [-1.02561188  0.93404123 -0.73383814  0.          0.53070161  0.0777178 ]\n",
      " [-0.12621858  0.128577   -0.79004163  0.53070161  0.         -0.63667815]\n",
      " [ 0.23677004  0.48067225 -0.40545759  0.0777178  -0.63667815  0.        ]]\n",
      "Vector of the cut : [ 1 -1  1  1  1  1]\n"
     ]
    }
   ],
   "source": [
    "# Adjacency matrix of a graph with n vertices and a random adjacency matrix\n",
    "n = 6\n",
    "A = np.random.randn(n, n)\n",
    "#delete the weighs for the edges between a same vertex\n",
    "for i in range(len(A)):\n",
    "    A[i][i] = 0\n",
    "#make the adjacency matrix symetric\n",
    "for i in range(len(A)):\n",
    "    for j in range(i,len(A)):\n",
    "        A[i][j] = A[j][i]\n",
    "print(\"Adjacency matrix :\")\n",
    "print(A)\n",
    "#the SDP problem is solved with the Laplacian matrix\n",
    "L = Laplacien(A)\n",
    "X = solve_sdp_maxcut(L)\n",
    "#We can then run the GW algorithm with the solution X\n",
    "print(\"Vector of the cut : {}\".format(GW_algo(V(X), L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 247
    },
    "id": "OHI-1GJ2CDYI",
    "outputId": "e57c1044-090b-4581-fbea-844d6afdf8db"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "draw_graph_from_np(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ouBARto-rCnj"
   },
   "source": [
    "### 3.1.3 Performance guarantee of the algorithm         \n",
    "\n",
    "The geometrical intuition we introduced above also has an interesting feature : the expectation value of the solution $\\xi$ of (GW95) has a simple form.        \n",
    "\n",
    "Using the (MC) form we introduced in part 3.1.1 and acknowledging that $\\mathbb{P}(\\xi_i \\neq \\xi_j) = \\frac{\\arccos(v_i^T v_j)}{\\pi}$, we can write the expectation value of the (GW95) algorithm's solution $\\xi$ as :\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{esp_gw95}\n",
    "    \\mathbb{E}\\left( \\sum\\limits_{ij \\in E} a_{ij} \\frac{1 - \\xi_i\\xi_j}{2} \\right) = \\sum\\limits_{ij \\in E} a_{ij} \\frac{\\arccos{v_i^T v_j}}{\\pi}\n",
    "\\end{equation}          \n",
    "\n",
    "Now, as we do not know the optimal solution to (MC), to estimate the performance of the (GW95) result we need to find a relation between the expectation find above and the optimal solution of the SDP program.       \n",
    "\n",
    "Now, let us denote $z_{mc}^*$ the optimal value of the Max-Cut, $z_{sdp}^*$ the optimal value of the relaxation.       \n",
    "If $A \\geq 0$, on average, the algorithm delivers a solution of value at least 0.88 times the optimal value.\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{qual_gw95}\n",
    "    \\mathbb{E}[GW95] > 0.87856 z_{sdp}^* > 0.87856 z_{mc}^*\n",
    "\\end{equation}        \n",
    "\n",
    "The intuition behind the constant 0.87856 comes from the comparison of the functions used along the way it is to say : $\\frac{1}{\\pi} \\arccos(x)$ and $\\frac{1 - x}{2}$. By plotting both function over $[-1, 1]$, Goemans and Williamson in \\[GW\\] notes that : $$ \\frac{1}{\\pi} \\arccos(x) > 0.87856 \\frac{1 - x}{2} $$\n",
    "The performance guarantee then derives from using this result in (MC) and the equality on the expectation above.\n",
    "\n",
    "\n",
    "**REFERENCE**    \n",
    "\n",
    "\\[GW\\] M.X. Goemans and D.P. Williamson. Improved approximation algorithms for maximum cut and satisfiability problems using semidefinite programming. Journal of the ACM, 42:1115–1145, 1995."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1tCWsU8AeGOV"
   },
   "source": [
    "## 3.2 Graph coloring\n",
    "### 3.2.1 SDP Relaxation - Chromatic number\n",
    "\n",
    "Let $G$ be a graph and $(V_1, \\dots, V_k)$ be a $k$-partition of its vertex set $V(G)$. We recall that a vertex set $V_i$ is stable if the vertices in $V_i$ are pairwise nonadjacent.      \n",
    "Now, a $k$-coloring of $G$ is such that each $V_i$ of the $k$-partition is stable.      \n",
    "\n",
    "With that in mind, we define the quantity of interest the chromatic number  : $\\chi(G)$ is the smallest value $k$ such that $G$ has a $k$-coloring.           \n",
    "\n",
    "Now using the idea we introduced in 1.1, let us model the $k$-partition of the vertex set by characteristic vectors $s_i \\in \\{ 0, 1 \\}^n$ where $(s_i)_u$ if $u \\in V_i$          \n",
    "\n",
    "We now, following the idea of 1.2, introduce the partition matrix \\eqref{eqn: pmat} associated to the $k$-partition $ (V_1, \\dots, V_k) $ :    \n",
    "\n",
    "\\begin{equation}\n",
    "\\tag{PMat}\n",
    "\\label{eqn: pmat}\n",
    "    M = \\sum_i s_i s_i^T\n",
    "\\end{equation}      \n",
    "\n",
    "Now, just as in 3.1.1, a way to model the objective $\\chi(G)$ is through the following result on $M$.       \n",
    "Let M be a symmetric $0, 1$ matrix, $M$ is a $k$-partition matrix if and only if :      \n",
    "\n",
    "$\\text{Diag}(M) = e$, $\\text{rank}(M) = k$ and $M \\succeq 0$        \n",
    "\n",
    "To get a sense of where this result is coming from, let us check that the partition matrix we introduced earlier is indeed satisfying the rank condition for example.       \n",
    "\n",
    "First, just looking at \\eqref{eqn: pmat} formula it is obvious that $M$ is a symmetric $0, 1$ matrix.           \n",
    "Now, we note that $s_i \\neq 0_{1\\times n}$ for any $V_i$ in the partition and that if $u \\in V_i$, $(s_{j \\neq i})_u = 0$, $M$ being derived from a $k$-partition giving us $\\text{rank}(M) = k$       \n",
    "\n",
    "Rest of the proof to get the equivalence is available in Rendl's paper.          \n",
    "\n",
    "Some other arguments that we are not reviewing here allows to refine the precedent equivalence result on $M$ and notably to get rid of the non-convex rank constraint and semidefiniteness of $M$. Instead, we now have :       \n",
    "let M be a symmetric $0, 1$ matrix, $M$ is a $k$-partition matrix if and only if :       \n",
    "\n",
    "$\\text{Diag}(M) = e$ and $\\left( tM - J \\succeq 0 \\iff t \\geq k \\right)$, where $J$ is the all-ones matrix                \n",
    "\n",
    "Using those two results, we now write our objective as the following SDP program:       \n",
    "\n",
    "\\begin{equation}\n",
    "    \\tag{$\\chi(G)$ SDP bin}\n",
    "    \\label{chrom_1}\n",
    "    \\chi(G) = \\min\\{ t : tM - J \\succeq 0; \\text{Diag}(M) = e; m_{ij} = 0, \\forall ij \\in E(G); m_{ij} \\in \\{ 0, 1 \\}\\}\n",
    "\\end{equation}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zrBE9bDM_vjN"
   },
   "source": [
    "### 3.2.2 Hyperplane rounding for Graph coloring\n",
    "\n",
    "As the hyperplane rounding algorithm used for Max-Cut we will now dive into an approach used for the graph-coloring problem.       \n",
    "The graph-coloring problem consists in assigning a color to each \\{ vertex, edge \\} of a graph such that no two adjacent \\{ vertices, edge \\} are of the same color.           \n",
    "\n",
    "This problem too is NP-hard and as such non trivial bounds for the number of colors are often hard to get let alone $\\chi(G)$. In 1983, Widgerson focused on the particular set-up of three-colorable graphs and ended up with an algorithm coloring any three-colorable graph on $n$ vertices with at most $3\\sqrt{n}$ .          \n",
    "\n",
    "The choice of three-colorable graphs was not haphazard. Indeed Widgerson used the two following facts : \n",
    "-  for any $v$ in $V(G)$ where $G$ is such that $\\chi(G) = 3$ then $N(v)$ is a bipartite graph therefore colorable with at most two colors (see \\[1\\])\n",
    "- if $G$ has a maximum vertex degree $\\Delta$ then $G$ can be colored in polynomial time with $\\Delta + 1$ colors\n",
    "\n",
    "We quickly recall that the neighbourhood $N(v)$ of a vertex $v \\in V(G)$ is the set of all vertices adjacent to $v$ and that the vertex degree $\\Delta$ of a vertex $v$ is the number of edges that are incident to $v$         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4ZTfuVI2e0Hy"
   },
   "outputs": [],
   "source": [
    "# Implementation of some basic functions related to graphs:\n",
    "\n",
    "def degres(A):\n",
    "    \"\"\"\n",
    "    return: the list of the degres of each vertex of the graph with adjacency matrix A\n",
    "    \"\"\"\n",
    "    return np.sum(1*(A!=0), axis=1)\n",
    "\n",
    "def degre_max(A):\n",
    "    \"\"\"\n",
    "    return: the vertex with maximum degre and the maximum degre\n",
    "    \"\"\"\n",
    "    return np.argmax(degres(A)), np.max(degres(A))\n",
    "\n",
    "def voisins(A, k):\n",
    "    \"\"\"\n",
    "    return: the neighbours of the vertex k for a graph with adjacency matrix A\n",
    "    \"\"\"\n",
    "    return [i for i in range(len(A)) if A[k][i]>0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "smS0e-9v_vjO"
   },
   "source": [
    "Those 2 facts in mind, Widgerson suggests to use the the property 1 stated above and to color the neighbourhood of a vertex of $G$ with only two colors. Furthermore, if the maximum vertex degree $\\Delta$ is such that $\\Delta > \\sqrt{n}$, then, abiding by the constraints of the problem, one can color at least $\\sqrt{n}$ vertices with only two colors.            \n",
    "The rest is backed by the second property stated above. The whole algorithm is now the following :      \n",
    "\n",
    "**Widgerson Algorithm for three-colorable graphs**\n",
    "\n",
    "*Input* \n",
    "- $G$ a graph on $n$ vertices such that $\\chi(G) = 3$     \n",
    "\n",
    "*Algorithm*\n",
    "- While there exists a vertex $v$ in $G$ with degree $\\Delta \\geq \\sqrt{n}$ : \n",
    "        - Color $v$ with color 1 and $N(v)$ with at most two new colors\n",
    "        - Remove $v$ and its neighbourhood from $G$ - new graph is still called $G$\n",
    "    \n",
    "- When all the remaining vertices are of degree $\\Delta < \\sqrt{n}$ color $G$ with at most $\\Delta$ colors    \n",
    "\n",
    "*Output* \n",
    "- A coloring of $G$ with at most $3\\sqrt{n}$ colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1foPUrpYrCnn"
   },
   "source": [
    "We will now implement this algorithm.    \n",
    "To verify the functioning of our coloring algorithms, we define a function that check that there are not any monochromatic egde:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EKtlIAcOv1_W"
   },
   "outputs": [],
   "source": [
    "def check_coloring(A, colors):\n",
    "    \"\"\"\n",
    "    Giving a graph and a coloring, check if the coloring is fine\n",
    "    (i.e. if there are not neighboors with same color)\n",
    "\n",
    "    A: matrice d'adjacence du graphe\n",
    "    colors: couleurs associées à chaque sommet\n",
    "\n",
    "    return: booléen indiquant si le coloring est correct (True) ou non (False)\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if A[i][j] > 0:\n",
    "                if colors[i]==colors[j]:\n",
    "                    return False\n",
    "\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yVOApElgrCno"
   },
   "source": [
    "The following simple function allow to color a 2-colorable graph with two colors. It will be helpful when defining the Widgerson algorithm later. Indeed, the subgraph of the neighbours of a vertex in a 3-colorable graph is a 2-colorable graph and we can use the following algorithm to 2-color it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8A2zmQWIHXB0"
   },
   "outputs": [],
   "source": [
    "def two_color(A, deux_couleurs=[1,2]):\n",
    "    \"\"\"\n",
    "    Color with two colors a 2-colorable graph\n",
    "\n",
    "    A: Adjacency matrix of the 2-colorable graph\n",
    "    deux_couleurs: list of two colors (ints) to use\n",
    "\n",
    "    return: coloring, i.e. list of the used colors for each vertex\n",
    "    and number of used colors (1 or 2)\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    nb_couleurs_utilisees = 1\n",
    "    couleurs = np.zeros(n)\n",
    "    sommet = 0\n",
    "    index_couleur = 0\n",
    "\n",
    "    while True:\n",
    "\n",
    "        couleurs[sommet] = deux_couleurs[index_couleur]\n",
    "\n",
    "        neighbours_to_be_colored = [i for i in range(n) if A[sommet][i]>0 and couleurs[i]==0]\n",
    "        if len(neighbours_to_be_colored) > 0:\n",
    "            sommet = neighbours_to_be_colored[0]\n",
    "            index_couleur = 1-index_couleur\n",
    "            nb_couleurs_utilisees = 2\n",
    "        elif np.any(couleurs==0):\n",
    "            sommet = np.argmax(couleurs==0)                   \n",
    "        else:\n",
    "            break\n",
    "\n",
    "    return couleurs, nb_couleurs_utilisees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "42X59jXZrCnq"
   },
   "source": [
    "Let G be a graph with maximum vertex degree $\\Delta$. Then G can be colored in polynomial time with $\\Delta+1$ colors. as stated above.  \n",
    "The following greedy algorithm make this lemma in practice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rfu44i61jO62"
   },
   "outputs": [],
   "source": [
    "def greedy_color(A, min_couleur=1):\n",
    "    \"\"\"\n",
    "    Color with at most degre_max+1 colors with a greedy method\n",
    "\n",
    "    A: Adjacency matrix of the graph to be colored\n",
    "    min_couleur: int of the first color to be used\n",
    "\n",
    "    return: coloring, list of the used colors for each vertex\n",
    "    starting with the color int min_couleur\n",
    "    with a greedy method (at most degre_max+1 colors)\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    sommet_max, degre_max_ = degre_max(A)\n",
    "    couleurs = np.zeros(n)\n",
    "    couleurs_possibles = list(range(min_couleur, min_couleur+degre_max_+1))\n",
    "\n",
    "    for sommet in range(n):\n",
    "        couleurs_voisins = set(couleurs[voisins(A, sommet)])\n",
    "        couleurs_possibles_sommet = [couleur for couleur in couleurs_possibles if (couleur not in couleurs_voisins)]\n",
    "        couleurs[sommet] = couleurs_possibles_sommet[0]\n",
    "                                     \n",
    "    return couleurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yyht1OfNrCnr"
   },
   "source": [
    "We can now define the Widgerson algorithm to color a 3-colorable graph with at most $3\\sqrt{n}$ colors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "A3wsvelmeNEk"
   },
   "outputs": [],
   "source": [
    "def wigderson(A):\n",
    "    \"\"\"\n",
    "    Color a 3-colorable graph with 3sqrt(n) colors\n",
    "    with the Wigderson algorithm\n",
    "\n",
    "    A: adjacency matrix of the 3-colorable graph\n",
    "\n",
    "    return: coloring, list of the colors (int) for each vertex\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    A_ = A.copy()\n",
    "\n",
    "    #colors for each vertex (0 means not colored)\n",
    "    couleur = 2\n",
    "    couleurs = np.zeros(n)\n",
    "\n",
    "    sommet_en_cours, degre_max_ = degre_max(A_)\n",
    "    \n",
    "    while degre_max_ >= np.sqrt(n):\n",
    "\n",
    "        #Color the considered vertex with color 1\n",
    "        couleurs[sommet_en_cours] = 1\n",
    "        \n",
    "        #Color its neighbours with two new colors\n",
    "        voisins_ = voisins(A_, sommet_en_cours)\n",
    "        couleurs[voisins_], nb_couleurs_utilisees = two_color(A_[voisins_,:][:,voisins_], deux_couleurs=[couleur+1, couleur+2])\n",
    "        couleur += nb_couleurs_utilisees\n",
    "\n",
    "        #reduce the graph (represented here with its adjacency matrix)\n",
    "        #by deleting the edges for the colored vertices (allow not to consider them anymore)\n",
    "        #and recompute the maximum degre and the vertex with max degre\n",
    "        sommets_a_garder = [i for i in range(n)]\n",
    "        A_[sommet_en_cours] = np.zeros(n)\n",
    "        for voisin in voisins_:\n",
    "            A_[voisin] = np.zeros(n)\n",
    "        sommet_en_cours, degre_max_ = degre_max(A_)\n",
    "\n",
    "    #color the last noncolored vertices with a greedy method\n",
    "    sommets_non_colores = np.argwhere(couleurs==0).flatten()\n",
    "    if len(sommets_non_colores)>0 :\n",
    "        couleurs[sommets_non_colores] = greedy_color(A_[sommets_non_colores, :][:, sommets_non_colores], min_couleur=couleur)\n",
    "\n",
    "    return couleurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J6PsQ3fdrCns"
   },
   "source": [
    "For instance, if we define a graph of four vertices forming a cycle, and we compute the coloring computed by the algorithms defined above, we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 247
    },
    "id": "5qJoz72MVfIp",
    "outputId": "fc940238-0d98-4818-ab59-46163962e504"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Adjacency matrix of a graph with 4 vertices forming a cycle\n",
    "A = np.array([[0,1,0,1],[1,0,1,0],[0,1,0,1],[1,0,1,0]])\n",
    "plt.figure(figsize=(3,3))\n",
    "draw_graph_from_np(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UBjhdGruVbTJ",
    "outputId": "b35a9189-8e60-4d04-bf0c-0adf8aaca7cf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_coloring(A, two_color(A)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gtJemxz6l6TZ",
    "outputId": "5b38a3b8-337a-4757-bb7e-c74f52af0b19"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_coloring(A, greedy_color(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CxdIZMMCevP7",
    "outputId": "e494fdc5-93e6-4590-bea6-a47824c70bcd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_coloring(A, wigderson(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xityl5GjrCnx"
   },
   "source": [
    "All these colorings are correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w7oJ1nWp4ym6"
   },
   "source": [
    "#### KMS method (Karger, 1998)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nyPT3SNl_vjX"
   },
   "source": [
    "The Widgerson algorithm we just saw does not make use of the relaxation we introduced in 3.2.2 but one improvement of the algorithm does so.      \n",
    "\n",
    "Starting back from $\\chi(G)$ SDP bin, we acknowledge that the $0, 1$ condition is not tractable and introduce a new form for $M$ that can be found in the Rendl article. From this new form emerges the famous Lovasz number $\\vartheta(G)$.      \n",
    "\n",
    "The Lovasz number has a lot of different uses and relations in various graph-related NP-hard problems like finding optimal stable sets and cliques.     \n",
    "Notably for the graph coloring problem $\\vartheta(G)$ is a lower bound on $\\chi(G)$      \n",
    "\n",
    "$\\vartheta(G)$ can be formulated as a semidefinite program and numerically approximated by the ellipsoid method in polynomial time in the number of vertices of G \\[2\\]\n",
    "\n",
    "\n",
    "One semidefinite program for $\\vartheta(G)$ is the following : \n",
    "\n",
    "\\begin{equation}\n",
    "\\tag{$\\vartheta(G)$ SDP}\n",
    "\\label{eqn: l_sdp}\n",
    "\\min\\{ \\lambda : V \\succeq 0, v_{ii} = 1 \\forall i, v_{ij} = \\lambda \\forall ij \\in E(G) \\}\n",
    "\\end{equation}      \n",
    "\n",
    "**REFERENCES**     \n",
    "\n",
    "- \\[1\\] Asratian, Armen S.; Denley, Tristan M. J.; Häggkvist, Roland (1998), Bipartite Graphs and their Applications, Cambridge Tracts in Mathematics, 131, Cambridge University Press, ISBN 9780521593458.\n",
    "\n",
    "- \\[2\\]Grötschel, Martin; Lovász, László; Schrijver, Alexander (1981), The ellipsoid method and its consequences in combinatorial optimization, Combinatorica, 1 (2): 169–197, doi:10.1007/BF02579273"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JT3q3gHi0qgi"
   },
   "source": [
    "We implement below this form of the SDP relaxation of the graph coloring problem with the CVXPY library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oyFHKY28l50V"
   },
   "outputs": [],
   "source": [
    "def solve_sdp_graph_coloring(A):\n",
    "    \"\"\"\n",
    "    Definition and solving of the SDP problem related to\n",
    "    the SDP relaxtion of graph coloring\n",
    "    (see the sdp form for lovasz number introduced above)\n",
    "    \n",
    "    A: square matrix, adjacency matrix of the graph\n",
    "    \n",
    "    return: square matrix X solution of the SDP problem\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    #build the matrices of the constraints\n",
    "    A_cont = []\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if A[i][j]>0:\n",
    "                A_cont_mat = np.zeros((n,n))\n",
    "                A_cont_mat[i][j] = 1\n",
    "                A_cont_mat = A_cont_mat.astype('float')\n",
    "                A_cont.append(A_cont_mat)\n",
    "\n",
    "    #define the SDP problem with CVXPY\n",
    "    X = cp.Variable((n,n), symmetric=True)\n",
    "    t = cp.Variable(1)\n",
    "    constraints = [X >> 0]\n",
    "    constraints += [\n",
    "        X[i][i] == 1. for i in range(n)\n",
    "    ]\n",
    "    constraints += [\n",
    "        cp.trace(A_cont[i] @ X) == t for i in range(len(A_cont))\n",
    "    ]\n",
    "\n",
    "    prob = cp.Problem(cp.Minimize(t), constraints)\n",
    "    prob.solve()\n",
    "\n",
    "    return X.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NwMUgb7orCn5"
   },
   "source": [
    "We will now use it in a refined algorithm.     \n",
    "\n",
    "As for the maxcut problem, we can adapt the hyperplane rounding idea to get a solution for the graph coloring problem from a solution $X$ of its SDP relaxation. It is what Karger, Motwani and Sudan proposed in 1998 adapting the idea of Goemans-Williamson.\n",
    "\n",
    "They proposed to generate $t$ random vectors on the unit sphere. The $t$ hyperplanes constructed from these vectors define $2^t$ regions. In a similar way to Goemans-Williamson algorithm, for a well-chosen $t$, if we apply identical color to the vectors $V_i$ that are in the same region, we get a semi-coloring with a high probability, i.e. there is a subgraph of size $(n/2)$ where there are not monochromatic edges.\n",
    "\n",
    "The KMS Algorithm combines this method with the Widgerson while-loop to get a coloring with $O(n^{0.387})$ colors.\n",
    "\n",
    "**KMS Algorithm for three-colorable graphs**\n",
    "\n",
    "*Input* \n",
    "- $G$ a graph on $n$ vertices such that $\\chi(G) = 3$     \n",
    "\n",
    "*Algorithm*\n",
    "- While there exists a vertex $v$ in $G$ with degree $\\Delta \\geq n^{0.613}$ : \n",
    "        - Color $v$ with color 1 and $N(v)$ with at most two new colors\n",
    "        - Remove $v$ and its neighbourhood from $G$ - new graph is still called $G$\n",
    "    \n",
    "- Then when the max degree $\\Delta < n^{0.613}$\n",
    "        - Compute the solution of the SDP relaxation of the problemwhile there exists a non-colored vertex\n",
    "        - while there are still vertices in the graph :\n",
    "        compute a semi-coloring from this solution with the hyperplane rounding method \n",
    "        and remove the colored vertices from the graph\n",
    "\n",
    "*Output* \n",
    "- A coloring of $G$ with at most $O(n^{0.387})$ colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "77amkaUx5F90"
   },
   "outputs": [],
   "source": [
    "def semi_coloring_with_hyperplane_rounding(A, V_, min_couleur=1, verbose=True):\n",
    "    \"\"\"\n",
    "    Semi-color the graph with colors\n",
    "    adaptating the hyperplane rounding method of GW\n",
    "\n",
    "    A: adjacency matrix nxn of the graph with n vertices\n",
    "    V: matrix nxn such as X=VtV\n",
    "    min_couleur : minimum int for the colors ints to be used\n",
    "\n",
    "    return: coloring, list of colors (ints) for each vertex\n",
    "    with zeros for the noncolored vertices\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    couleurs = np.zeros(n)\n",
    "    nb_used_colors = 0\n",
    "    sommet_max, degre_max_ = degre_max(A)\n",
    "\n",
    "    #if there are not any edge, we can return a vector with one color only\n",
    "    if degre_max_==0:\n",
    "        return np.ones(n)*min_couleur, 1\n",
    "\n",
    "    t = int(2 + np.log(degre_max_)/np.log(3))\n",
    "\n",
    "    while (couleurs>0).sum() < (n/2):\n",
    "\n",
    "        #generate t random vectors r on the unit sphere\n",
    "        r = np.random.normal(0,1,(t,len(V_)))\n",
    "        r = (r.T/np.linalg.norm(r, axis=1)).T\n",
    "        #compute the dot products rTvi of each r with each vi\n",
    "        rsTvis = np.dot(r, V_)\n",
    "\n",
    "        #get vectors with 1 or 0 if vi is in a side or the other of each hyperplan\n",
    "        vecteurs_hyperplans = rsTvis>=0\n",
    "        #then get some unique ids of color for each region defined by the hyperplanes defined by the random vectors r\n",
    "        #(put a number to each hyperplane and sum with this ponderation to get unique ids)\n",
    "        couleurs = (vecteurs_hyperplans.T*np.array(range(1,t+1))).sum(axis=1)\n",
    "\n",
    "        #delete one of the two vertices for each monochromatic edge\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                if A[i][j]>0:\n",
    "                    if couleurs[i]==couleurs[j]:\n",
    "                        couleurs[i] = 0\n",
    "\n",
    "    #reorganise the colors to get a consecutive sequence starting from min_couleur\n",
    "    colors_set = set(couleurs)\n",
    "    colors_set.discard(0)\n",
    "    nb_used_colors = len(colors_set)\n",
    "    old_colors_ints = list(colors_set)\n",
    "    new_colors_ints = list(range(min_couleur, min_couleur+nb_used_colors))\n",
    "    colors_transform = dict(zip(old_colors_ints, new_colors_ints))\n",
    "    colors_transform[0] = 0\n",
    "    couleurs = [colors_transform[couleur] for couleur in couleurs]\n",
    "\n",
    "    return couleurs, nb_used_colors\n",
    "\n",
    "\n",
    "def kms(A, verbose=True):\n",
    "    \"\"\"\n",
    "    Color the graph with O(n^0.387) colors\n",
    "    running the algorithm proposed by KMS\n",
    "\n",
    "    A: adjacency matrix of the 3-colorable graph\n",
    "\n",
    "    return: coloring, list of colors (ints) for each vertex\n",
    "    \"\"\"\n",
    "    n = len(A)\n",
    "    A_ = A.copy()\n",
    "\n",
    "    #colors for each vertex (0 means not colored)\n",
    "    couleur = 1\n",
    "    couleurs = np.zeros(n)\n",
    "\n",
    "    sommet_en_cours, degre_max_ = degre_max(A_)\n",
    "    \n",
    "    #Run the loop of the Wigderson algorithm\n",
    "    #while the max degre of non colored vertices is superior to n^0.613\n",
    "    while degre_max_ >= n**0.613:\n",
    "\n",
    "        #Color the considered vertex with a new color\n",
    "        couleurs[sommet_en_cours] = 1\n",
    "        \n",
    "        #Color the neighbours with two new colors\n",
    "        voisins_ = voisins(A_, sommet_en_cours)\n",
    "        couleurs[voisins_], nb_couleurs_utilisees = two_color(A_[voisins_,:][:,voisins_], deux_couleurs=[couleur+1, couleur+2])\n",
    "        couleur += nb_couleurs_utilisees\n",
    "\n",
    "        #reduce the graph (represented here with its adjacency matrix)\n",
    "        #by deleting the edges for the colored vertices (allow not to consider them anymore)\n",
    "        #and recompute the maximum degre and the vertex with max degre\n",
    "        sommets_a_garder = [i for i in range(n)]\n",
    "        A_[sommet_en_cours] = np.zeros(n)\n",
    "        for voisin in voisins_:\n",
    "            A_[voisin] = np.zeros(n)\n",
    "        sommet_en_cours, degre_max_ = degre_max(A_)\n",
    "\n",
    "    if verbose:\n",
    "        print(\"End of the Widgerson loop ; current coloring :\")\n",
    "        print(couleurs)\n",
    "\n",
    "    #Then use the SDP relaxation for the remaining graph...\n",
    "    sommets_non_colores = np.argwhere(couleurs==0).flatten()\n",
    "    if len(sommets_non_colores)>0 :\n",
    "        A_sous_graphe = A_[sommets_non_colores, :][:, sommets_non_colores]\n",
    "\n",
    "        X = solve_sdp_graph_coloring(A_sous_graphe)\n",
    "    \n",
    "        #...and the hyperplane rounding idea to get the colors from the solution\n",
    "        V_ = V(X) #Cholesky factorisation defined above in the notebook\n",
    "\n",
    "        #repeat the hyperplane rounding idea to get semicoloring until having colored the whole graph\n",
    "        while len(sommets_non_colores)>0:\n",
    "            A_non_colores = A_[sommets_non_colores, :][:, sommets_non_colores]\n",
    "            V_non_colores = ((V_.T)[sommets_non_colores]).T\n",
    "            couleurs[sommets_non_colores], nb_couleurs_utilisees = semi_coloring_with_hyperplane_rounding(A_non_colores, V_non_colores, min_couleur=couleur)\n",
    "            couleur += nb_couleurs_utilisees\n",
    "            sommets_non_colores = np.argwhere(couleurs==0).flatten()\n",
    "            if verbose:\n",
    "                print(\"New semicoloring added via hyperplane rounding ; current coloring :\")\n",
    "                print(couleurs)\n",
    "\n",
    "    return couleurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ouk7WpXigXkv"
   },
   "source": [
    "We can do a first test of the KMS algorithm with the very simple graph with 4 vertices forming a cycle we used above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SWW6a3UGnRwE",
    "outputId": "56c70312-4be8-4de8-865f-588d48608ef0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of the Widgerson loop ; current coloring :\n",
      "[0. 0. 0. 0.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[2. 1. 2. 1.]\n",
      "coloring : [2. 1. 2. 1.]\n",
      "The KMS algo is here correct.\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0,1,0,1],[1,0,1,0],[0,1,0,1],[1,0,1,0]])\n",
    "coloring = kms(A)\n",
    "print(\"coloring : {}\".format(coloring))\n",
    "print(\"The KMS algo is here \" + \"correct.\" if check_coloring(A, coloring) else \"not correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "k2KnVGDCFocb"
   },
   "source": [
    "We define a function to draw the graph and visualize the coloring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3A6KpgOfFkqd"
   },
   "outputs": [],
   "source": [
    "def draw_graph_with_coloring(G, coloring):\n",
    "    \"\"\"\n",
    "    draw graph G (networkx graph) with the colors defined in coloring (list of ints)\n",
    "    \"\"\"\n",
    "    pos = nx.spring_layout(G)\n",
    "    colors = ['red','blue','green','yellow','purple', 'orange', \"black\", \"grey\", \"white\", \"magenta\"]\n",
    "    for i in range(len(coloring)):\n",
    "        nx.draw_networkx_nodes(G, pos, [x for x in G.nodes() if coloring[x]==i], node_color=colors[i])\n",
    "    nx.draw_networkx_edges(G, pos)\n",
    "    plt.axis(\"off\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 248
    },
    "id": "EFPJnrd-F79A",
    "outputId": "8dd1784f-8d91-43a4-a62a-a111930e2685"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_graph_with_coloring(nx.from_numpy_array(A), coloring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x_xUS7aXrCn7"
   },
   "source": [
    "We can also test with a graph of 9 vertices forming a cycle, because it is also 3-colorable (but not 2-colorable):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3J3zles_gOPi",
    "outputId": "7b3bb81c-aa48-476f-a0c6-53520959fb90"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of the Widgerson loop ; current coloring :\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[2. 0. 2. 0. 2. 0. 2. 1. 0.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[2. 3. 2. 3. 2. 3. 2. 1. 3.]\n",
      "coloring : [2. 3. 2. 3. 2. 3. 2. 1. 3.]\n",
      "The KMS algo is here correct.\n"
     ]
    }
   ],
   "source": [
    "#adjacency matrix of a graph with n vertices forming a cycle\n",
    "n = 9\n",
    "A = np.zeros((n,n))\n",
    "for i in range(len(A)-1):\n",
    "    A[i][i+1] = 1\n",
    "    A[i+1][i] = 1\n",
    "A[-1][0] = 1\n",
    "A[0][-1] = 1\n",
    "coloring = kms(A)\n",
    "print(\"coloring : {}\".format(coloring))\n",
    "print(\"The KMS algo is here \" + \"correct.\" if check_coloring(A, coloring) else \"not correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 248
    },
    "id": "TYnzS_amGMik",
    "outputId": "8c408ae6-bdea-4a83-edfc-e72d110aaca4"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_graph_with_coloring(nx.from_numpy_array(A), coloring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p7XVn9cQkhOA",
    "outputId": "c603c728-a6f3-4c2a-ea2c-2c7bcb484314"
   },
   "source": [
    "We cannot use a graph with any random adjacency matrix because the graph has to be 3-colorable to make the KMS algorithm valid ; thus we chose to test here with the Petersen graph (https://en.wikipedia.org/wiki/Petersen_graph) that has 10 vertices and 15 edges and that is known to be 3-colorable :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5_ni0llQ0mc8",
    "outputId": "afac5789-9336-4709-d909-0f1624a613e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of the Widgerson loop ; current coloring :\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[1. 3. 2. 0. 4. 0. 2. 0. 4. 3.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[1. 3. 2. 5. 4. 0. 2. 5. 4. 3.]\n",
      "New semicoloring added via hyperplane rounding ; current coloring :\n",
      "[1. 3. 2. 5. 4. 6. 2. 5. 4. 3.]\n",
      "coloring : [1. 3. 2. 5. 4. 6. 2. 5. 4. 3.]\n",
      "The KMS algo is here correct.\n"
     ]
    }
   ],
   "source": [
    "petersen = nx.petersen_graph()\n",
    "A_petersen = np.array(nx.adjacency_matrix(petersen).todense())\n",
    "coloring = kms(A_petersen)\n",
    "print(\"coloring : {}\".format(coloring))\n",
    "print(\"The KMS algo is here \" + \"correct.\" if check_coloring(A_petersen, coloring) else \"not correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 248
    },
    "id": "IMlqpGu_FcIr",
    "outputId": "48877756-d09a-4a0b-d1a1-23e60fad2b16"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_graph_with_coloring(petersen, coloring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9ScoTWkI7Pun"
   },
   "source": [
    "# 4  Interior Points methods for SDP programming and more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9mbDNu8Y6Voi"
   },
   "source": [
    "# 4. Solving SDP in practice\n",
    "\n",
    "Now that we have seen different SDP relaxations, we explore some methods to efficiently solve SDP programs.\n",
    "\n",
    "## 4.1 Interior Point algorithms\n",
    "\n",
    "From Chapter 5 in class we saw that barrier methods which are iterating inside the polytope of constraints are very efficient to solve SDP programs.      \n",
    "\n",
    "Inspired by the demonstration page 20 in Chapter 5, we recall the primal and dual problems introduced in section 2.     \n",
    "\n",
    "\\begin{equation}\n",
    "    \\tag{P}\n",
    "    \\label{primal_5}\n",
    "    \\begin{split}\n",
    "    &\\min \\langle C, X \\rangle \\\\\n",
    "    &\\text{ such that } A(X) = b, X \\succeq 0\n",
    "    \\end{split}\n",
    "\\end{equation} \n",
    "\n",
    "\\begin{equation}\n",
    "    \\tag{D}\n",
    "    \\label{dual_5}\n",
    "    \\begin{split}\n",
    "    &\\max b^T y \\\\\n",
    "    &\\text{ such that } Z = C - A^T(y) \\succeq 0\n",
    "    \\end{split}\n",
    "\\end{equation}\n",
    "where the linear operator $A$ has been introduced in section 2      \n",
    "\n",
    "Looking back to section 2, under the *Slater's* condition we acknowledge that $(X, y, Z)$ is optimal when $Z = C - A^T(y) \\succeq 0, A(X) = b, ZX - \\mu I = 0$ and $\\langle Z, X \\rangle = 0$ this last condition being a consequence of the strong duality discussed $0 = z_p - z_d = \\langle Z, X \\rangle$        \n",
    "\n",
    "From there, the primal-dual interior points method is derived from the convex optimization problem called the primal barrier problem where a logarithmic barrier controlled by a parameter $\\mu$ is added to (Primal).      \n",
    "\n",
    "The constraints are then the following :      \n",
    "\n",
    "\\begin{equation}\n",
    "    \\tag{PD$_{\\mu}$}\n",
    "    \\label{cond_pdp}\n",
    "    Z = C - A^T(y) \\succeq 0, A(X) = b, ZX - \\mu I = 0\n",
    "\\end{equation}       \n",
    "\n",
    "Whole details of the procedure to get \\eqref{cond_pdp} can be found in Rendl's paper.        \n",
    "\n",
    "We acknowledge that there is an equivalence between (Primal) and (Dual) having stricly feasible points and \\eqref{cond_pdp} having a unique solution $(X_{\\mu}, y_{\\mu}, Z_{\\mu}), \\forall \\mu > 0$          \n",
    "\n",
    "Now that we have this new program, let us recall the concept of barrier methods is to solve a sequence \\eqref{cond_pdp} for different decreasing values of $\\mu$ and use this sequence of results as an approximation to a solution of the initial program.       \n",
    "The idea is to solve a finite number of \\eqref{cond_pdp} for a decreasing sequence $\\mu_k$ and use the last solution $\\mu_{k_{\\text{last}}}$ as an approximation to the initial problem.        \n",
    "The intuition behind using only the last step is linked to the instability of Newton's method, a slightly different initialization point can yield a very different sequence of results.     \n",
    "\n",
    "The set of solutions obtained $CP := \\{P_{\\mu} = (X_{\\mu}, y_{\\mu}, Z_{\\mu}) : \\mu > 0 \\}$ defines a smooth curve, describing a path on the set of constraints. $CP$ is called the *central path*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m3cxS2Amm4Ne"
   },
   "source": [
    "To compute SDP programming, we firstly define some utilitaries functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XJRiTAZXMXDf"
   },
   "outputs": [],
   "source": [
    "def is_sdp(X):\n",
    "    return np.all(np.linalg.eigvals(X) >= 0)\n",
    "\n",
    "def proj_sdp(X):\n",
    "    A = (X + X.T)/2\n",
    "    eigvals, eigvecs = np.linalg.eig(A)\n",
    "    eigvals[eigvals < 0] = 0\n",
    "\n",
    "    return eigvecs.dot(np.diag(eigvals)).dot(eigvecs.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b3Hqb4rmm-jJ"
   },
   "source": [
    "We now define an implementation of SDP programming solver - for the maxcut SDP relaxation problem more precisely here - through primal-dual path following Interior points method. The initial values of X, y, Z are chosen to be on the primal-dual path. At each iteration we firstly get the directions of descent as described in the article, and then we applied factors $\\alpha_p$ and $\\alpha_d$ to those directions in order to ensure the new matrices X and Z are semidefinite positive. We also update the value of $\\mu$. The loop stops when the updates of X become low."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ySnlxEcA-zLJ"
   },
   "outputs": [],
   "source": [
    "def sdp_maxcut_interior_points(L, rho=0.5, nb_iterations=10, verbose=False):\n",
    "    \"\"\"\n",
    "    Solve SDP programming with primal-dual path following interior points method\n",
    "    for the SDP relaxation of the maxcut problem\n",
    "\n",
    "    L: Laplacian of the ajacency matrix, parameter in the function to minimize Tr(LXt)\n",
    "    rho: paramètre d'échelle dans la méthode des points intérieurs (entre 0 et 1)\n",
    "\n",
    "    return: X, solution of the SDP problem\n",
    "    \"\"\"\n",
    "    n = len(L)\n",
    "    b = np.ones(n)*(1/4)\n",
    "    #initial values of variables (see HVW97)\n",
    "    X = np.eye(n)*(1/4)\n",
    "    y = np.sum(np.abs(L), axis=1)*1.1\n",
    "    Z = L - np.diag(y)\n",
    "    mu = -np.trace(np.dot(X,Z))\n",
    "    #mu = 0\n",
    "    iteration = 0\n",
    "    delta_X_mean = np.inf\n",
    "\n",
    "    while (iteration<nb_iterations) and delta_X_mean>10**-7:\n",
    "        iteration += 1\n",
    "        if verbose:\n",
    "            print(\"---------------------iteration : {}\".format(iteration))\n",
    "            print(\"X : {}\".format(X))\n",
    "            print(\"eigval X : {}\".format(np.linalg.eigvals(X)))\n",
    "            print(\"obj : {}\".format(np.trace(np.dot(L, X.T))))\n",
    "            print(\"mu {}\".format(mu))\n",
    "\n",
    "        Z_inv = np.linalg.inv(Z)\n",
    "        Z_inv = (Z_inv+Z_inv.T)/2\n",
    "        r_p = b - np.diag(X) # (42) in Rendl article\n",
    "        r_d = L - np.diag(y) - Z # (43) in Rendl article\n",
    "        v = r_p - np.diag(mu*Z_inv - X) + np.diag(np.dot(Z_inv, np.dot(r_d, X)))\n",
    "        #v = - np.diag(mu*Z_inv - X)\n",
    "        #v = - np.diag(mu*Z_inv) - b\n",
    "        M = X*Z_inv\n",
    "        #M = -X*Z_inv\n",
    "\n",
    "        delta_y = np.linalg.solve(M, v) #(45) in Rendl article\n",
    "        #delta_y = np.linalg.solve(M, mu*np.diag(Z_inv) - np.ones(n))\n",
    "        delta_Z = r_d - np.diag(delta_y)\n",
    "        #delta_Z =  -np.diag(delta_y)\n",
    "        delta_X = mu*Z_inv - X - np.dot(Z_inv, np.dot(delta_Z, X))\n",
    "        delta_X = (delta_X + delta_X.T)/2\n",
    "        delta_Z = (delta_Z + delta_Z.T)/2\n",
    "\n",
    "        #find alpha_p such as X+alpha_p*delta_X is SDP\n",
    "        alpha_p = 1\n",
    "        while not(is_sdp(X + alpha_p*delta_X)):\n",
    "            alpha_p *= 0.8\n",
    "        \n",
    "        #find alpha_d such as Z+alpha_d*delta_Z is SDP\n",
    "        alpha_d = 1\n",
    "        while not(is_sdp(-(Z + alpha_d*delta_Z))):\n",
    "            alpha_d *= 0.8\n",
    "\n",
    "        #To get DP\n",
    "        if alpha_p < 1:\n",
    "            alpha_p = 0.95*alpha_p\n",
    "        if alpha_d < 1:\n",
    "            alpha_d = 0.95*alpha_d\n",
    "\n",
    "        #update X, y and Z following the primal-dual path\n",
    "        X += alpha_p*delta_X\n",
    "        y += alpha_d*delta_y\n",
    "        Z += alpha_d*delta_Z\n",
    "\n",
    "        if verbose:\n",
    "            print(\"alpha_p : {}\".format(alpha_p))\n",
    "            print(\"alpha_d : {}\".format(alpha_d))\n",
    "            print(\"delta_X : {}\".format(delta_X))\n",
    "            print(\"delta_y : {}\".format(delta_y))\n",
    "            print(\"delta_Z : {}\".format(delta_Z))\n",
    "            print(\"r_d : {}\".format(r_d))\n",
    "            print(\"r_p : {}\".format(r_p))\n",
    "        \n",
    "        mu = -(1/n)*np.trace(np.dot(X,Z))\n",
    "        #mu = rho*mu\n",
    "\n",
    "        delta_X_mean = alpha_p*np.abs(delta_X).mean()\n",
    "\n",
    "    return X*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ihPSNpI8pAYR"
   },
   "source": [
    "We can firstly test the function with simple adjacency matrices and compare it to the results of CVXPY library :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LguZx6_MStL1",
    "outputId": "a90727fd-d81b-4565-eb1e-b68ad14a0dac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The function get the solution :\n",
      "[[ 1.         -0.99999987]\n",
      " [-0.99999987  1.        ]]\n",
      "The CVXPY library get the solution :\n",
      "[[ 1. -1.]\n",
      " [-1.  1.]]\n",
      "The function get the objective value : 3.999999739014581\n",
      "The CVXPY library get the objective value : 3.9999999999998264\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0,1],[1,0]])\n",
    "L = Laplacien(A)\n",
    "X = sdp_maxcut_interior_points(L, nb_iterations=10)\n",
    "X_cvxpy = solve_sdp_maxcut(L)\n",
    "print(\"The function get the solution :\")\n",
    "print(X)\n",
    "print(\"The CVXPY library get the solution :\")\n",
    "print(X_cvxpy)\n",
    "print(\"The function get the objective value : {}\".format(np.trace(np.dot(L, X.T))))\n",
    "print(\"The CVXPY library get the objective value : {}\".format(np.trace(np.dot(L, X_cvxpy.T))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "n-4hc2gUl3OD",
    "outputId": "6ff54f26-24d9-413a-ad3d-02ecbaa0b41d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The function get the solution :\n",
      "[[ 1.         -0.99995229  0.96522052]\n",
      " [-0.99995229  1.         -0.9677266 ]\n",
      " [ 0.96522052 -0.9677266   1.        ]]\n",
      "The CVXPY library get the solution :\n",
      "[[ 0.99998973 -1.00013297  1.00006328]\n",
      " [-1.00013297  1.00001997 -0.99999553]\n",
      " [ 1.00006328 -0.99999553  0.99997757]]\n",
      "The function get the objective value : 11.870810971099008\n",
      "The CVXPY library get the objective value : 12.000252828564445\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0,1,0],[1,0,2],[0,2,0]])\n",
    "L = Laplacien(A)\n",
    "X = sdp_maxcut_interior_points(L, nb_iterations=10)\n",
    "X_cvxpy = solve_sdp_maxcut(L)\n",
    "print(\"The function get the solution :\")\n",
    "print(X)\n",
    "print(\"The CVXPY library get the solution :\")\n",
    "print(X_cvxpy)\n",
    "print(\"The function get the objective value : {}\".format(np.trace(np.dot(L, X.T))))\n",
    "print(\"The CVXPY library get the objective value : {}\".format(np.trace(np.dot(L, X_cvxpy.T))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6RRrUxGJktgS"
   },
   "source": [
    "We will now test the time of the interior points method with different size of graphs n. To do this, we generate random adjacency matrix of size n:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fb-ntNRUhOdM"
   },
   "outputs": [],
   "source": [
    "def generate_random_adj_matrix(n):\n",
    "    \"\"\"\n",
    "    Generate a random adjacency matrix of size n\n",
    "    \"\"\"  \n",
    "    A = (np.random.randn(n, n)>0.1)*1\n",
    "    #delete the weighs of the edges between a same vertex\n",
    "    for i in range(len(A)):\n",
    "        A[i][i] = 0\n",
    "    #make the matrix symetric\n",
    "    for i in range(len(A)):\n",
    "        for j in range(i,len(A)):\n",
    "            A[i][j] = A[j][i]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "2vfawoYMhnvL"
   },
   "outputs": [],
   "source": [
    "n_s = [20,50,100,200,300,400,500]\n",
    "times = []\n",
    "\n",
    "for n in n_s:\n",
    "    A = generate_random_adj_matrix(n)\n",
    "    L = Laplacien(A)\n",
    "    t0 = time.time()\n",
    "    X = sdp_maxcut_interior_points(L, nb_iterations=10)\n",
    "    t1 = time.time()\n",
    "    times.append(t1-t0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b2Eq9U6poQ-s"
   },
   "source": [
    "We can plot the times of the method for increasing n and see an exponential dynamic that make the Interior Points method impractical for a large n and for a large number of constraints. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "id": "lEbwhEFdjurr",
    "outputId": "9895affa-7848-490f-8ee7-bd310d3a21e5"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(n_s, times)\n",
    "plt.xlabel(\"size n of the graph\")\n",
    "plt.ylabel(\"time to compute the SDP relaxation\")\n",
    "plt.title(\"Time performances of Interior Points Method for SDP problem\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e9rBFt6LfSr7"
   },
   "source": [
    "## 4.2 Extensions and future work\n",
    "\n",
    "Implementations showed that a limitation to the use of interior point methods was the dimension of the matrix space and the number of constraints.      \n",
    "\n",
    "A few methods can bypass the dimension-related difficulties encountered by the interior point methods.      \n",
    "\n",
    "When the matrix space is of reasonable dimension but the number of constraints is very large, one general idea for example is to separate the set of constraints in two different sets. One set is considered to be manageable with the interior points methods and the second set - supposedly making things too complicated - is added to the objective function through a partial Lagrangian.      \n",
    "\n",
    "Now, using traditional techniques we end solving an SDP over the first set of constraints we kept. This is supposed to be doable with the interior point methods for example.     \n",
    "\n",
    "We acknowledge that the solution found here can be linked to the subgradient of a function of the partial Lagrangian introduced above.     \n",
    "\n",
    "The function there is convex but is not differentiable at some points therefore minimizing this function will make use of non smooth optimization techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "compressed_sensing_9.ipynb",
   "provenance": []
  },
  "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}