code.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jzbPJ6LnmLk6"
      },
      "source": [
        "# Optimizing Game Theory Algorithms for Graph-Based Games"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nq1dn_GBJ8sb"
      },
      "source": [
        "## Import sources and graph creation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xIF2HEJPJdR9"
      },
      "outputs": [],
      "source": [
        "import networkx as nx\n",
        "import numpy as np\n",
        "from random import random, randint, uniform\n",
        "import time\n",
        "from math import factorial\n",
        "from itertools import combinations\n",
        "import matplotlib.pyplot as plt\n",
        "from typing import List\n",
        "from itertools import permutations\n",
        "import networkx.algorithms.approximation.treewidth as tw\n",
        "import random"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gc8255AbTCwo"
      },
      "outputs": [],
      "source": [
        "# @title execution parameters\n",
        "# these 4 variables determine what points will be executed.\n",
        "# You can choose whatever you prefer\n",
        "POINT_1 = True\n",
        "POINT_2 = True\n",
        "POINT_3 = True\n",
        "POINT_4 = True\n",
        "\n",
        "#set this to true for running experiments, false otherwise\n",
        "EXPERIMENTS = True\n",
        "\n",
        "#set this to true if you want to use the prepared blocks for testing the sol.\n",
        "SINGLE_BENCHMARK = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k0EUYX4BJ6NQ",
        "outputId": "d9d3b4ab-cb52-4bee-8aab-0c8193f5a015"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Nodes: ['s', 't', '1', '2', '3', '4']\n",
            "Edges: [('s', '1'), ('s', '2'), ('t', '3'), ('t', '4'), ('1', '3'), ('1', '4'), ('2', '4')]\n"
          ]
        }
      ],
      "source": [
        "\n",
        "G=nx.Graph()\n",
        "nodes = ['s', 't', '1', '2', '3', '4']\n",
        "edges = [('s', '1'), ('s', '2'), ('1', '3'), ('1', '4'), #('3','4'),('3','2'),\n",
        "         ('2', '4'), ('3', 't'), ('4', 't')]\n",
        "G.add_nodes_from(nodes)\n",
        "G.add_edges_from(edges)\n",
        "\n",
        "print(f\"Nodes: {G.nodes()}\")\n",
        "print(f\"Edges: {G.edges()}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RIKvBxkL-Gvz"
      },
      "outputs": [],
      "source": [
        "# @title Random graph generator\n",
        "# generates a random graph starting from the fixed parameters in innput.\n",
        "# Used in all the assignments for both correctness checking and benchmarking\n",
        "def generate_random_graph_from_parameters(num_nodes: int, edge_density: float,\n",
        "                                          outcoming_edges_from_s: int,\n",
        "                                          incoming_edges_on_t: int):\n",
        "  min_node_name = 1\n",
        "  nodes = [str(x) for x in range(min_node_name,num_nodes+1)]\n",
        "  nodes.append('s')\n",
        "  nodes.append('t')\n",
        "  G=nx.Graph()\n",
        "  G.add_nodes_from(nodes)\n",
        "  #print(f\"adding nodes to graph: {nodes}\")\n",
        "  # add a number of edges according to density where density is a float\n",
        "  # between 0 and 1 which. A graph with density 0 is a graph without edges,\n",
        "  # a graph with density 1 is a graph with n(n-1)/2 eges when edges = num_nodes\n",
        "  max_num_edges = (num_nodes*(num_nodes -1))/2\n",
        "  #print(f\"Max num edges: {max_num_edges}\")\n",
        "  for i in range(int(max_num_edges * edge_density)):\n",
        "    # guess two nodes and add the edge\n",
        "    # if edge was already added guess again -I want the exact num of edges in G\n",
        "    u = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    v = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    edge = (u, v)\n",
        "    while G.has_edge(edge[0], edge[1]) or edge[0] == edge[1]:\n",
        "      u = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "      v = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "      edge = (u, v)\n",
        "    G.add_edge(edge[0], edge[1])\n",
        "    #print(f\"Adding edge {edge[0]}, {edge[1]}\")\n",
        "\n",
        "  for i in range(outcoming_edges_from_s):\n",
        "    v = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    while G.has_edge('s', v):\n",
        "      v = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    G.add_edge('s', v)\n",
        "    #print(f\"Adding edge from s towards {v}\")\n",
        "\n",
        "  for i in range(incoming_edges_on_t):\n",
        "    u  = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    while G.has_edge(u, 't'):\n",
        "      u = nodes[randint(min_node_name-1,num_nodes-1)]\n",
        "    G.add_edge(u, 't')\n",
        "    #print(f\"Adding edge toward t from {u}\")\n",
        "  return G\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xmzhsu8lUzVg"
      },
      "outputs": [],
      "source": [
        "# @title Materialized powerset\n",
        "def powerset(List):\n",
        "    subs = [frozenset(j) for i in range(len(List)) for j in combinations(List, i+1)]\n",
        "    subs += [frozenset()]\n",
        "    return subs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L0e--LjS_Y01"
      },
      "outputs": [],
      "source": [
        "# @title Generation example\n",
        "\n",
        "# num_nodes = randint(10, 15)\n",
        "# density = random.uniform(0.1, 1.0)\n",
        "# print(f\"Generating node with num nodes: {num_nodes} and density: {density}\")\n",
        "# #TODO these names are not appropriate\n",
        "# edges_outcoming_from_s = randint(2, 3)\n",
        "# edges_incoming_on_t = randint(2, 3)\n",
        "# G = generate_random_graph_from_parameters(num_nodes, density, 2, 2)\n",
        "# print(f\"The graph contains {len(list(G.neighbors('s')))} edges from s and {len(list(G.neighbors('t')))} edges from t\")\n",
        "# print(f\"The graph has: {len(list(G.nodes()))} nodes and {len(list(G.edges()))} edges\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "Gzv0zTfQ5Ksa",
        "outputId": "95958f09-7ade-481f-9dc6-0cd3b88d2541"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Graph plot\n",
        "nx.draw(G, with_labels = True, font_weight='bold', node_size = 500, node_color = 'red')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "82uF5hgeL2kb"
      },
      "source": [
        "# Assignment 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xi3MhDSONGcE"
      },
      "source": [
        "Assume that forming a path connecting s and t lead to a reward of 100$. Then,compute the Shapley value associated with the agents in {1,2,……,n} as a fair way to distribute that reward among the agents in {1,2,……, n}, which in particular encourages cooperation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U6ZxM31OUIOz"
      },
      "outputs": [],
      "source": [
        "# @title compute characteristic function for graph G\n",
        "if POINT_1:\n",
        "  def compute_characteristic_function(G, naive: bool):\n",
        "    characteristic_function: dict = {}\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "    all_coalitions = powerset(all_nodes)\n",
        "    # for every coalition, modify the graph such that\n",
        "    # it contains only the nodes and the edges in such coalitions\n",
        "    # and assign a value to CF according to the path formation\n",
        "    for coalition in all_coalitions:\n",
        "      removed_nodes = []\n",
        "      for node in all_nodes:\n",
        "        if node not in coalition:\n",
        "          removed_nodes.append(node)\n",
        "\n",
        "      removed_edges = list(G.edges(removed_nodes))\n",
        "      G.remove_nodes_from(removed_nodes)\n",
        "      #check that a path s-t exists in the subgraph\n",
        "      #made of the nodes in the subset and the edges\n",
        "      #incident to such nodes\n",
        "      if nx.has_path(G, 's', 't'):\n",
        "        characteristic_function[coalition] = 100\n",
        "      else:\n",
        "        if naive:\n",
        "          characteristic_function[coalition] = 0\n",
        "      G.add_nodes_from(removed_nodes)\n",
        "      for e in removed_edges:\n",
        "        G.add_edge(e[0], e[1])\n",
        "    return characteristic_function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T_2jF9SIB75X"
      },
      "outputs": [],
      "source": [
        "# @title characteristic function from the example\n",
        "if POINT_1:\n",
        "  characteristic_function: dict = {frozenset(): 0, frozenset({\"1\"}): 0, frozenset({\"2\"}): 0, frozenset({\"3\"}): 0, frozenset({\"4\"}): 0,\n",
        "                                  frozenset({\"1\", \"2\"}): 0, frozenset({\"1\", \"3\"}): 100, frozenset({\"1\", \"4\"}): 100,\n",
        "                                  frozenset({\"2\", \"3\"}): 0, frozenset({\"2\", \"4\"}): 100, frozenset({\"3\", \"4\"}): 0,\n",
        "                                  frozenset({\"1\", \"2\", \"4\"}): 100, frozenset({\"1\", \"3\", \"4\"}): 100, frozenset({\"2\", \"3\", \"1\"}): 100,\n",
        "                                  frozenset({\"2\", \"3\", \"4\"}): 100, frozenset({\"1\", \"2\", \"3\", \"4\"}): 100}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6vKbR5ruBiQi"
      },
      "outputs": [],
      "source": [
        "# @title Shapley value with optimized characteristic function\n",
        "if POINT_1:\n",
        "  def shapley_value(player, characteristic_function):\n",
        "      player = frozenset([player])\n",
        "      player_list = max(characteristic_function)\n",
        "      N = len(player_list)\n",
        "      shapley_val = 0\n",
        "      for coalition in characteristic_function:\n",
        "          S = len(coalition)\n",
        "          if S == 0:\n",
        "            continue\n",
        "          coalition_without_player = coalition - player\n",
        "          marginal_contribution = 0\n",
        "          if coalition_without_player not in characteristic_function:\n",
        "              marginal_contribution = 100\n",
        "\n",
        "          shapley_val += ((factorial(N - S) * factorial(S - 1)) / factorial(N)) * marginal_contribution\n",
        "      return round(shapley_val, 10)\n",
        "\n",
        "  def shapley(characteristic_function, all_nodes):\n",
        "      return {player: shapley_value(player, characteristic_function) for player in list(all_nodes)}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TdR5EhJESXYd"
      },
      "outputs": [],
      "source": [
        "# @title Shapley value with standard characteristic from lab solutions\n",
        "if POINT_1:\n",
        "  # We now implement the Shapley value for a given player, using the second equation\n",
        "  def shapley_value_lab(player, characteristic_function):\n",
        "      player_list = max(characteristic_function)\n",
        "      player = set([player])\n",
        "      N = len(player_list)\n",
        "      coalitions = powerset(player_list)\n",
        "      shapley_val = 0\n",
        "      for coalition in coalitions:\n",
        "          S = len(coalition)\n",
        "          if S == 0:\n",
        "            continue\n",
        "          marginal_contribution = characteristic_function[coalition] - (characteristic_function[coalition - player] if len(coalition - player) > 0 else 0)\n",
        "          shapley_val += ((factorial(N - S) * factorial(S - 1)) / factorial(N)) * marginal_contribution\n",
        "      return round(shapley_val, 10)\n",
        "\n",
        "  # This function returns a dictionary with the Shapley value for each player\n",
        "  def shapley_lab(characteristic_function):\n",
        "      # To get the grand coalition from the characteristic function, we can use the function max\n",
        "      return {player: shapley_value_lab(player, characteristic_function) for player in max(characteristic_function)}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-1AtVXvo_va0"
      },
      "outputs": [],
      "source": [
        "# @title compare shapley value result with tolerance\n",
        "if POINT_1:\n",
        "  def compare_dictionaries(dict1, dict2, tolerance=0):\n",
        "      if set(dict1.keys()) != set(dict2.keys()):\n",
        "          return False\n",
        "\n",
        "      for key in dict1:\n",
        "          if isinstance(dict1[key], int) and isinstance(dict2[key], int):\n",
        "              if abs(dict1[key] - dict2[key]) > tolerance:\n",
        "                  return False\n",
        "          elif dict1[key] != dict2[key]:\n",
        "              return False\n",
        "\n",
        "      return True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "A9-OwWaADfLJ"
      },
      "outputs": [],
      "source": [
        "# @title Inappropriate benchmarking\n",
        "if POINT_1:\n",
        "  import random\n",
        "  def make_comparison(num_comparisons: int):\n",
        "    smart_solved_instances_times = []\n",
        "    naive_solved_instances_times = []\n",
        "\n",
        "    for i in range(num_comparisons):\n",
        "      # create a random graph with fixed parameters\n",
        "      num_nodes = randint(13, 18)\n",
        "      density = random.uniform(0.1, 0.5)\n",
        "      # TODO these names are not appropriate\n",
        "      # add edges of the type {s, n} and {n, t} in the graph\n",
        "      # (these { indicate the set repr. of edges\n",
        "      # which is more appropriate in undirected graphs)\n",
        "      edges_outcoming_from_s = randint(2, 3)\n",
        "      edges_incoming_on_t = randint(2, 3)\n",
        "      print(f\"Generating node with num nodes: {num_nodes} and density: {density}\")\n",
        "      G = generate_random_graph_from_parameters(num_nodes, density, edges_outcoming_from_s, edges_incoming_on_t)\n",
        "      all_nodes = list(G.nodes())\n",
        "      all_nodes.remove('s')\n",
        "      all_nodes.remove('t')\n",
        "      characteristic_function_smart = compute_characteristic_function(G, False)\n",
        "      start_time = time.time()\n",
        "      shapley_values_smart = shapley(characteristic_function_smart, all_nodes)\n",
        "      end_time = time.time()\n",
        "      print(shapley_values_smart)\n",
        "      smart_solved_instance_time = end_time-start_time\n",
        "      print(f\"Smart computation took {smart_solved_instance_time}\")\n",
        "\n",
        "      characteristic_function_naive = compute_characteristic_function(G, True)\n",
        "      start_time = time.time()\n",
        "      shapley_values_naive = shapley_lab(characteristic_function_naive)\n",
        "      end_time = time.time()\n",
        "      print(shapley_values_naive)\n",
        "      naive_solved_instance_time = end_time-start_time\n",
        "      print(f\"Naive computation took {naive_solved_instance_time}\")\n",
        "\n",
        "      if not compare_dictionaries(shapley_values_smart, shapley_values_naive, tolerance = 0.0001):\n",
        "        print(\"ERROR: Shapley values for the two implementations do not coincide\")\n",
        "        #for debugging purposes\n",
        "        #return G\n",
        "      else:\n",
        "        smart_solved_instances_times.append(smart_solved_instance_time)\n",
        "        naive_solved_instances_times.append(naive_solved_instance_time)\n",
        "\n",
        "    print(\"ALL DONE! No errors found\")\n",
        "    return (smart_solved_instances_times, naive_solved_instances_times)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rnHvLyCAPgal",
        "outputId": "02ddf676-9b27-4ad9-d50e-89a26f5e1d72"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Generating node with num nodes: 16 and density: 0.3224014262526028\n",
            "{'1': 0.0, '2': 0.2572427572, '3': 0.1598401598, '4': 0.2752802753, '5': 17.4975024975, '6': 0.0083250083, '7': 2.5588300588, '8': 0.2608502609, '9': 2.1403596404, '10': 6.3683538684, '11': 0.3932178932, '12': 61.9635919636, '13': 4.7594072594, '14': 0.1237651238, '15': 3.035020535, '16': 0.1984126984}\n",
            "Smart computation took 1.0215845108032227\n",
            "{'3': 0.1598401598, '11': 0.3932178932, '14': 0.1237651238, '2': 0.2572427572, '7': 2.5588300588, '8': 0.2608502609, '13': 4.7594072594, '15': 3.035020535, '10': 6.3683538684, '12': 61.9635919636, '5': 17.4975024975, '1': 0.0, '16': 0.1984126984, '4': 0.2752802753, '9': 2.1403596404, '6': 0.0083250083}\n",
            "Naive computation took 6.033766269683838\n",
            "Generating node with num nodes: 18 and density: 0.4723765052586498\n",
            "{'1': 0.0045787546, '2': 0.327034077, '3': 0.327034077, '4': 0.0650738151, '5': 15.3592241092, '6': 0.0295537796, '7': 0.0745088245, '8': 0.327034077, '9': 0.0295537796, '10': 0.111000111, '11': 15.3592241092, '12': 66.9937007438, '13': 0.0, '14': 0.1921689422, '15': 0.327034077, '16': 0.0717338217, '17': 0.327034077, '18': 0.0745088245}\n",
            "Smart computation took 6.345836877822876\n",
            "{'3': 0.327034077, '11': 15.3592241092, '14': 0.1921689422, '2': 0.327034077, '7': 0.0745088245, '17': 0.327034077, '8': 0.327034077, '13': 0.0, '15': 0.327034077, '10': 0.111000111, '12': 66.9937007438, '5': 15.3592241092, '1': 0.0045787546, '16': 0.0717338217, '18': 0.0745088245, '4': 0.0650738151, '9': 0.0295537796, '6': 0.0295537796}\n",
            "Naive computation took 32.650038719177246\n",
            "Generating node with num nodes: 14 and density: 0.29314291750623106\n",
            "{'1': 11.0714285714, '2': 0.3571428571, '3': 2.0238095238, '4': 17.0238095238, '5': 0.0, '6': 0.0, '7': 33.6904761905, '8': 10.3571428571, '9': 0.0, '10': 0.0, '11': 0.0, '12': 2.7380952381, '13': 0.0, '14': 22.7380952381}\n",
            "Smart computation took 0.20572781562805176\n",
            "{'3': 2.0238095238, '11': 0.0, '14': 22.7380952381, '2': 0.3571428571, '7': 33.6904761905, '8': 10.3571428571, '13': 0.0, '10': 0.0, '12': 2.7380952381, '5': 0.0, '1': 11.0714285714, '4': 17.0238095238, '9': 0.0, '6': 0.0}\n",
            "Naive computation took 0.9626204967498779\n",
            "Generating node with num nodes: 13 and density: 0.1406993401280644\n",
            "{'1': 0.0, '2': 0.0, '3': 2.380952381, '4': 0.0, '5': 0.0, '6': 2.380952381, '7': 27.380952381, '8': 0.0, '9': 27.380952381, '10': 0.0, '11': 2.380952381, '12': 27.380952381, '13': 10.7142857143}\n",
            "Smart computation took 0.008071660995483398\n",
            "{'3': 2.380952381, '11': 2.380952381, '2': 0.0, '7': 27.380952381, '8': 0.0, '13': 10.7142857143, '10': 0.0, '12': 27.380952381, '5': 0.0, '1': 0.0, '4': 0.0, '9': 27.380952381, '6': 2.380952381}\n",
            "Naive computation took 0.3547673225402832\n",
            "Generating node with num nodes: 13 and density: 0.40246721752995307\n",
            "{'1': 1.5512265512, '2': 0.1226551227, '3': 14.8845598846, '4': 0.7142857143, '5': 0.8369408369, '6': 11.1940836941, '7': 1.1544011544, '8': 0.1623376623, '9': 48.2178932179, '10': 12.1067821068, '11': 0.0, '12': 9.0115440115, '13': 0.0432900433}\n",
            "Smart computation took 0.0952296257019043\n",
            "{'3': 14.8845598846, '11': 0.0, '2': 0.1226551227, '7': 1.1544011544, '8': 0.1623376623, '13': 0.0432900433, '10': 12.1067821068, '12': 9.0115440115, '5': 0.8369408369, '1': 1.5512265512, '4': 0.7142857143, '9': 48.2178932179, '6': 11.1940836941}\n",
            "Naive computation took 0.4836606979370117\n",
            "Generating node with num nodes: 16 and density: 0.2987437969497704\n",
            "{'1': 6.2803862804, '2': 0.0277500278, '3': 10.2125652126, '4': 8.0624930625, '5': 2.5394050394, '6': 1.3561438561, '7': 0.4625929626, '8': 0.1598401598, '9': 0.337995338, '10': 15.0011100011, '11': 7.4636474636, '12': 0.5960705961, '13': 19.3287268287, '14': 0.897990898, '15': 20.2533577534, '16': 7.0199245199}\n",
            "Smart computation took 0.7325842380523682\n",
            "{'3': 10.2125652126, '11': 7.4636474636, '14': 0.897990898, '2': 0.0277500278, '7': 0.4625929626, '8': 0.1598401598, '13': 19.3287268287, '15': 20.2533577534, '10': 15.0011100011, '12': 0.5960705961, '5': 2.5394050394, '1': 6.2803862804, '16': 7.0199245199, '4': 8.0624930625, '9': 0.337995338, '6': 1.3561438561}\n",
            "Naive computation took 6.79136848449707\n",
            "Generating node with num nodes: 16 and density: 0.33707249059240674\n",
            "{'1': 10.9632034632, '2': 1.3997113997, '3': 0.5266955267, '4': 0.6854256854, '5': 0.0865800866, '6': 5.0901875902, '7': 0.0, '8': 3.3802308802, '9': 1.1616161616, '10': 25.5266955267, '11': 18.4235209235, '12': 25.5266955267, '13': 7.0238095238, '14': 0.0, '15': 0.2056277056, '16': 0.0}\n",
            "Smart computation took 0.8951437473297119\n",
            "{'3': 0.5266955267, '11': 18.4235209235, '14': 0.0, '2': 1.3997113997, '7': 0.0, '8': 3.3802308802, '13': 7.0238095238, '15': 0.2056277056, '10': 25.5266955267, '12': 25.5266955267, '5': 0.0865800866, '1': 10.9632034632, '16': 0.0, '4': 0.6854256854, '9': 1.1616161616, '6': 5.0901875902}\n",
            "Naive computation took 6.5347325801849365\n",
            "Generating node with num nodes: 17 and density: 0.33467921984552806\n",
            "{'1': 0.0, '2': 0.0, '3': 0.0, '4': 0.0, '5': 0.0, '6': 0.0, '7': 0.0, '8': 50.0, '9': 0.0, '10': 0.0, '11': 50.0, '12': 0.0, '13': 0.0, '14': 0.0, '15': 0.0, '16': 0.0, '17': 0.0}\n",
            "Smart computation took 2.7919259071350098\n",
            "{'3': 0.0, '11': 50.0, '14': 0.0, '2': 0.0, '7': 0.0, '17': 0.0, '8': 50.0, '13': 0.0, '15': 0.0, '10': 0.0, '12': 0.0, '5': 0.0, '1': 0.0, '16': 0.0, '4': 0.0, '9': 0.0, '6': 0.0}\n",
            "Naive computation took 15.298795938491821\n",
            "Generating node with num nodes: 18 and density: 0.42031554110410807\n",
            "{'1': 0.586480513, '2': 0.8618995384, '3': 0.0290803967, '4': 15.2389114154, '5': 10.8872908138, '6': 0.6944281209, '7': 0.1476138241, '8': 0.1388725653, '9': 24.9448998714, '10': 31.9055780821, '11': 0.030508707, '12': 0.1360975626, '13': 0.0524883613, '14': 12.0668057433, '15': 0.030508707, '16': 1.3103399868, '17': 0.0971087736, '18': 0.8410870176}\n",
            "Smart computation took 5.5023956298828125\n",
            "{'3': 0.0290803967, '11': 0.030508707, '14': 12.0668057433, '2': 0.8618995384, '7': 0.1476138241, '17': 0.0971087736, '8': 0.1388725653, '13': 0.0524883613, '15': 0.030508707, '10': 31.9055780821, '12': 0.1360975626, '5': 10.8872908138, '1': 0.586480513, '16': 1.3103399868, '18': 0.8410870176, '4': 15.2389114154, '9': 24.9448998714, '6': 0.6944281209}\n",
            "Naive computation took 32.48573875427246\n",
            "Generating node with num nodes: 14 and density: 0.22052759048230983\n",
            "{'1': 5.7142857143, '2': 0.0, '3': 1.3095238095, '4': 0.0, '5': 21.6666666667, '6': 1.6666666667, '7': 0.0, '8': 17.380952381, '9': 6.4285714286, '10': 14.4047619048, '11': 0.0, '12': 19.7619047619, '13': 11.6666666667, '14': 0.0}\n",
            "Smart computation took 0.21270298957824707\n",
            "{'3': 1.3095238095, '11': 0.0, '14': 0.0, '2': 0.0, '7': 0.0, '8': 17.380952381, '13': 11.6666666667, '10': 14.4047619048, '12': 19.7619047619, '5': 21.6666666667, '1': 5.7142857143, '4': 0.0, '9': 6.4285714286, '6': 1.6666666667}\n",
            "Naive computation took 1.0582830905914307\n",
            "Generating node with num nodes: 16 and density: 0.20956078508929782\n",
            "{'1': 0.0, '2': 0.0, '3': 0.0, '4': 0.0, '5': 0.0, '6': 0.0, '7': 0.0, '8': 0.0, '9': 0.0, '10': 0.0, '11': 0.0, '12': 0.0, '13': 0.0, '14': 100.0000000001, '15': 0.0, '16': 0.0}\n",
            "Smart computation took 0.8249757289886475\n",
            "{'3': 0.0, '11': 0.0, '14': 100.0000000001, '2': 0.0, '7': 0.0, '8': 0.0, '13': 0.0, '15': 0.0, '10': 0.0, '12': 0.0, '5': 0.0, '1': 0.0, '16': 0.0, '4': 0.0, '9': 0.0, '6': 0.0}\n",
            "Naive computation took 6.652807235717773\n",
            "Generating node with num nodes: 14 and density: 0.47488915263541953\n",
            "{'1': 59.4866244866, '2': 0.053002553, '3': 0.337995338, '4': 0.0782550783, '5': 0.439005439, '6': 0.5580530581, '7': 0.2947052947, '8': 22.0443445443, '9': 9.4866244866, '10': 5.3776778777, '11': 0.3957153957, '12': 0.0, '13': 0.2947052947, '14': 1.1532911533}\n",
            "Smart computation took 0.18706488609313965\n",
            "{'3': 0.337995338, '11': 0.3957153957, '14': 1.1532911533, '2': 0.053002553, '7': 0.2947052947, '8': 22.0443445443, '13': 0.2947052947, '10': 5.3776778777, '12': 0.0, '5': 0.439005439, '1': 59.4866244866, '4': 0.0782550783, '9': 9.4866244866, '6': 0.5580530581}\n",
            "Naive computation took 1.170830488204956\n",
            "Generating node with num nodes: 14 and density: 0.28581641722951345\n",
            "{'1': 7.380952381, '2': 4.0476190476, '3': 0.0, '4': 0.0, '5': 2.380952381, '6': 0.0, '7': 15.7142857143, '8': 64.0476190476, '9': 2.380952381, '10': 0.0, '11': 0.0, '12': 4.0476190476, '13': 0.0, '14': 0.0}\n",
            "Smart computation took 0.20894908905029297\n",
            "{'3': 0.0, '11': 0.0, '14': 0.0, '2': 4.0476190476, '7': 15.7142857143, '8': 64.0476190476, '13': 0.0, '10': 0.0, '12': 4.0476190476, '5': 2.380952381, '1': 7.380952381, '4': 0.0, '9': 2.380952381, '6': 0.0}\n",
            "Naive computation took 1.2384212017059326\n",
            "Generating node with num nodes: 15 and density: 0.12462303339786157\n",
            "{'1': 3.7265512266, '2': 0.0, '3': 3.7265512266, '4': 3.7265512266, '5': 6.7027417027, '6': 1.2698412698, '7': 6.9408369408, '8': 28.5281385281, '9': 3.7265512266, '10': 0.0, '11': 3.7265512266, '12': 27.2582972583, '13': 6.9408369408, '14': 0.0, '15': 3.7265512266}\n",
            "Smart computation took 0.22661662101745605\n",
            "{'3': 3.7265512266, '11': 3.7265512266, '14': 0.0, '2': 0.0, '7': 6.9408369408, '8': 28.5281385281, '13': 6.9408369408, '15': 3.7265512266, '10': 0.0, '12': 27.2582972583, '5': 6.7027417027, '1': 3.7265512266, '4': 3.7265512266, '9': 3.7265512266, '6': 1.2698412698}\n",
            "Naive computation took 2.7986154556274414\n",
            "Generating node with num nodes: 17 and density: 0.12490488167364618\n",
            "{'1': 5.0, '2': 0.0, '3': 0.0, '4': 0.0, '5': 0.0, '6': 0.0, '7': 0.0, '8': 0.0, '9': 0.0, '10': 0.0, '11': 5.0, '12': 5.0, '13': 80.0, '14': 0.0, '15': 5.0, '16': 0.0, '17': 0.0}\n",
            "Smart computation took 1.8309333324432373\n",
            "{'3': 0.0, '11': 5.0, '14': 0.0, '2': 0.0, '7': 0.0, '17': 0.0, '8': 0.0, '13': 80.0, '15': 5.0, '10': 0.0, '12': 5.0, '5': 0.0, '1': 5.0, '16': 0.0, '4': 0.0, '9': 0.0, '6': 0.0}\n",
            "Naive computation took 15.594739437103271\n",
            "Generating node with num nodes: 14 and density: 0.21989265597820518\n",
            "{'1': 13.7698412698, '2': 0.0, '3': 26.8253968254, '4': 4.7619047619, '5': 13.0555555556, '6': 0.6746031746, '7': 0.6746031746, '8': 4.4841269841, '9': 1.746031746, '10': 0.6746031746, '11': 26.1507936508, '12': 0.3571428571, '13': 0.0, '14': 6.8253968254}\n",
            "Smart computation took 0.1281595230102539\n",
            "{'3': 26.8253968254, '11': 26.1507936508, '14': 6.8253968254, '2': 0.0, '7': 0.6746031746, '8': 4.4841269841, '13': 0.0, '10': 0.6746031746, '12': 0.3571428571, '5': 13.0555555556, '1': 13.7698412698, '4': 4.7619047619, '9': 1.746031746, '6': 0.6746031746}\n",
            "Naive computation took 1.1526033878326416\n",
            "Generating node with num nodes: 18 and density: 0.26054086300754087\n",
            "{'1': 7.195027195, '2': 12.6454101454, '3': 0.0, '4': 0.341047841, '5': 6.9533244533, '6': 12.5785325785, '7': 51.1663336664, '8': 0.0, '9': 0.7384282384, '10': 3.6807636808, '11': 0.2242202242, '12': 0.2561327561, '13': 0.7345432345, '14': 0.0685425685, '15': 1.6641691642, '16': 1.186036186, '17': 0.5272505273, '18': 0.0402375402}\n",
            "Smart computation took 5.194499492645264\n",
            "{'3': 0.0, '11': 0.2242202242, '14': 0.0685425685, '2': 12.6454101454, '7': 51.1663336664, '17': 0.5272505273, '8': 0.0, '13': 0.7345432345, '15': 1.6641691642, '10': 3.6807636808, '12': 0.2561327561, '5': 6.9533244533, '1': 7.195027195, '16': 1.186036186, '18': 0.0402375402, '4': 0.341047841, '9': 0.7384282384, '6': 12.5785325785}\n",
            "Naive computation took 31.57453155517578\n",
            "Generating node with num nodes: 17 and density: 0.15992895834365678\n",
            "{'1': 0.753968254, '2': 1.4213564214, '3': 0.0, '4': 22.0634920635, '5': 1.8073593074, '6': 0.6565656566, '7': 0.6565656566, '8': 27.5396825397, '9': 0.0, '10': 0.6757131757, '11': 0.5436230436, '12': 14.733044733, '13': 18.1060606061, '14': 0.0, '15': 5.6385281385, '16': 0.8874458874, '17': 4.5165945166}\n",
            "Smart computation took 1.6317517757415771\n",
            "{'3': 0.0, '11': 0.5436230436, '14': 0.0, '2': 1.4213564214, '7': 0.6565656566, '17': 4.5165945166, '8': 27.5396825397, '13': 18.1060606061, '15': 5.6385281385, '10': 0.6757131757, '12': 14.733044733, '5': 1.8073593074, '1': 0.753968254, '16': 0.8874458874, '4': 22.0634920635, '9': 0.0, '6': 0.6565656566}\n",
            "Naive computation took 14.746970415115356\n",
            "Generating node with num nodes: 18 and density: 0.20143571955057624\n",
            "{'1': 0.0, '2': 55.0, '3': 0.0, '4': 0.0, '5': 5.0, '6': 0.0, '7': 0.0, '8': 0.0, '9': 0.0, '10': 0.0, '11': 5.0, '12': 0.0, '13': 0.0, '14': 5.0, '15': 0.0, '16': 0.0, '17': 30.0, '18': 0.0}\n",
            "Smart computation took 2.011986494064331\n",
            "{'3': 0.0, '11': 5.0, '14': 5.0, '2': 55.0, '7': 0.0, '17': 30.0, '8': 0.0, '13': 0.0, '15': 0.0, '10': 0.0, '12': 0.0, '5': 5.0, '1': 0.0, '16': 0.0, '18': 0.0, '4': 0.0, '9': 0.0, '6': 0.0}\n",
            "Naive computation took 33.49140810966492\n",
            "Generating node with num nodes: 14 and density: 0.3854221313575402\n",
            "{'1': 0.670995671, '2': 1.3852813853, '3': 0.670995671, '4': 8.7265512266, '5': 0.0757575758, '6': 0.670995671, '7': 0.0757575758, '8': 4.1233766234, '9': 0.0, '10': 18.7265512266, '11': 0.7142857143, '12': 61.3852813853, '13': 2.7741702742, '14': 0.0}\n",
            "Smart computation took 0.23338675498962402\n",
            "{'3': 0.670995671, '11': 0.7142857143, '14': 0.0, '2': 1.3852813853, '7': 0.0757575758, '8': 4.1233766234, '13': 2.7741702742, '10': 18.7265512266, '12': 61.3852813853, '5': 0.0757575758, '1': 0.670995671, '4': 8.7265512266, '9': 0.0, '6': 0.670995671}\n",
            "Naive computation took 0.960740327835083\n",
            "ALL DONE! No errors found\n"
          ]
        }
      ],
      "source": [
        "if POINT_1 and EXPERIMENTS:\n",
        "  num_comparisons = 20\n",
        "  results = make_comparison(num_comparisons)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kALVqVZAWT9p"
      },
      "outputs": [],
      "source": [
        "# @title Block for checking solution after submission\n",
        "# TODO just define your graph here and remove all comments\n",
        "# if POINT_1 and SINGLE_BENCHMARK:\n",
        "  # G=nx.Graph()\n",
        "  # nodes = ['s', 't', '1', '2', '3', '4']\n",
        "  # edges = [('s', '1'), ('s', '2'), ('1', '3'), ('1', '4'), #('3','4'),('3','2'),\n",
        "  #         ('2', '4'), ('3', 't'), ('4', 't')]\n",
        "  # G.add_nodes_from(nodes)\n",
        "  # G.add_edges_from(edges)\n",
        "\n",
        "  # print(f\"Nodes: {G.nodes()}\")\n",
        "  # print(f\"Edges: {G.edges()}\")\n",
        "\n",
        "  # characteristic_function_smart = compute_characteristic_function(G, False)\n",
        "  # start_time = time.time()\n",
        "  # shapley_values_smart = shapley(characteristic_function_smart)\n",
        "  # end_time = time.time()\n",
        "  # print(shapley_values_smart)\n",
        "  # smart_solved_instance_time = end_time-start_time\n",
        "  # print(f\"Smart computation took {smart_solved_instance_time}\")\n",
        "\n",
        "  # characteristic_function_naive = compute_characteristic_function(G, True)\n",
        "  # start_time = time.time()\n",
        "  # shapley_values_naive = shapley_lab(characteristic_function_naive)\n",
        "  # end_time = time.time()\n",
        "  # print(shapley_values_naive)\n",
        "  # naive_solved_instance_time = end_time-start_time\n",
        "  # print(f\"Naive computation took {naive_solved_instance_time}\")\n",
        "\n",
        "  # if not compare_dictionaries(shapley_values_smart, shapley_values_naive, tolerance = 0.0001):\n",
        "  #   print(\"ERROR: Shapley values for the two implementations do not coincide\")\n",
        "  # else:\n",
        "  #   print(\"ALL DONE! No errors found\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "id": "oqwxoKWHNAT-",
        "outputId": "7bdad2e1-cb8f-4f37-9592-dc2d1a6efd85"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1.5144763350486756\n",
            "10.601771998405457\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Cactus plot of results\n",
        "from statistics import mean\n",
        "if POINT_1 and EXPERIMENTS:\n",
        "  x_smart = results[0]\n",
        "  y = [i for i in range(num_comparisons)]\n",
        "\n",
        "  x_naive = results[1]\n",
        "\n",
        "  x_smart.sort()\n",
        "  x_naive.sort()\n",
        "\n",
        "  print(mean(x_smart))\n",
        "  print(mean(x_naive))\n",
        "\n",
        "  plt.plot(y, x_naive, marker='o', linestyle='-', label='naive version')\n",
        "  plt.plot(y, x_smart,  marker='x', linestyle='-', label='smart version')\n",
        "\n",
        "  plt.ylabel('Solved instances')\n",
        "  plt.xlabel('time')\n",
        "  plt.title('Shapley values')\n",
        "\n",
        "  plt.legend()\n",
        "\n",
        "  plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uL6JFyTJgayV"
      },
      "outputs": [],
      "source": [
        "# @title Check that the two created characteristic function represent the same thing\n",
        "if POINT_1:\n",
        "  # the naive and smart characteristic function should have the same meaning\n",
        "  def check_characteristic_functions(characteristic_function, characteristic_function_1):\n",
        "    for coalition in characteristic_function.keys():\n",
        "\n",
        "      if coalition in characteristic_function_1:\n",
        "        if 100 != characteristic_function_1[coalition]:\n",
        "          #print(\"Error\")\n",
        "          return False\n",
        "      else:\n",
        "        if characteristic_function[coalition] != 0:\n",
        "          #print(\"Error\")\n",
        "          return False\n",
        "    return True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nGUcOyR0ZgY8"
      },
      "source": [
        "# Assignment 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8TW_5xZ1W7Tz"
      },
      "outputs": [],
      "source": [
        "# @title Compute always cooperating players as the players with <=2 neighbours\n",
        "if POINT_2:\n",
        "  # nodes with less than 3 neighbours are always cooperating\n",
        "  def compute_always_cooperating_players(G):\n",
        "    always_cooperating_players = []\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "\n",
        "    source_and_destination = ['s', 't']\n",
        "    removed_edges = list(G.edges(source_and_destination))\n",
        "    G.remove_nodes_from(source_and_destination)\n",
        "\n",
        "    nodes_to_degree = dict(G.degree())\n",
        "    for node in all_nodes:\n",
        "      if nodes_to_degree[node] <= 2:\n",
        "        always_cooperating_players.append(node)\n",
        "\n",
        "    G.add_nodes_from(source_and_destination)\n",
        "    for e in removed_edges:\n",
        "      G.add_edge(e[0], e[1])\n",
        "    return always_cooperating_players"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CTrwnqjnrB4W"
      },
      "outputs": [],
      "source": [
        "# @title compute payoffs for players in G\n",
        "if POINT_2:\n",
        "  def compute_payoffs(G, always_cooperating_players, naive: bool):\n",
        "    payoffs: dict = {}\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "    all_strategy_profiles = powerset(all_nodes)\n",
        "\n",
        "    all_nodes_int = [int(node) for node in all_nodes]\n",
        "    all_nodes_int.sort()\n",
        "\n",
        "    for strategy_profile in all_strategy_profiles:\n",
        "      # do not compute payoffs for stategies in which always\n",
        "      # cooperating players are defecting because these will never be equilibria\n",
        "      # Or better: they may be equlibria, but so will be also the strategy in\n",
        "      # which such player is cooperating instead of defecting. Therefore we can\n",
        "      # remove these kind of strategies without loss of soundness or\n",
        "      # completeness for the proposed task\n",
        "      if not naive:\n",
        "        skip_strategy = False\n",
        "        for player in always_cooperating_players:\n",
        "          if player not in strategy_profile:\n",
        "            skip_strategy = True\n",
        "            break\n",
        "\n",
        "        if len(strategy_profile) == 0 and len(always_cooperating_players) > 0:\n",
        "          skip_strategy = True\n",
        "\n",
        "        if skip_strategy:\n",
        "          continue\n",
        "\n",
        "      removed_nodes = []\n",
        "      #if coalition not in characteristic function\n",
        "      for node in all_nodes:\n",
        "\n",
        "        if node not in strategy_profile:\n",
        "          removed_nodes.append(node)\n",
        "\n",
        "      removed_edges = list(G.edges(removed_nodes))\n",
        "      G.remove_nodes_from(removed_nodes)\n",
        "      #check that a path s-t exists in the subgraph\n",
        "      #made of the nodes in the subset and the edges\n",
        "      #incident to such nodes\n",
        "\n",
        "      payoffs[strategy_profile] = []\n",
        "      if nx.has_path(G, 's', 't'):\n",
        "        #set 1 for players that have not more than 2 neighbours cooperating\n",
        "        # -1 otherwise\n",
        "        for player in all_nodes_int:\n",
        "          player = str(player)\n",
        "          if player in strategy_profile:\n",
        "            neigh_cooperating = list(G.neighbors(player))\n",
        "            num_neigh_cooperating = len(neigh_cooperating)\n",
        "            #s and t are not considered in the count\n",
        "            if 's' in neigh_cooperating:\n",
        "              num_neigh_cooperating -= 1\n",
        "            if 't' in neigh_cooperating:\n",
        "              num_neigh_cooperating -= 1\n",
        "\n",
        "            #print(\"WE\", len(list(G.neighbors(player))))\n",
        "            #constraint violated\n",
        "            if num_neigh_cooperating > 2:\n",
        "              payoffs[strategy_profile].append(-1)\n",
        "            #cooperation and path forms\n",
        "            else:\n",
        "              payoffs[strategy_profile].append(1)\n",
        "            #no cooperation but path forms\n",
        "          else:\n",
        "            payoffs[strategy_profile].append(-0.5)\n",
        "        #for all players in the game\n",
        "      else:\n",
        "        for player in all_nodes_int:\n",
        "          # no path but cooperating\n",
        "          #payoffs[strategy_profile].append(-1)\n",
        "          player = str(player)\n",
        "          if player in strategy_profile:\n",
        "            neigh_cooperating = list(G.neighbors(player))\n",
        "            num_neigh_cooperating = len(neigh_cooperating)\n",
        "            #s and t are not considered in the count\n",
        "            if 's' in neigh_cooperating:\n",
        "              num_neigh_cooperating -= 1\n",
        "            if 't' in neigh_cooperating:\n",
        "              num_neigh_cooperating -= 1\n",
        "            if num_neigh_cooperating > 2:\n",
        "              payoffs[strategy_profile].append(-1)\n",
        "            else:\n",
        "              payoffs[strategy_profile].append(0)\n",
        "          # # no path and defecting\n",
        "          else:\n",
        "            payoffs[strategy_profile].append(-0.5)\n",
        "      G.add_nodes_from(removed_nodes)\n",
        "      for e in removed_edges:\n",
        "        G.add_edge(e[0], e[1])\n",
        "    #payoffs[frozenset()] = [-0.5 for i in range(len(list(G.nodes())))]\n",
        "    return payoffs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1eFAi7H50OEY"
      },
      "outputs": [],
      "source": [
        "# @title compute Nash Equilibrium - Naive approach\n",
        "if POINT_2:\n",
        "  def compute_nash_equilibrium_naive(G, payoffs, all_strategy_profiles, return_all=False):\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "    all_equilibria = []\n",
        "    for strategy_profile in all_strategy_profiles:\n",
        "      best_strategy = True\n",
        "      for player in all_nodes:\n",
        "        player_set = frozenset([player])\n",
        "        if player in strategy_profile:\n",
        "          changed_strategy = strategy_profile - player_set\n",
        "        else:\n",
        "          changed_strategy = strategy_profile.union(player_set)\n",
        "\n",
        "        if payoffs[changed_strategy][int(player)-1] > payoffs[strategy_profile][int(player)-1]:\n",
        "          best_strategy = False\n",
        "          break\n",
        "      #profile is not best strategy for some player and hence it cannot be an eq.\n",
        "      #if no player stopped the inner for (for every player the profile was\n",
        "      # a best response), then profile is an equilibrium\n",
        "      if best_strategy:\n",
        "        if not return_all:\n",
        "          return (True, strategy_profile)\n",
        "        else:\n",
        "          all_equilibria.append(strategy_profile)\n",
        "    return (len(all_equilibria) > 0, all_equilibria)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-5cSO3WvWl-M"
      },
      "outputs": [],
      "source": [
        "# @title compute Nash Equilibrium - A smarter approach\n",
        "if POINT_2:\n",
        "  def compute_nash_equilibrium_smart(G, payoffs, always_cooperating_players, all_strategy_profiles, return_all=False):\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "    all_equilibria = []\n",
        "    # check only strategies for which a payoff is given\n",
        "    # N.B. strategy profiles not in payoffs are not equilibria\n",
        "    non_always_cooperating_players = frozenset(all_nodes) - frozenset(always_cooperating_players)\n",
        "\n",
        "    # trivial Nash equilibrium when no player has more than two neighbours\n",
        "    # and therefore anyone cooperates\n",
        "    if non_always_cooperating_players == frozenset():\n",
        "      return (True, frozenset(all_nodes))\n",
        "\n",
        "    for strategy_profile in payoffs.keys():\n",
        "      best_strategy = True\n",
        "      # do not check best response condition for always cooperating player\n",
        "      # since cooperating is a dominant strategy for them and only\n",
        "      # strategy profiles with them cooperating are given\n",
        "      for player in non_always_cooperating_players:\n",
        "        player_set = frozenset([player])\n",
        "        if player in strategy_profile:\n",
        "          changed_strategy = strategy_profile - player_set\n",
        "        else:\n",
        "          changed_strategy = strategy_profile.union(player_set)\n",
        "        if payoffs[changed_strategy][int(player)-1] > payoffs[strategy_profile][int(player)-1]:\n",
        "          #print(f\"strategy {changed_strategy} is better w.r.t. {strategy_profile} for player{player}\")\n",
        "          best_strategy = False\n",
        "          break\n",
        "      #profile is not best strategy for some player and hence it cannot be an eq.\n",
        "      #if no player stopped the inner for (for every player the profile was\n",
        "      # a best response), then profile is an equilibrium\n",
        "      if best_strategy:\n",
        "        if not return_all:\n",
        "          return (True, strategy_profile)\n",
        "        else:\n",
        "          all_equilibria.append(strategy_profile)\n",
        "    return (len(all_equilibria) > 0, all_equilibria)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7iVLcV3MUhty"
      },
      "outputs": [],
      "source": [
        "# @title Benchmarking\n",
        "if POINT_2:\n",
        "  import random\n",
        "\n",
        "  def make_comparison_nash_eq(num_comparisons: int):\n",
        "    smart_solved_instances_times = []\n",
        "    naive_solved_instances_times = []\n",
        "    smart_to_check_strategy_profiles = []\n",
        "    naive_to_check_strategy_profiles = []\n",
        "    for i in range(num_comparisons):\n",
        "      # create a random graph with fixed parameters\n",
        "      num_nodes = randint(15, 18)\n",
        "      density = random.uniform(0.1, 0.5)\n",
        "      # TODO these names are not appropriate\n",
        "      # add edges of the type {s, n} and {n, t} in the graph\n",
        "      # (these { indicate the set repr. of edges\n",
        "      # which is more appropriate in undirected graphs)\n",
        "      edges_outcoming_from_s = randint(2, 3)\n",
        "      edges_incoming_on_t = randint(2, 3)\n",
        "      G = generate_random_graph_from_parameters(num_nodes, density, edges_outcoming_from_s, edges_incoming_on_t)\n",
        "      all_nodes = list(G.nodes())\n",
        "      all_nodes.remove('s')\n",
        "      all_nodes.remove('t')\n",
        "      all_strategy_profiles = powerset(all_nodes)\n",
        "      always_cooperating_players = compute_always_cooperating_players(G)\n",
        "\n",
        "      payoffs_smart = compute_payoffs(G, always_cooperating_players, False)\n",
        "      start_time = time.time()\n",
        "      nash_eq_smart = compute_nash_equilibrium_smart(G, payoffs_smart, always_cooperating_players, all_strategy_profiles)\n",
        "      end_time = time.time()\n",
        "      print(nash_eq_smart)\n",
        "      smart_solved_instance_time = end_time-start_time\n",
        "      smart_to_check_strategy_profiles.append(len(payoffs_smart.keys()))\n",
        "      print(f\"Smart computation took {smart_solved_instance_time} using {len(payoffs_smart.keys())} strategy profiles\")\n",
        "\n",
        "      payoffs_naive = compute_payoffs(G, always_cooperating_players, True)\n",
        "      start_time = time.time()\n",
        "      nash_eq_naive = compute_nash_equilibrium_naive(G, payoffs_naive, all_strategy_profiles)\n",
        "      end_time = time.time()\n",
        "      print(nash_eq_naive)\n",
        "      naive_solved_instance_time = end_time-start_time\n",
        "      naive_to_check_strategy_profiles.append(len(payoffs_naive.keys()))\n",
        "      print(f\"Naive computation took {naive_solved_instance_time} using {len(payoffs_naive.keys())} strategy profiles\")\n",
        "\n",
        "      smart_solved_instances_times.append(smart_solved_instance_time)\n",
        "      naive_solved_instances_times.append(naive_solved_instance_time)\n",
        "\n",
        "    print(\"ALL DONE!\")\n",
        "    return (smart_solved_instances_times, naive_solved_instances_times, smart_to_check_strategy_profiles, naive_to_check_strategy_profiles)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jG50mdzodSTX",
        "outputId": "d6782cfe-f56b-40f3-c087-2ef4fa6b3d48"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(True, frozenset({'3', '11', '2', '7', '17', '8', '18', '1', '4', '6'}))\n",
            "Smart computation took 0.6480786800384521 using 262144 strategy profiles\n",
            "(True, frozenset({'3', '11', '2', '7', '17', '8', '18', '1', '4', '6'}))\n",
            "Naive computation took 0.7061336040496826 using 262144 strategy profiles\n",
            "(True, frozenset({'3', '2', '17', '8', '5', '16', '6'}))\n",
            "Smart computation took 0.1418895721435547 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '2', '17', '8', '5', '16', '6'}))\n",
            "Naive computation took 0.1502857208251953 using 131072 strategy profiles\n",
            "(True, frozenset({'11', '14', '7', '2', '8', '13', '15', '10', '12', '1', '4'}))\n",
            "Smart computation took 0.021701574325561523 using 8192 strategy profiles\n",
            "(True, frozenset({'11', '14', '7', '2', '8', '13', '15', '10', '12', '1', '4'}))\n",
            "Naive computation took 0.640850305557251 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '11', '7', '2', '17', '13', '15', '1', '16', '10', '9', '6'}))\n",
            "Smart computation took 0.002443075180053711 using 2048 strategy profiles\n",
            "(True, frozenset({'3', '11', '7', '2', '17', '13', '15', '1', '16', '10', '9', '6'}))\n",
            "Naive computation took 1.8605859279632568 using 262144 strategy profiles\n",
            "(True, frozenset({'14', '7', '15', '5', '1', '16', '13', '9'}))\n",
            "Smart computation took 0.14299511909484863 using 65536 strategy profiles\n",
            "(True, frozenset({'14', '7', '15', '5', '1', '16', '13', '9'}))\n",
            "Naive computation took 0.15466046333312988 using 65536 strategy profiles\n",
            "(True, frozenset({'3', '14', '7', '2', '8', '15', '10', '1', '4', '9'}))\n",
            "Smart computation took 0.0007853507995605469 using 512 strategy profiles\n",
            "(True, frozenset({'3', '14', '7', '2', '8', '15', '10', '1', '4', '9'}))\n",
            "Naive computation took 0.1323549747467041 using 32768 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '2', '7', '15', '12', '5', '1', '10', '9', '6'}))\n",
            "Smart computation took 0.00032711029052734375 using 128 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '2', '7', '15', '12', '5', '1', '10', '9', '6'}))\n",
            "Naive computation took 0.1599118709564209 using 32768 strategy profiles\n",
            "(True, frozenset({'11', '7', '13', '5', '1', '10', '9'}))\n",
            "Smart computation took 0.02880716323852539 using 16384 strategy profiles\n",
            "(True, frozenset({'11', '7', '13', '5', '1', '10', '9'}))\n",
            "Naive computation took 0.05464673042297363 using 32768 strategy profiles\n",
            "(True, frozenset({'3', '14', '13', '15', '12', '1', '10', '6'}))\n",
            "Smart computation took 0.004816532135009766 using 4096 strategy profiles\n",
            "(True, frozenset({'3', '14', '13', '15', '12', '1', '10', '6'}))\n",
            "Naive computation took 0.0868980884552002 using 32768 strategy profiles\n",
            "(True, frozenset({'3', '14', '7', '15', '5', '1', '13'}))\n",
            "Smart computation took 0.07953333854675293 using 65536 strategy profiles\n",
            "(True, frozenset({'3', '14', '7', '15', '5', '1', '13'}))\n",
            "Naive computation took 0.08658432960510254 using 65536 strategy profiles\n",
            "(True, frozenset({'14', '2', '8', '10', '1', '4', '6'}))\n",
            "Smart computation took 0.07567977905273438 using 65536 strategy profiles\n",
            "(True, frozenset({'14', '2', '8', '10', '1', '4', '6'}))\n",
            "Naive computation took 0.07277083396911621 using 65536 strategy profiles\n",
            "(True, frozenset({'3', '11', '2', '7', '17', '8', '13', '15', '10', '12', '5', '1', '18', '4', '6'}))\n",
            "Smart computation took 0.000993967056274414 using 64 strategy profiles\n",
            "(True, frozenset({'3', '11', '2', '7', '17', '8', '13', '15', '10', '12', '5', '1', '18', '4', '6'}))\n",
            "Naive computation took 1.4138906002044678 using 262144 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '7', '8', '13', '15', '12', '5', '1', '16', '18', '10'}))\n",
            "Smart computation took 0.0020346641540527344 using 1024 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '7', '8', '13', '15', '12', '5', '1', '16', '18', '10'}))\n",
            "Naive computation took 1.5347411632537842 using 262144 strategy profiles\n",
            "(True, frozenset({'3', '2', '15', '1', '16', '4'}))\n",
            "Smart computation took 0.030736684799194336 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '2', '15', '1', '16', '4'}))\n",
            "Naive computation took 0.03170132637023926 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '14', '2', '8', '15', '1', '16', '9', '6'}))\n",
            "Smart computation took 0.4786365032196045 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '14', '2', '8', '15', '1', '16', '9', '6'}))\n",
            "Naive computation took 0.3412292003631592 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '11', '7', '2', '10', '1', '16', '4', '9'}))\n",
            "Smart computation took 0.07182669639587402 using 32768 strategy profiles\n",
            "(True, frozenset({'3', '11', '7', '2', '10', '1', '16', '4', '9'}))\n",
            "Naive computation took 0.1967780590057373 using 65536 strategy profiles\n",
            "(True, frozenset({'3', '11', '2', '17', '8', '13', '15', '10', '12', '1', '4', '9', '6'}))\n",
            "Smart computation took 0.0006320476531982422 using 256 strategy profiles\n",
            "(True, frozenset({'3', '11', '2', '17', '8', '13', '15', '10', '12', '1', '4', '9', '6'}))\n",
            "Naive computation took 0.7180187702178955 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '14', '2', '7', '8', '13', '15', '10', '12', '18', '1', '16', '4', '9', '6'}))\n",
            "Smart computation took 8.702278137207031e-05 using 32 strategy profiles\n",
            "(True, frozenset({'3', '14', '2', '7', '8', '13', '15', '10', '12', '18', '1', '16', '4', '9', '6'}))\n",
            "Naive computation took 1.4430062770843506 using 262144 strategy profiles\n",
            "(True, frozenset({'3', '2', '17', '8', '13', '15', '12', '1', '4', '9'}))\n",
            "Smart computation took 0.02817559242248535 using 16384 strategy profiles\n",
            "(True, frozenset({'3', '2', '17', '8', '13', '15', '12', '1', '4', '9'}))\n",
            "Naive computation took 0.5179674625396729 using 131072 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '2', '7', '8', '13', '15', '10', '5', '1', '4', '9'}))\n",
            "Smart computation took 7.653236389160156e-05 using 16 strategy profiles\n",
            "(True, frozenset({'3', '11', '14', '2', '7', '8', '13', '15', '10', '5', '1', '4', '9'}))\n",
            "Naive computation took 0.16986870765686035 using 32768 strategy profiles\n",
            "ALL DONE!\n"
          ]
        }
      ],
      "source": [
        "if POINT_2 and EXPERIMENTS:\n",
        "  num_comparisons = 20\n",
        "  results = make_comparison_nash_eq(num_comparisons)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 576
        },
        "id": "e2SmLzcRr4fn",
        "outputId": "ee6d7242-0fc7-47bf-a571-f306e679a736"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average time\n",
            "\tsmart -> 0.08801285028457642\n",
            "\tsmart -> 0.52364422082901\n",
            "Average of maximum strategy profiles to check\n",
            "\tsmart -> 46693.6\n",
            "\tnaive -> 126156.8\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Cactus plot of results\n",
        "if POINT_2 and EXPERIMENTS:\n",
        "  from statistics import mean\n",
        "\n",
        "  x_smart = results[0]\n",
        "  y = [i for i in range(num_comparisons)]\n",
        "\n",
        "  x_naive = results[1]\n",
        "\n",
        "  x_smart.sort()\n",
        "  x_naive.sort()\n",
        "  print(\"Average time\")\n",
        "  print(f\"\\tsmart -> {mean(x_smart)}\")\n",
        "  print(f\"\\tsmart -> {mean(x_naive)}\")\n",
        "\n",
        "  print(\"Average of maximum strategy profiles to check\")\n",
        "  print(f\"\\tsmart -> {mean(results[2])}\")\n",
        "  print(f\"\\tnaive -> {mean(results[3])}\")\n",
        "\n",
        "\n",
        "  plt.plot(y, x_naive, marker='o', linestyle='-', label='naive version')\n",
        "  plt.plot(y, x_smart,  marker='x', linestyle='-', label='smart version')\n",
        "\n",
        "  plt.ylabel('Solved instances')\n",
        "  plt.xlabel('time')\n",
        "  plt.title('Nash Equilibrium')\n",
        "\n",
        "  plt.legend()\n",
        "\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PU22TiWtzZlZ"
      },
      "outputs": [],
      "source": [
        "#G = generate_random_graph_from_parameters(4, 1, 2, 2)\n",
        "# nx.draw(G, with_labels = True, font_weight='bold', node_size = 500, node_color = 'red')\n",
        "# all_nodes = list(G.nodes())\n",
        "# all_nodes.remove('s')\n",
        "# all_nodes.remove('t')\n",
        "# all_strategy_profiles = powerset(all_nodes)\n",
        "# always_cooperating_players = compute_always_cooperating_players(G)\n",
        "# payoffs_smart = compute_payoffs(G, always_cooperating_players, True)\n",
        "# #print(payoffs_smart)\n",
        "# #print(always_cooperating_players)\n",
        "# #nash_eq_smart = compute_nash_equilibrium_smart(G, payoffs_smart, always_cooperating_players, all_strategy_profiles, True)\n",
        "# nash_eq_smart = compute_nash_equilibrium_naive(G, payoffs_smart, all_strategy_profiles, True)\n",
        "# print(nash_eq_smart)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TMVqMYRzd_EB"
      },
      "outputs": [],
      "source": [
        "# @title Block for checking solution after submission\n",
        "# TODO just define your graph here and remove all comments\n",
        "# if POINT_3 and SINGLE_BENCHMARK:\n",
        "  # G=nx.Graph()\n",
        "  # nodes = ['s', 't', '1', '2', '3', '4']\n",
        "  # edges = [('s', '1'), ('s', '2'), ('1', '3'), ('1', '4'), #('3','4'),('3','2'),\n",
        "  #         ('2', '4'), ('3', 't'), ('4', 't')]\n",
        "  # G.add_nodes_from(nodes)\n",
        "  # G.add_edges_from(edges)\n",
        "\n",
        "  # print(f\"Nodes: {G.nodes()}\")\n",
        "  # print(f\"Edges: {G.edges()}\")\n",
        "  # all_nodes = list(G.nodes())\n",
        "  # all_nodes.remove('s')\n",
        "  # all_nodes.remove('t')\n",
        "  # all_strategy_profiles = powerset(all_nodes)\n",
        "  # always_cooperating_players = compute_always_cooperating_players(G)\n",
        "  # payoffs_smart = compute_payoffs(G, always_cooperating_players, False)\n",
        "  # nash_eq_smart = compute_nash_equilibrium_smart(G, payoffs_smart, always_cooperating_players, all_strategy_profiles)\n",
        "  # print(nash_eq_smart)\n",
        "  # payoffs_smart"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xoUBzWfqAPMo"
      },
      "source": [
        "# Assignment 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vpaNF3yFASCI"
      },
      "outputs": [],
      "source": [
        "# @title Tree decomposition\n",
        "if POINT_3:\n",
        "  def tree_decomposition(G, elimination_order):\n",
        "      bags: set = set()\n",
        "      max_bag_size = 0\n",
        "      for node in elimination_order:\n",
        "          bag: set = set()\n",
        "          bag.add(node)\n",
        "          #triangulate - add an edge between any pair of adj nodes to the one that I am removing\n",
        "          for neigh1 in nx.neighbors(G, node):\n",
        "              #create a bag with all the neighbours of the elimination node\n",
        "              bag.add(neigh1) #this should add the node itself\n",
        "              for neigh2 in nx.neighbors(G, node):\n",
        "                  G.add_edge(neigh1, neigh2)\n",
        "\n",
        "          to_add = True\n",
        "          for bag_already_added in bags:\n",
        "              if  bag_already_added.issuperset(frozenset(bag)):\n",
        "                  to_add = False\n",
        "\n",
        "          if to_add:\n",
        "              #add bag\n",
        "              bags.add(frozenset(bag))\n",
        "              if len(bag) > max_bag_size:\n",
        "                  max_bag_size = len(bag)\n",
        "\n",
        "          G.remove_node(node)\n",
        "\n",
        "      # Build a weighted graph on the bags, where the weights are given by the cardinality of the intersection of any two bags\n",
        "      # In such a way the maximum spanning tree of the constructed graph will trivially\n",
        "      # coincide with the tree decomposition. No edge is added in T if the cardinality\n",
        "      # of the intersection between two bags is not maximum(this comes form max span tree definition)\n",
        "      cluster_graph = nx.Graph()\n",
        "      edges = [(u, v, len(u & v)) for u, v in permutations(bags, 2) if len(u & v) > 0]\n",
        "      cluster_graph.add_weighted_edges_from(edges)\n",
        "\n",
        "      # Find the tree decomposition by extracting the maximum spanning tree of the cluster graph\n",
        "      T = nx.maximum_spanning_tree(cluster_graph)\n",
        "\n",
        "      return (max_bag_size-1, T)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ct0V4H9ua-o9"
      },
      "outputs": [],
      "source": [
        "# @title min degree elimination order\n",
        "if POINT_3:\n",
        "  def min_degree_elimination_order(G):\n",
        "      G1 = G.copy()\n",
        "      degree_of_node:dict = {}\n",
        "      removal_order = []\n",
        "      min_neighbours_def = len(G1.nodes())\n",
        "      while len(G1.nodes()) > 0:\n",
        "          degree_of_node = {}\n",
        "          min_neighbours = min_neighbours_def\n",
        "          for node in G1.nodes():\n",
        "              if G1.degree(node) < min_neighbours:\n",
        "                  min_neighbours = G1.degree(node)\n",
        "                  degree_of_node[node] = G1.degree(node)\n",
        "\n",
        "\n",
        "          #G.remove_edges_from(G.nodes()[node])\n",
        "          to_remove = list(degree_of_node.keys())[list(degree_of_node.values()).index(min(degree_of_node.values()))]\n",
        "          removal_order.append(to_remove)\n",
        "          #print(\"Nodes in the graph: \", G1.nodes(), \" to remove \", to_remove)\n",
        "          #triangulate - add an edge between any pair of adj nodes to the one that I am removing\n",
        "          for neigh1 in nx.neighbors(G1, to_remove):\n",
        "              for neigh2 in nx.neighbors(G1, to_remove):\n",
        "                  if neigh1 != neigh2:\n",
        "                    G1.add_edge(neigh1, neigh2)\n",
        "          G1.remove_node(to_remove)\n",
        "      return removal_order"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cBlTA6Sm7c5x"
      },
      "outputs": [],
      "source": [
        "# @title Nash Equilibrium computation with Tree decomposition\n",
        "# Note: whatever correct tree decomposition we find is a bound to the treewidth\n",
        "# of the graph. The algorithm works with whatever tree decomposition, but in the\n",
        "# trivial case in which all the nodes are grouped in a single bag the algorithm\n",
        "# does not behave differently w.r.t. the nash equilibrium computation that does\n",
        "# not exploit tree decomposition\n",
        "if POINT_3:\n",
        "  def compute_nash_equilibrium_from_tree_decomposition(T, payoffs, all_strategy_profiles):\n",
        "    root = list(T.nodes())[0]\n",
        "    bfs_successors = dict(nx.bfs_successors(T, root))\n",
        "    postorder = nx.dfs_postorder_nodes(T, root)\n",
        "\n",
        "    # keeps a set for each bag which consists of the players that a bag is fixing\n",
        "    player_fixed_by_bag: dict = {}\n",
        "    # keeps what are equilibria up to a certain level in the tree\n",
        "    equilibria_up_to_bag : dict = {}\n",
        "\n",
        "    players_fixed_cooperate = set()\n",
        "    players_fixed_defect = set()\n",
        "    non_fixed_players = set()\n",
        "\n",
        "    for bag in postorder:\n",
        "      #print(f\"Considering bag {bag}\")\n",
        "\n",
        "      is_root = True\n",
        "      #find the father of current bag and compute what node the current bag is fixing\n",
        "      for father in bfs_successors:\n",
        "        if bag in bfs_successors[father]:\n",
        "          #bag is son of father\n",
        "          is_root = False\n",
        "          player_fixed_by_bag[bag] = bag - father\n",
        "          #print(f\"Bag {bag} is fixing  {player_fixed_by_bag[bag]} computed as {bag} - {father}\")\n",
        "          break\n",
        "        if is_root:\n",
        "          players_fixed_by_root = []\n",
        "          # fix all the players that are in child and not in root\n",
        "          for child in bfs_successors[bag]:\n",
        "            # fix the players that were not fixed by child (those in common with them)\n",
        "            players_fixed_by_root = players_fixed_by_root + list(child.intersection(bag))\n",
        "          player_fixed_by_bag[bag] = frozenset(players_fixed_by_root)\n",
        "          #print(f\"Bag {bag} is fixing  {player_fixed_by_bag[bag]}\")\n",
        "\n",
        "      #leaf\n",
        "      if bag not in bfs_successors:\n",
        "        #print(f\"bag {bag} is a leaf\")\n",
        "        equilibria_up_to_bag[bag] = []\n",
        "        for strategy_profile in all_strategy_profiles:\n",
        "          best_strategy = True\n",
        "          for player in bag.union(non_fixed_players):\n",
        "            #print(f\"Checking best response for {player}\")\n",
        "            player_set = frozenset([player])\n",
        "\n",
        "            if player in strategy_profile:\n",
        "              changed_strategy = player_set - strategy_profile\n",
        "            else:\n",
        "              changed_strategy = strategy_profile.union(player_set)\n",
        "\n",
        "            if payoffs[changed_strategy][int(player)-1] > payoffs[strategy_profile][int(player)-1]:\n",
        "              best_strategy = False\n",
        "              break\n",
        "          #profile is not best strategy for some player and hence it cannot be an eq.\n",
        "          #if no player stopped the inner for (for every player the profile was\n",
        "          # a best response), then profile is an equilibrium\n",
        "          if best_strategy:\n",
        "            #just the players of the bag may suffice\n",
        "            equilibria_up_to_bag[bag].append(strategy_profile)\n",
        "            #print(f\"appending equilibria for bag {bag}\")\n",
        "\n",
        "        # save fixed player by bag with their choice\n",
        "        # (assuming that only one option is saved among cooperate and defect)\n",
        "        for player in player_fixed_by_bag[bag]:\n",
        "          all_defect = True\n",
        "          all_cooperate = True\n",
        "          for strategy in equilibria_up_to_bag[bag]:\n",
        "            if player in strategy:\n",
        "              all_defect = False\n",
        "            if player not in strategy:\n",
        "              all_cooperate = False\n",
        "          if all_cooperate:\n",
        "            players_fixed_cooperate.add(player)\n",
        "            #print(f\"Bag {bag} is fixing {player} as cooperate\")\n",
        "          elif all_defect:\n",
        "            players_fixed_defect.add(player)\n",
        "            #print(f\"Bag {bag} is fixing {player} as defect\")\n",
        "          else: #non-fixed\n",
        "            non_fixed_players.add(player)\n",
        "\n",
        "      #non-leaf: merge results\n",
        "      else:\n",
        "        #print(f\"bag {bag} is not a leaf\")\n",
        "        equilibria_up_to_bag[bag] = []\n",
        "        all_strategy_profiles_bag = []\n",
        "\n",
        "        # say that everyone survives\n",
        "        for child in bfs_successors[bag]:\n",
        "          #print(f\"Considering bag {bag} - adding equilibria from {child}\")\n",
        "          all_strategy_profiles_bag = all_strategy_profiles_bag + equilibria_up_to_bag[child]\n",
        "\n",
        "        to_check_players = players_fixed_cooperate.union(players_fixed_defect)\n",
        "        strategy_profiles_to_remove = set()\n",
        "        all_strategy_profiles_bag = list(set(all_strategy_profiles_bag))\n",
        "        # remove strategy profiles such that they do not match on\n",
        "        # he ith player with the ith player fixed by some child of bag\n",
        "        #print(f\"removing candidate eqilibria from bag {bag} I have to check players {players_fixed_cooperate} and {players_fixed_defect}\")\n",
        "\n",
        "        for strategy_profile in all_strategy_profiles_bag:\n",
        "            for player in to_check_players:\n",
        "              #print(f\"I am in bag {bag} and checking {player}\")\n",
        "              if player in players_fixed_cooperate:\n",
        "                if player not in strategy_profile:\n",
        "                  strategy_profiles_to_remove.add(strategy_profile)\n",
        "                  #print(\"Removed one\")\n",
        "                  #print(f\"removed  {strategy_profile} outside bag loop - check cooperate\")\n",
        "              elif player in players_fixed_defect:\n",
        "                if player in strategy_profile:\n",
        "                  strategy_profiles_to_remove.add(strategy_profile)\n",
        "                  #print(f\"removed {strategy_profile} outside bag loop - check defect\")\n",
        "                  #print(\"Removed one\")\n",
        "\n",
        "        for strategy_profile in strategy_profiles_to_remove:\n",
        "          all_strategy_profiles_bag.remove(strategy_profile)\n",
        "\n",
        "        strategy_profiles_to_remove = set()\n",
        "\n",
        "        for strategy_profile in all_strategy_profiles_bag:\n",
        "          best_strategy = True\n",
        "          for player in bag.union(non_fixed_players):\n",
        "            player_set = frozenset([player])\n",
        "\n",
        "            if player in strategy_profile:\n",
        "              changed_strategy = player_set - strategy_profile\n",
        "            else:\n",
        "              changed_strategy = strategy_profile.union(player_set)\n",
        "\n",
        "            if payoffs[changed_strategy][int(player)-1] > payoffs[strategy_profile][int(player)-1]:\n",
        "              best_strategy = False\n",
        "              strategy_profiles_to_remove.add(strategy_profile)\n",
        "              #print(\"Removing inside check for bag best response\")\n",
        "              break\n",
        "\n",
        "        for strategy_profile in strategy_profiles_to_remove:\n",
        "          all_strategy_profiles_bag.remove(strategy_profile)\n",
        "\n",
        "        equilibria_up_to_bag[bag] = all_strategy_profiles_bag\n",
        "\n",
        "        # save fixed player by bag with their choice\n",
        "        # (assuming that only one option is saved among cooperate and defect)\n",
        "        for player in player_fixed_by_bag[bag]:\n",
        "          all_defect = True\n",
        "          all_cooperate = True\n",
        "          for strategy in equilibria_up_to_bag[bag]:\n",
        "            if player in strategy:\n",
        "              all_defect = False\n",
        "            if player not in strategy:\n",
        "              all_cooperate = False\n",
        "          if all_cooperate:\n",
        "            players_fixed_cooperate.add(player)\n",
        "            #print(f\"Bag {bag} is fixing {player} as cooperate\")\n",
        "          elif all_defect:\n",
        "            players_fixed_defect.add(player)\n",
        "            #print(f\"Bag {bag} is fixing {player} as defect\")\n",
        "          else: #non-fixed\n",
        "            non_fixed_players.add(player)\n",
        "\n",
        "      #print(f\"Equilibria up to bag {bag} are {len(equilibria_up_to_bag[bag])}\")\n",
        "    return equilibria_up_to_bag[root]\n",
        "    #original"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 568
        },
        "id": "oqSUAcwmeSLB",
        "outputId": "98d294c2-1e1e-40e3-fdad-212b30ec0859"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "frozenset({'4', '1'})\n",
            "{frozenset({'4', '1'}): [frozenset({'3', '1'}), frozenset({'4', '2'})]}\n",
            "equilibria are [frozenset({'3', '4', '2', '1'})]\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "if POINT_3 and EXPERIMENTS:\n",
        "\n",
        "  G1 = G.copy()\n",
        "  G1.remove_nodes_from(['s', 't'])\n",
        "  T = tw.treewidth_min_degree(G1)[1]\n",
        "  elim_order = min_degree_elimination_order(G1)\n",
        "\n",
        "  #w, T = tree_decomposition(G1, elim_order)\n",
        "\n",
        "  labels = {node:','.join(list(map(str, node))) for node in T}\n",
        "\n",
        "  nx.draw(T, labels=labels, font_weight='bold', node_color = 'red', node_size = 3000)\n",
        "\n",
        "  root = list(T.nodes())[0]\n",
        "  print(root)\n",
        "  bfs_successors = dict(nx.bfs_successors(T, root))\n",
        "  print(bfs_successors)\n",
        "  all_nodes = list(G.nodes())\n",
        "  all_nodes.remove('s')\n",
        "  all_nodes.remove('t')\n",
        "  all_strategy_profiles = powerset(all_nodes)\n",
        "  payoffs = compute_payoffs(G, [], True)\n",
        "  all_equilibria = compute_nash_equilibrium_from_tree_decomposition(T, payoffs, all_strategy_profiles)\n",
        "  print(f\"equilibria are {all_equilibria}\")\n",
        "  #print(payoffs)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OobfTaQ14KRD"
      },
      "source": [
        "# Assignment 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fFX2jhIs4L_d"
      },
      "outputs": [],
      "source": [
        "# @title VCG\n",
        "if POINT_4:\n",
        "  # defines the function that maps each player to their real utility\n",
        "  def real_utility_for_player(player: int):\n",
        "    return player * 10\n",
        "\n",
        "  # declare a random value close to the real utility of the player\n",
        "  def declare_values(G):\n",
        "    k = 9\n",
        "    declared_values: dict = {}\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "\n",
        "    for player in all_nodes:\n",
        "      true_value_for_player = real_utility_for_player(int(player))\n",
        "      declared_values[player] = true_value_for_player + randint(-k, k)\n",
        "    return declared_values\n",
        "\n",
        "  # compute weight of a specific path according to declared values\n",
        "  def get_weight(path, declared_values):\n",
        "    value = 0\n",
        "    for node in path[1:-1]:\n",
        "      value += declared_values[node]\n",
        "    return value\n",
        "\n",
        "  # generate all simple paths in the graph and compute the weight of each of them\n",
        "  def compute_paths_to_values(G, declared_values):\n",
        "    paths_to_values = []\n",
        "    for path in nx.all_simple_paths(G, 's', 't'):\n",
        "      paths_to_values.append((path, get_weight(path, declared_values)))\n",
        "    paths_to_values.sort(key=lambda tup: tup[1], reverse=True)\n",
        "    return paths_to_values\n",
        "\n",
        "  # compute top ranked option by excluding a player. If such player is None\n",
        "  # just return the very first option (options are sorted by value)\n",
        "  def compute_top_ranked_without_player(paths_to_values, excluded_player = None):\n",
        "    if excluded_player is None:\n",
        "      return paths_to_values[0]\n",
        "\n",
        "    for path_and_value in paths_to_values:\n",
        "      if excluded_player not in path_and_value[0]:\n",
        "        return path_and_value\n",
        "\n",
        "    #no path without excluded player\n",
        "    return None\n",
        "\n",
        "  # compute payements for all players given the declaration\n",
        "  # in declared_values\n",
        "  def VCG_mechanism(G, declared_values):\n",
        "    #value and payements for every player\n",
        "    VCG_results = {}\n",
        "    paths_to_values = compute_paths_to_values(G, declared_values)\n",
        "    # for i in paths_to_values:\n",
        "    #   print(i)\n",
        "    top_ranked = compute_top_ranked_without_player(paths_to_values)\n",
        "    for player in list(G.nodes()):\n",
        "      if player == 's' or player == 't':\n",
        "        continue\n",
        "      top_ranked_wo_player = compute_top_ranked_without_player(paths_to_values, excluded_player = player)\n",
        "      if top_ranked_wo_player is None:\n",
        "        h_i = 0\n",
        "        #print(f\"Top ranked path without player {player} has value 0\")\n",
        "      else:\n",
        "        #print(f\"Top ranked path without player {player} is {top_ranked_wo_player[0]} of value {top_ranked_wo_player[1]}\")\n",
        "        h_i = top_ranked_wo_player[1]\n",
        "      opt_value_wo_player = 0\n",
        "      for p in top_ranked[0][1:-1]:\n",
        "        if p != player:\n",
        "          opt_value_wo_player += declared_values[p]\n",
        "      #print(f\"sum values in opt without counting player {player} is of value: {opt_value_wo_player}\")\n",
        "      payement_player = h_i - opt_value_wo_player\n",
        "      VCG_results[player] = payement_player * -1\n",
        "    return VCG_results\n",
        "\n",
        "  def compute_gain_with_payements_and_declarations(G, declared_values, players_and_payements):\n",
        "    all_nodes = list(G.nodes())\n",
        "    all_nodes.remove('s')\n",
        "    all_nodes.remove('t')\n",
        "    gain_players = {}\n",
        "    for player in all_nodes:\n",
        "      #print(f\"payement for player {player} is:  {players_and_payements[player]}\")\n",
        "      gain_players[player] = players_and_payements[player] - declared_values[player]\n",
        "    return gain_players"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xiQs8mYu_g6L"
      },
      "outputs": [],
      "source": [
        "if POINT_4:\n",
        "    G =  generate_random_graph_from_parameters(7, 0.3, 2, 2)\n",
        "    declared_values = declare_values(G)\n",
        "    players_and_payements = VCG_mechanism(G, declared_values)\n",
        "    compute_gain_with_payements_and_declarations(G, declared_values, players_and_payements)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hw9JAW0Gey70",
        "outputId": "3843aa7b-65fa-41c5-a148-c630ebdec9ad"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'1': 5, '2': 18, '3': 26, '4': 45, '5': 49, '6': 54, '7': 78}\n",
            "Selected changing player: 3\n",
            "[26, 31, 36, 41, 46, 51, 56, 61, 66, 71]\n",
            "[-26, -31, -36, -41, -46, -51, -56, -61, -66, -71]\n"
          ]
        }
      ],
      "source": [
        "# @title Checking whether it is convenient for a player to declare a higher value\n",
        "if POINT_4 and EXPERIMENTS:\n",
        "  num_nodes = 7\n",
        "  G =  generate_random_graph_from_parameters(num_nodes, 0.3, 2, 2)\n",
        "  declared_values = declare_values(G)\n",
        "  print(declared_values)\n",
        "\n",
        "  increase_by_iteration = 5\n",
        "  selected_changing_player = str(num_nodes//2)\n",
        "  print(f\"Selected changing player: {selected_changing_player}\")\n",
        "  declaration_for_player = []\n",
        "  gain_for_changing_player = []\n",
        "\n",
        "  for i in range(10):\n",
        "    #change declaration of player and see what happens to the payement\n",
        "    players_and_payements = VCG_mechanism(G, declared_values)\n",
        "    gain_for_players = compute_gain_with_payements_and_declarations(G, declared_values, players_and_payements)\n",
        "    declaration_for_player.append(declared_values[selected_changing_player])\n",
        "    gain_for_changing_player.append(gain_for_players[selected_changing_player])\n",
        "    #print(\"WE \", declared_values)\n",
        "    #print(f\"Players and payements {gain_for_players}\")\n",
        "    declared_values[selected_changing_player] += increase_by_iteration\n",
        "\n",
        "  print(declaration_for_player)\n",
        "  print(gain_for_changing_player)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "VEuDgiW-kAZC",
        "outputId": "8efc2858-ce83-45e7-8c2c-bcbbd80ccec6"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Plot how gain for player goes as his declared value increases\n",
        "if POINT_4 and EXPERIMENTS:\n",
        "  plt.plot(declaration_for_player, gain_for_changing_player,  marker='x', linestyle='-', label='gain by declaration')\n",
        "  plt.axvline(x = real_utility_for_player(int(selected_changing_player)), color = 'b', label = 'real utility for player')\n",
        "  plt.ylabel('gain')\n",
        "  plt.xlabel('declaration')\n",
        "  plt.title('VCG')\n",
        "\n",
        "  plt.legend()\n",
        "\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t3vzuMC-eWkj"
      },
      "outputs": [],
      "source": [
        "# @title Block for checking solution after submission\n",
        "# TODO just define your graph here and remove all comments\n",
        "# if POINT_3 and SINGLE_BENCHMARK:\n",
        "  # G=nx.Graph()\n",
        "  # nodes = ['s', 't', '1', '2', '3', '4']\n",
        "  # edges = [('s', '1'), ('s', '2'), ('1', '3'), ('1', '4'), #('3','4'),('3','2'),\n",
        "  #         ('2', '4'), ('3', 't'), ('4', 't')]\n",
        "  # G.add_nodes_from(nodes)\n",
        "  # G.add_edges_from(edges)\n",
        "  # declared_values = declare_values(G)\n",
        "  # print(declared_values)\n",
        "  # players_and_payements = VCG_mechanism(G, declared_values)\n",
        "  # compute_gain_with_payements_and_declarations(G, declared_values, players_and_payements)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}