FairDivision2Ag3It.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNom1+2WHKNlDc5J/psWp9C",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tinsir888/algorithms-incentives-and-data/blob/main/FairDivision2Ag3It.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fair allocations among 2 agent with 3 items\n",
        "\n",
        "Input of each agent is the ordinal preference profile.\n",
        "\n",
        "Consider the case that items are divisible."
      ],
      "metadata": {
        "id": "PMJGCA-K6b-k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import copy\n",
        "\n",
        "num_of_item = 3\n",
        "\n",
        "class agent:\n",
        "\n",
        "  def __init__(self, true_preference, bid_preference):\n",
        "    self.bundle=[0]*num_of_item\n",
        "    self.true_preference=true_preference\n",
        "    self.bid=bid_preference\n",
        "\n",
        "  def is_truthful(self):\n",
        "    return self.true_preference == self.bid_preference\n",
        "\n",
        "  def is_sd_prefer(self,bundle1,bundle2):\n",
        "    # judge whether the agent strictly SD-prefer bundle1 to bundle2\n",
        "    cumulate1=0\n",
        "    cumulate2=0\n",
        "    i=0\n",
        "    is_strictly_sd_prefer=False\n",
        "    while cumulate1>=cumulate2 and i<num_of_item:\n",
        "      cumulate1 += bundle1[self.true_preference[i]]\n",
        "      cumulate2 += bundle2[self.true_preference[i]]\n",
        "      i+=1\n",
        "      #print(cumulate1,cumulate2)\n",
        "      if cumulate1 > cumulate2:\n",
        "        is_strictly_sd_prefer=True\n",
        "      if cumulate1 < cumulate2:\n",
        "        return False\n",
        "    return is_strictly_sd_prefer\n",
        "\n",
        "class fair_division_instance:\n",
        "  def __init__(self, agent1, agent2):\n",
        "    self.agent1=agent1\n",
        "    self.agent2=agent2\n",
        "    self.remain_item = [100]*num_of_item\n",
        "    self.alloc1=[0]*num_of_item\n",
        "    self.alloc2=[0]*num_of_item\n",
        "    self.is_equil=None\n",
        "\n",
        "  def not_complete(self):\n",
        "    for i in range(num_of_item):\n",
        "      if self.remain_item[i] > 0:\n",
        "        return True\n",
        "    return False\n",
        "\n",
        "  def eating_protocol(self):\n",
        "\n",
        "    i=0\n",
        "    j=0\n",
        "    #agent1_eat=self.agent1.bid[i]\n",
        "    #agent2_eat=self.agent2.bid[j]\n",
        "    while self.not_complete():\n",
        "      if self.remain_item[self.agent1.bid[i]] == 0:\n",
        "        i+=1\n",
        "        continue\n",
        "      if self.remain_item[self.agent2.bid[j]] == 0:\n",
        "        j+=1\n",
        "        continue\n",
        "\n",
        "      if self.agent1.bid[i] == self.agent2.bid[j] and self.remain_item[self.agent1.bid[i]] > 0:\n",
        "        self.alloc1[self.agent1.bid[i]] += (self.remain_item[self.agent1.bid[i]]/2)\n",
        "        self.alloc2[self.agent2.bid[j]] += (self.remain_item[self.agent2.bid[j]]/2)\n",
        "        self.remain_item[self.agent1.bid[i]] = 0\n",
        "        i+=1\n",
        "        j+=1\n",
        "      elif self.agent1.bid[i] != self.agent2.bid[j] and self.remain_item[self.agent1.bid[i]] > 0:\n",
        "        if(i<num_of_item):\n",
        "          self.alloc1[self.agent1.bid[i]] += self.remain_item[self.agent1.bid[i]]\n",
        "          self.remain_item[self.agent1.bid[i]] = 0\n",
        "          i+=1\n",
        "        if(j<num_of_item):\n",
        "          self.alloc2[self.agent2.bid[j]] += self.remain_item[self.agent2.bid[j]]\n",
        "          self.remain_item[self.agent2.bid[j]] = 0\n",
        "          j+=1\n",
        "    self.agent1.bundle=self.alloc1\n",
        "    self.agent2.bundle=self.alloc2\n",
        "    return self.alloc1, self.alloc2\n",
        "\n",
        "  def is_equilibrium(self):\n",
        "    pass\n",
        "\n",
        "  def is_br2ag1(self):\n",
        "    pass\n",
        "\n",
        "  def is_br2ag2(self):\n",
        "    pass\n",
        "\n",
        "  def get_alloc(self):\n",
        "\n",
        "    print(\"agent1's true preference: \",self.agent1.true_preference)\n",
        "    print(\"agent2's true preference: \",self.agent2.true_preference)\n",
        "    print(\"agent1's bid: \",self.agent1.bid)\n",
        "    print(\"agent2's bid: \",self.agent2.bid)\n",
        "    print(\"agent1 gets: \",self.agent1.bundle)\n",
        "    print(\"agent2 gets: \",self.agent2.bundle)\n",
        "    #print(\"is equilibrium? \",self.is_equilibrium())"
      ],
      "metadata": {
        "id": "wjEKc31X7BkI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def check_state(true_preference1, true_preference2):\n",
        "  agent1 = agent(true_preference1,true_preference1)\n",
        "  agent2 = agent(true_preference2,true_preference2)\n",
        "  I = fair_division_instance(agent1,agent2)\n",
        "  true_alloc1,true_alloc2 = I.eating_protocol() # Allocated bundles by truth-telling\n",
        "  print(\"---------------------------------------------------------\")\n",
        "  I.get_alloc()\n",
        "  \"\"\"\n",
        "  print(\"Is it best response for agent 1?\")\n",
        "  # fix agent 2\n",
        "  flag=True\n",
        "  prefer1 = [i for i in range(num_of_item)]\n",
        "  per2 = true_preference2\n",
        "  prefer1_per = permutations(prefer1)\n",
        "  for per1 in prefer1_per:\n",
        "    tmp_agent1=agent(true_preference1,per1)\n",
        "    tmp_agent2=agent(true_preference2,per2)\n",
        "    tmp_I=fair_division_instance(tmp_agent1,tmp_agent2)\n",
        "    tmp_alloc1,tmp_alloc2=tmp_I.eating_protocol()\n",
        "    if tmp_agent1.is_sd_prefer(tmp_alloc1,true_alloc1):\n",
        "      flag=False\n",
        "      print(\"Better one:\")\n",
        "      print(\"Misreporting \",true_preference1,\" -> \",per1)\n",
        "      print(\"Bundle 1: \",true_alloc1,\" -> \",tmp_alloc1)\n",
        "      print(\"Bundle 2: \",true_alloc2,\" -> \",tmp_alloc2)\n",
        "  if flag:\n",
        "    print(\"Yes!\")\n",
        "  \"\"\"\n",
        "  print(\"Is it best response for agent 2?\")\n",
        "  # fix agent 1\n",
        "  flag=True\n",
        "  per1=true_preference1\n",
        "  prefer2 = [i for i in range(num_of_item)]\n",
        "  prefer2_per = permutations(prefer2)\n",
        "  for per2 in prefer2_per:\n",
        "    tmp_agent1=agent(true_preference1,per1)\n",
        "    tmp_agent2=agent(true_preference2,per2)\n",
        "    tmp_I=fair_division_instance(tmp_agent1,tmp_agent2)\n",
        "    tmp_alloc1,tmp_alloc2=tmp_I.eating_protocol()\n",
        "    #tmp_I.get_alloc()\n",
        "    #print(tmp_alloc2,true_alloc2)\n",
        "    if tmp_agent2.is_sd_prefer(tmp_alloc2,true_alloc2):\n",
        "      flag=False\n",
        "      print(\"Better one:\")\n",
        "      print(\"Misreporting \",true_preference2,\" -> \",per2)\n",
        "      print(\"Bundle 1: \",true_alloc1,\" -> \",tmp_alloc1)\n",
        "      print(\"Bundle 2: \",true_alloc2,\" -> \",tmp_alloc2)\n",
        "  if flag:\n",
        "    print(\"Yes!\")\n",
        "  print(\"---------------------------------------------------------\\n\\n\")\n",
        "\n",
        "import networkx as nx\n",
        "\n",
        "def get_reporting_states_graph_edge(true_preference1, true_preference2, G):\n",
        "  #G = nx.Graph()\n",
        "  agent1 = agent(true_preference1,true_preference1)\n",
        "  agent2 = agent(true_preference2,true_preference2)\n",
        "  I = fair_division_instance(agent1,agent2)\n",
        "  true_alloc1,true_alloc2 = I.eating_protocol()\n",
        "  #print(\"Is it best response for agent 2?\")\n",
        "  # fix agent 1\n",
        "  flag=True\n",
        "  per1=true_preference1\n",
        "  prefer2 = [i for i in range(num_of_item)]\n",
        "  prefer2_per = permutations(prefer2)\n",
        "  for per2 in prefer2_per:\n",
        "    tmp_agent1=agent(true_preference1,per1)\n",
        "    tmp_agent2=agent(true_preference2,per2)\n",
        "    tmp_I=fair_division_instance(tmp_agent1,tmp_agent2)\n",
        "    tmp_alloc1,tmp_alloc2=tmp_I.eating_protocol()\n",
        "    #tmp_I.get_alloc()\n",
        "    #print(tmp_alloc2,true_alloc2)\n",
        "    if tmp_agent2.is_sd_prefer(tmp_alloc2,true_alloc2):\n",
        "      flag=False\n",
        "      #print(\"Better one:\")\n",
        "      #print(true_preference2,\" --> \",per2)\n",
        "      \"\"\"\n",
        "      for dig in true_preference2:\n",
        "        print(dig,end=\"\")\n",
        "      print(\" --> \",end=\"\")\n",
        "      for dig in per2:\n",
        "        print(dig,end=\"\")\n",
        "      print(\"\")\n",
        "      \"\"\"\n",
        "      G.add_edge(true_preference2, per2)\n",
        "      #print(\"Bundle 1: \",true_alloc1,\" -> \",tmp_alloc1)\n",
        "      #print(\"Bundle 2: \",true_alloc2,\" -> \",tmp_alloc2)\n",
        "  #if flag:\n",
        "    #print(\"Yes!\")\n",
        "  #print(\"---------------------------------------------------------\\n\\n\")\n",
        "  #return G"
      ],
      "metadata": {
        "id": "UJ1DiFqaGj2N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tQmFy5vk6ZIp",
        "outputId": "40d836b4-582e-4b85-9636-da9352736a63"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (0, 1, 2)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (0, 1, 2)\n",
            "agent1 gets:  [50.0, 50.0, 50.0]\n",
            "agent2 gets:  [50.0, 50.0, 50.0]\n",
            "Is it best response for agent 2?\n",
            "Yes!\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n",
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (0, 2, 1)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (0, 2, 1)\n",
            "agent1 gets:  [50.0, 100, 0]\n",
            "agent2 gets:  [50.0, 0, 100]\n",
            "Is it best response for agent 2?\n",
            "Yes!\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n",
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (1, 0, 2)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (1, 0, 2)\n",
            "agent1 gets:  [100, 0, 50.0]\n",
            "agent2 gets:  [0, 100, 50.0]\n",
            "Is it best response for agent 2?\n",
            "Yes!\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n",
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (1, 2, 0)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (1, 2, 0)\n",
            "agent1 gets:  [100, 0, 50.0]\n",
            "agent2 gets:  [0, 100, 50.0]\n",
            "Is it best response for agent 2?\n",
            "Yes!\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n",
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (2, 0, 1)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (2, 0, 1)\n",
            "agent1 gets:  [100, 50.0, 0]\n",
            "agent2 gets:  [0, 50.0, 100]\n",
            "Is it best response for agent 2?\n",
            "Better one:\n",
            "Misreporting  (2, 0, 1)  ->  (0, 2, 1)\n",
            "Bundle 1:  [100, 50.0, 0]  ->  [50.0, 100, 0]\n",
            "Bundle 2:  [0, 50.0, 100]  ->  [50.0, 0, 100]\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n",
            "---------------------------------------------------------\n",
            "agent1's true preference:  (0, 1, 2)\n",
            "agent2's true preference:  (2, 1, 0)\n",
            "agent1's bid:  (0, 1, 2)\n",
            "agent2's bid:  (2, 1, 0)\n",
            "agent1 gets:  [100, 50.0, 0]\n",
            "agent2 gets:  [0, 50.0, 100]\n",
            "Is it best response for agent 2?\n",
            "Yes!\n",
            "---------------------------------------------------------\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Generate permutations of preferences\n",
        "from itertools import permutations\n",
        "\n",
        "def solve_2agent(num_of_item):\n",
        "  # Define the elements\n",
        "  prefer1 = [i for i in range(num_of_item)]\n",
        "\n",
        "  # Generate permutations\n",
        "  prefer1_per = permutations(prefer1)\n",
        "\n",
        "  # Print the permutations\n",
        "  for per1 in prefer1_per:\n",
        "    prefer2 = [i for i in range(num_of_item)]\n",
        "    prefer2_per = permutations(prefer2)\n",
        "    for per2 in prefer2_per:\n",
        "      #print(per1, per2, type(per1))\n",
        "      check_state(per1, per2)\n",
        "    print(\"\\n\\n\\n\")\n",
        "\n",
        "def solve_2agent_reduced(num_of_item):\n",
        "  # Define the elements\n",
        "  prefer1 = [i for i in range(num_of_item)]\n",
        "\n",
        "  # Generate permutations\n",
        "  prefer1_per = list(permutations(prefer1))\n",
        "\n",
        "  # Print the permutations\n",
        "  prefer2 = [i for i in range(num_of_item)]\n",
        "  prefer2_per = permutations(prefer2)\n",
        "\n",
        "  per1 = prefer1_per[0]\n",
        "  for per2 in prefer2_per:\n",
        "    #print(per1, per2, type(per1))\n",
        "    check_state(per1, per2)\n",
        "  #print(\"\\n\\n\\n\")\n",
        "\n",
        "\n",
        "def build_reporting_edge_graph(num_of_item,G):\n",
        "  # Define the elements\n",
        "  prefer1 = [i for i in range(num_of_item)]\n",
        "\n",
        "  # Generate permutations\n",
        "  prefer1_per = list(permutations(prefer1))\n",
        "\n",
        "  # Print the permutations\n",
        "  prefer2 = [i for i in range(num_of_item)]\n",
        "  prefer2_per = permutations(prefer2)\n",
        "\n",
        "  per1 = prefer1_per[0]\n",
        "  for per2 in prefer2_per:\n",
        "    #print(per1, per2, type(per1))\n",
        "    #G.add_node(per2)\n",
        "    get_reporting_states_graph_edge(per1, per2, G)\n",
        "  #print(\"\\n\\n\\n\")\n",
        "\n",
        "num_of_item=3\n",
        "solve_2agent_reduced(num_of_item)\n",
        "#build_reporting_edge_graph(num_of_item)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Analysis for cases\n",
        "\n",
        "For the scenario of 2 agents with 3 divisible goods.\n",
        "\n",
        "Assume the 3 items are $g_1,g_2,g_3$, 2 agent $1,2$.\n",
        "\n",
        "- There are $36$ cases in total, but by rotational symmetry, it can be reduced to $6$ cases.\n",
        " - For example $1:g_1\\succ g_2\\succ g_3,2:g_1\\succ g_2\\succ g_3$ is equivalent to $1:g_1\\succ g_3\\succ g_2,2:g_1\\succ g_3\\succ g_2$.\n",
        "- The $6$ cases are in the following (Fix the ordinal preference on agent 1 on $g_1\\succ g_2\\succ g_3$, we analysis agent 2 for all permutations on preference):\n",
        "\n",
        "1. agent1's true preference: $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent2's true preference:  $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent 1 gets:  $[50.0, 50.0, 50.0]$\n",
        "  \n",
        "  agent 2 gets:  $[50.0, 50.0, 50.0]$\n",
        "\n",
        "  - Best response for agent 2? **Yes**.\n",
        "    \n",
        "    Because there are no other preference prefile of player 2 inducing high sum of share of first $k$ item for $k=[3]$.\n",
        "\n",
        "2. agent1's true preference: $g_1\\succ g_2\\succ g_3$\n",
        "\n",
        "  agent2's true preference:  $g_1\\succ g_3\\succ g_2$\n",
        "  \n",
        "  agent1 gets:  $[50.0, 100, 0]$\n",
        "  \n",
        "  agent2 gets:  $[50.0, 0, 100]$\n",
        "\n",
        "  - Best response for agent 2? **Yes**.\n",
        "  \n",
        "    First observe that by eating protocol, each agent exactly gain the total share of $150$ item.\n",
        "\n",
        "    The top priority of both agents are $g_1$, thus agent 2 can't manipulate to gain higher than $50$ share of $g_1$ when agent 1 reports truthfully by putting $g_1$ on its top priority.\n",
        "  \n",
        "  - Agent 2 in case 5 has an incentive to deviate to case 2. Then it's natural to ask whether it's the best response for agent 1.\n",
        "\n",
        "    The answer is **Yes**.\n",
        "\n",
        "    - Agent 1 must put $g_1$ on top priority, otherwise it will loss the share of its favorite $g_1$.\n",
        "    - If agent $1$ switch the position of $g_2$ and $g_3$, it will loss the share of second priority $g_2$.\n",
        "\n",
        "3. agent1's true preference:  $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent2's true preference:  $g_2\\succ g_1\\succ g_3$\n",
        "  \n",
        "  agent1 gets:  $[100, 0, 50.0]$\n",
        "  \n",
        "  agent2 gets:  $[0, 100, 50.0]$\n",
        "\n",
        "  - Best response for agent 2? **Yes**.\n",
        "\n",
        "    Here any other misreport which promote share of $g_1$ will hurt the $100$ share of $g_2$.\n",
        "\n",
        "4. agent1's true preference:  $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent2's true preference:  $g_2\\succ g_3\\succ g_1$\n",
        "  \n",
        "  agent1 gets:  $[100, 0, 50.0]$\n",
        "  \n",
        "  agent2 gets:  $[0, 100, 50.0]$\n",
        "\n",
        "  - Best response for agent 2? **Yes**\n",
        "\n",
        "    Indeed, it's the best outcome for both agent: $100$ share of top priority, $50$ share of second priority.\n",
        "\n",
        "5. agent1's true preference:  $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent2's true preference:  $g_3\\succ g_1\\succ g_2$\n",
        "  \n",
        "  agent1 gets:  $[100, 50.0, 0]$\n",
        "\n",
        "  agent2 gets:  $[0, 50.0, 100]$\n",
        "\n",
        "  - Best response for agent 2? **NO!!!**\n",
        "\n",
        "    By misreporting $g_1\\succ g_3\\succ g_2$, the eating protocol allocates:\n",
        "\n",
        "    - agent 1 gets: $[50.0, 100, 0]$\n",
        "    - agent 2 gets: $[50.0, 0, 100]$\n",
        "\n",
        "    Which is strictly better off w.r.t. agent 2.\n",
        "\n",
        "6. agent1's true preference:  $g_1\\succ g_2\\succ g_3$\n",
        "  \n",
        "  agent2's true preference:  $g_3\\succ g_2\\succ g_1$\n",
        "  \n",
        "  agent1 gets:  $[100, 50.0, 0]$\n",
        "  \n",
        "  agent2 gets:  $[0, 50.0, 100]$\n",
        "\n",
        "  - Best response for agent $2$? **Yes**.\n",
        "\n",
        "    Indeed, it's the best outcome for both agent: $100$ share of top priority, $50$ share of second priority.\n",
        "\n",
        "## Graph of reporting states\n",
        "\n",
        "It is worth noting whether there are cycles in the graph $G=(V,E)$ of reporting states.\n",
        "\n",
        "There are $3!\\times3!=36$ reporting states $V$. An **directed** edge in the graph $e=(v_1,v_2)\\in E$ means there are a agent in reporting state node $v_1$ has an incentive to deviate to reporting state $v_2$.\n",
        "\n",
        "By the analysis for 6 cases above, there are no cycle in the graph."
      ],
      "metadata": {
        "id": "mHp5jGY3RKhz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2 Agent, 4 Items"
      ],
      "metadata": {
        "id": "k1jDw4lyeHvx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_of_item=4\n",
        "#solve_2agent_reduced(num_of_item)\n",
        "reporting_state_graph_4=nx.DiGraph()\n",
        "build_reporting_edge_graph(num_of_item,reporting_state_graph_4)"
      ],
      "metadata": {
        "id": "Tuf9v19XeOkd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.figure(figsize=(10, 10))\n",
        "pos = nx.circular_layout(reporting_state_graph_4)\n",
        "nx.draw_networkx(reporting_state_graph_4,pos)\n",
        "print(\"Is there any cycle? \", \"No.\" if nx.is_directed_acyclic_graph(reporting_state_graph_4) else \"Yes.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 825
        },
        "id": "d3eF_hyYvGq1",
        "outputId": "d2266641-dd89-4671-835d-0b488bbe0a5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is there any cycle?  No.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x1000 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2 Agent, 5 Items"
      ],
      "metadata": {
        "id": "Bl_ksUQtl-Kh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_of_item=5\n",
        "#solve_2agent_reduced(num_of_item)\n",
        "reporting_state_graph_5=nx.DiGraph()\n",
        "build_reporting_edge_graph(num_of_item,reporting_state_graph_5)\n",
        "print(\"Is there any cycle? \", \"No.\" if nx.is_directed_acyclic_graph(reporting_state_graph_5) else \"Yes.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EiuEKfGVmC4O",
        "outputId": "fd629f36-9994-43cf-a869-9ba27dbf8cc5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is there any cycle?  No.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(100, 100))\n",
        "pos = nx.circular_layout(reporting_state_graph_5)\n",
        "nx.draw_networkx(reporting_state_graph_5,pos)"
      ],
      "metadata": {
        "id": "O6kALQ8KtaHl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# What about $n$ items?\n",
        "\n",
        "Trying 6,7... items using brute force.\n",
        "\n",
        "There is no cycle for 6 and 7 items.\n",
        "\n",
        "Brute force running time: ~6min 30s."
      ],
      "metadata": {
        "id": "Lw1bIEMrzOFF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for num in range(6,8):\n",
        "  num_of_item = num\n",
        "  tmp_reporting_state_graph=nx.DiGraph()\n",
        "  build_reporting_edge_graph(num_of_item,tmp_reporting_state_graph)\n",
        "  print(\"Is there any cycle in \", num_of_item, \" items? \", \"No.\" if nx.is_directed_acyclic_graph(tmp_reporting_state_graph) else \"Yes.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nPwtlgLjzW2P",
        "outputId": "49561568-42d0-4eda-97ed-6506f01476e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is there any cycle in  6  items?  No.\n",
            "Is there any cycle in  7  items?  No.\n"
          ]
        }
      ]
    }
  ]
}