Nash equilibrium.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "79a065f1",
   "metadata": {},
   "source": [
    "# <span style=\"font-family: Cambria;\"> Nash equilibrium </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6d55ea5",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">In this project i want to calculate Nash equilibrium in bayesian games like game below:</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b900ab6",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 16px\">Bach or Stravinsky? Variant of BoS with imperfect information 2\n",
    "Consider a variant of BoS in which neither player knows whether the other wants to go out with her. Specifically, suppose that player 1 thinks that with probability ½ player 2 wants to go out with her, and with probability ½ player 2 wants to avoid her, and player 2 thinks that with probability 2/3 player 1 wants to go out with her and with probability 1/3 player 1 wants to avoid her. As before, assume that each player knows her own preferences.\n",
    "We can model this situation by introducing 4 states, one for each possible configuration of preferences. We refer to these states as:\n",
    "</span>\n",
    "<br>\n",
    "<br>\n",
    "<span style=\"font-family: Cambria; font-size : 16px\">\n",
    " yy: each player wants to go out with the other.<br>\n",
    " yn: player 1 wants to go out with player 2 but player 2 wants to avoid player 1.<br>\n",
    " ny: player 1 wants to avoid player 2 and player 2 wants to go out with player 1.<br>\n",
    " nn: both players want to avoid the other.\n",
    " <br>\n",
    " <br>\n",
    "The fact that player 1 does not know player 2’s preferences means that she cannot distinguish between states yy and yn, or between states ny and nn. Similarly, player 2 cannot distinguish between states yy and ny, or between states yn and nn. We can model the players’ information by assuming that each player receives a signal before choosing an action. Player 1 receives the same signal, say 𝑦1, in states yy and yn, and a different signal, say 𝑛1, in states ny and nn; player 2 receives the same signal, say 𝑦2, in states yy and ny, and a different signal, say 𝑛2, in states yn and nn. After player 1 receives the signal 𝑦1, she is referred to as type 𝑦1 of player 1 (who wishes to go out with player 2); after she receives the signal 𝑛1, she is referred to as type 𝑛1 of player 1 (who wishes to avoid player 2). In a similar way, player 2 has two types: 𝑦2 and 𝑛2.Type 𝑦1 of player 1 believes that the probability of each of the states yy and yn is ½; type 𝑛1 of player 1 believes that the probability of each of the states ny and nn is ½. Type 𝑦2 of player 2 believes that the probability of state yy is 2/3 and that of state ny is 1/3; type 𝑛2 of player 2 believes that the probability of state yn is 2/3 and that of state nn is 1/3. \n",
    " <br>We can represent the game as:</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "285ec2ee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0e5bf8aa",
   "metadata": {},
   "source": [
    "![image](bayesiangames.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7248d17",
   "metadata": {},
   "source": [
    "## <span style=\"font-family: Cambria; font-size : 18px\">Step1: receiving P1 & P2</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f3720d5",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">We receive input parameters P1 and P2 from users as our input possibilities</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92a15640",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your P1 : 1/2\n",
      "Enter your P2 : 2/3\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "input_str_1 = input(\"Enter your P1 : \")\n",
    "input_str_2 = input(\"Enter your P2 : \")\n",
    "\n",
    "try:\n",
    "    p1 = Fraction(input_str_1)\n",
    "    p2 = Fraction(input_str_2)\n",
    "except ValueError:\n",
    "    print(\"Invalid input. Please enter fractions in the format 'numerator/denominator'.\")\n",
    "\n",
    "p2 = Fraction(p2)\n",
    "p1 = Fraction(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f624b6",
   "metadata": {},
   "source": [
    "## <span style=\"font-family: Cambria; font-size : 18px\">Step2: receiving inputs</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3676c80e",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">Now, we are ready to receive inputs for our matrices.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1901922a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "48558247",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter element at position (1,1): 2\n",
      "Enter element at position (1,2): 1\n",
      "Enter element at position (1,3): 0\n",
      "Enter element at position (1,4): 0\n",
      "Enter element at position (1,5): 2\n",
      "Enter element at position (1,6): 0\n",
      "Enter element at position (1,7): 0\n",
      "Enter element at position (1,8): 2\n",
      "Enter element at position (2,1): 0\n",
      "Enter element at position (2,2): 0\n",
      "Enter element at position (2,3): 1\n",
      "Enter element at position (2,4): 2\n",
      "Enter element at position (2,5): 0\n",
      "Enter element at position (2,6): 1\n",
      "Enter element at position (2,7): 1\n",
      "Enter element at position (2,8): 0\n",
      "Enter element at position (3,1): 0\n",
      "Enter element at position (3,2): 1\n",
      "Enter element at position (3,3): 2\n",
      "Enter element at position (3,4): 0\n",
      "Enter element at position (3,5): 0\n",
      "Enter element at position (3,6): 0\n",
      "Enter element at position (3,7): 2\n",
      "Enter element at position (3,8): 2\n",
      "Enter element at position (4,1): 1\n",
      "Enter element at position (4,2): 0\n",
      "Enter element at position (4,3): 0\n",
      "Enter element at position (4,4): 2\n",
      "Enter element at position (4,5): 1\n",
      "Enter element at position (4,6): 1\n",
      "Enter element at position (4,7): 0\n",
      "Enter element at position (4,8): 0\n"
     ]
    }
   ],
   "source": [
    "matrix = [[0] * 8 for _ in range(4)]\n",
    "\n",
    "for i in range(4):\n",
    "    for j in range(8):\n",
    "        matrix[i][j] = int(input(f\"Enter element at position ({i+1},{j+1}): \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0a7fcc29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1, 0, 0, 2, 0, 0, 2]\n",
      "[0, 0, 1, 2, 0, 1, 1, 0]\n",
      "[0, 1, 2, 0, 0, 0, 2, 2]\n",
      "[1, 0, 0, 2, 1, 1, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "for row in matrix:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4535c8c2",
   "metadata": {},
   "source": [
    "## <span style=\"font-family: Cambria; font-size : 18px\">Step3: creating matrices</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2164535",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">in this step we should create 4 matrices like image below to calculate best responses for each player </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55462e03",
   "metadata": {},
   "source": [
    "![image](second_matrices.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7f2c77",
   "metadata": {},
   "source": [
    "## y1 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "69740d3c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# matrix y1\n",
    "y1 = [None] * 8\n",
    "y1[0] = (p1 * matrix[0][0]) + ((1-p1) * matrix[0][4])\n",
    "y1[1] = (p1 * matrix[0][0]) + ((1-p1) * matrix[0][6])\n",
    "y1[2] = (p1 * matrix[0][2]) + ((1-p1) * matrix[0][4])\n",
    "y1[3] = (p1 * matrix[0][2]) + ((1-p1) * matrix[0][6])\n",
    "\n",
    "y1[4] = (p1 * matrix[1][0]) + ((1-p1) * matrix[1][4])\n",
    "y1[5] = (p1 * matrix[1][0]) + ((1-p1) * matrix[1][6])\n",
    "y1[6] = (p1 * matrix[1][2]) + ((1-p1) * matrix[1][4])\n",
    "y1[7] = (p1 * matrix[1][2]) + ((1-p1) * matrix[1][6])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f8b77c54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Fraction(2, 1), Fraction(1, 1), Fraction(1, 1), Fraction(0, 1), Fraction(0, 1), Fraction(1, 2), Fraction(1, 2), Fraction(1, 1)]\n"
     ]
    }
   ],
   "source": [
    "print (y1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8657dcad",
   "metadata": {},
   "source": [
    "## n1 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "58d1b220",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix n1\n",
    "n1 = [None] * 8\n",
    "n1[0] = (p1 * matrix[2][0]) + ((1-p1) * matrix[2][4])\n",
    "n1[1] = (p1 * matrix[2][0]) + ((1-p1) * matrix[2][6])\n",
    "n1[2] = (p1 * matrix[2][2]) + ((1-p1) * matrix[2][4])\n",
    "n1[3] = (p1 * matrix[2][2]) + ((1-p1) * matrix[2][6])\n",
    "\n",
    "n1[4] = (p1 * matrix[3][0]) + ((1-p1) * matrix[3][4])\n",
    "n1[5] = (p1 * matrix[3][0]) + ((1-p1) * matrix[3][6])\n",
    "n1[6] = (p1 * matrix[3][2]) + ((1-p1) * matrix[3][4])\n",
    "n1[7] = (p1 * matrix[3][2]) + ((1-p1) * matrix[3][6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a0d0857f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Fraction(0, 1), Fraction(1, 1), Fraction(1, 1), Fraction(2, 1), Fraction(1, 1), Fraction(1, 2), Fraction(1, 2), Fraction(0, 1)]\n"
     ]
    }
   ],
   "source": [
    "print (n1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd44671c",
   "metadata": {},
   "source": [
    "## y2 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "266e6764",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix y2\n",
    "y2 = [None] * 8\n",
    "y2[0] = (p2 * matrix[0][1]) + ((1-p2) * matrix[2][1])\n",
    "y2[1] = (p2 * matrix[0][3]) + ((1-p2) * matrix[2][3])\n",
    "y2[2] = (p2 * matrix[0][1]) + ((1-p2) * matrix[3][1])\n",
    "y2[3] = (p2 * matrix[0][3]) + ((1-p2) * matrix[3][3])\n",
    "\n",
    "y2[4] = (p2 * matrix[1][1]) + ((1-p2) * matrix[2][1])\n",
    "y2[5] = (p2 * matrix[1][3]) + ((1-p2) * matrix[2][3])\n",
    "y2[6] = (p2 * matrix[1][1]) + ((1-p2) * matrix[3][1])\n",
    "y2[7] = (p2 * matrix[1][3]) + ((1-p2) * matrix[3][3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "49654a97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Fraction(1, 1), Fraction(0, 1), Fraction(2, 3), Fraction(2, 3), Fraction(1, 3), Fraction(4, 3), Fraction(0, 1), Fraction(2, 1)]\n"
     ]
    }
   ],
   "source": [
    "print (y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae5d80b",
   "metadata": {},
   "source": [
    "## n2 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7eea6c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix n2\n",
    "n2 = [None] * 8\n",
    "n2[0] = (p2 * matrix[0][5]) + ((1-p2) * matrix[2][5])\n",
    "n2[1] = (p2 * matrix[0][7]) + ((1-p2) * matrix[2][7])\n",
    "n2[2] = (p2 * matrix[0][5]) + ((1-p2) * matrix[3][5])\n",
    "n2[3] = (p2 * matrix[0][7]) + ((1-p2) * matrix[3][7])\n",
    "\n",
    "n2[4] = (p2 * matrix[1][5]) + ((1-p2) * matrix[2][5])\n",
    "n2[5] = (p2 * matrix[1][7]) + ((1-p2) * matrix[2][7])\n",
    "n2[6] = (p2 * matrix[1][5]) + ((1-p2) * matrix[3][5])\n",
    "n2[7] = (p2 * matrix[1][7]) + ((1-p2) * matrix[3][7])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f3d52fe2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Fraction(0, 1), Fraction(2, 1), Fraction(1, 3), Fraction(4, 3), Fraction(2, 3), Fraction(2, 3), Fraction(1, 1), Fraction(0, 1)]\n"
     ]
    }
   ],
   "source": [
    "print (n2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "946e61ad",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(4, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2[4]+n2[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f705e6e3",
   "metadata": {},
   "source": [
    "## <span style=\"font-family: Cambria;\">Step4: compare values</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee9155d",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">Now, we should compare values of those matrices to find the bestresponce for every action.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b4d106d",
   "metadata": {},
   "source": [
    "### comparing values of y1 and n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8e93cd4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[('B', 'B'), ('B', 'S')], [('B', 'S'), ('B', 'B')], [('S', 'B'), ('B', 'B')], [('S', 'S'), ('S', 'B')]]\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "\n",
    "def Best_response(i, input_list):\n",
    "    if i == 0:\n",
    "        input_list.insert(0, ('B', 'B'))\n",
    "    elif i == 1:\n",
    "        input_list.insert(0, ('B', 'S'))\n",
    "    elif i == 2:\n",
    "        input_list.insert(0, ('S', 'B'))\n",
    "    elif i == 3:\n",
    "        input_list.insert(0, ('S', 'S'))\n",
    "    return input_list\n",
    "\n",
    "\n",
    "\n",
    "result_list1 = []\n",
    "result_list2 = []\n",
    "result_list3 = []\n",
    "result_list4 = []\n",
    "final_list = []\n",
    "i=0\n",
    "\n",
    "\n",
    "for i in range(0, 4):\n",
    "    if y1[i] > y1[i + 4]:\n",
    "        y1_result = \"B\"\n",
    "    elif y1[i] == y1[i + 4]:\n",
    "        y1_result = \"S\"\n",
    "        y2_result = \"B\"\n",
    "    else:\n",
    "        y1_result = \"S\"\n",
    "\n",
    "    if n1[i] > n1[i + 4]:\n",
    "        n1_result = \"B\"\n",
    "    elif n1[i] == n1[i + 4]:\n",
    "        n1_result = \"S\"\n",
    "        n2_result = \"B\"\n",
    "    else:\n",
    "        n1_result = \"S\"\n",
    "        \n",
    "    if y1[i] == y1[i + 4] and n1[i] == n1[i + 4]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y2_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list2))\n",
    "        result_list3.append((y1_result, n2_result))\n",
    "        final_list.append(Best_response(i, result_list3))\n",
    "        result_list4.append((y2_result, n2_result)) \n",
    "        final_list.append(Best_response(i, result_list4))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "        result_list3 = []\n",
    "        result_list4 = []\n",
    "        \n",
    "    elif n1[i] == n1[i + 4]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y1_result, n2_result))\n",
    "        final_list.append(Best_response(i, result_list2))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "    elif y1[i] == y1[i + 4]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y2_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list2))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "    else:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list.append(Best_response(i, result_list1))\n",
    "        result_list1 = []\n",
    "        \n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acf04195",
   "metadata": {},
   "source": [
    "### comparing values of y2 and n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9cb978d6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[('B', 'B'), ('B', 'S')], [('B', 'S'), ('S', 'S')], [('B', 'S'), ('B', 'S')], [('S', 'B'), ('S', 'S')], [('S', 'B'), ('S', 'B')], [('S', 'S'), ('S', 'B')]]\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "\n",
    "def Best_response(i, input_list):\n",
    "    if i == 0:\n",
    "        input_list.insert(0, ('B', 'B'))\n",
    "    elif i == 1:\n",
    "        input_list.insert(0, ('B', 'S'))\n",
    "    elif i == 2:\n",
    "        input_list.insert(0, ('S', 'B'))\n",
    "    elif i == 3:\n",
    "        input_list.insert(0, ('S', 'S'))\n",
    "    return input_list\n",
    "\n",
    "\n",
    "result_list1 = []\n",
    "result_list2 = []\n",
    "result_list3 = []\n",
    "result_list4 = []\n",
    "final_list2 = []\n",
    "i=0\n",
    "\n",
    "for i in range(0, 4):\n",
    "    j=2*i\n",
    "    if y2[j] > y2[j + 1]:\n",
    "        y1_result = \"B\"\n",
    "    elif y2[j] == y2[j + 1]:\n",
    "        y1_result = \"S\"\n",
    "        y2_result = \"B\"\n",
    "    else:\n",
    "        y1_result = \"S\"\n",
    "\n",
    "    if n2[j] > n2[j + 1]:\n",
    "        n1_result = \"B\"\n",
    "    elif n2[j] == n2[j + 1]:\n",
    "        n1_result = \"S\"\n",
    "        n2_result = \"B\"\n",
    "    else:\n",
    "        n1_result = \"S\"\n",
    "        \n",
    "    if y2[j] == y2[j + 1] and n2[j] == n2[j + 1]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y2_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list2))\n",
    "        result_list3.append((y1_result, n2_result))\n",
    "        final_list2.append(Best_response(i, result_list3))\n",
    "        result_list4.append((y2_result, n2_result)) \n",
    "        final_list2.append(Best_response(i, result_list4))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "        result_list3 = []\n",
    "        result_list4 = []\n",
    "        \n",
    "    elif  n2[j] == n2[j + 1]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y1_result, n2_result))\n",
    "        final_list2.append(Best_response(i, result_list2))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "    elif y2[j] == y2[j + 1]:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list1))\n",
    "        result_list2.append((y2_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list2))\n",
    "        result_list1 = []\n",
    "        result_list2 = []\n",
    "    else:\n",
    "        result_list1.append((y1_result, n1_result))\n",
    "        final_list2.append(Best_response(i, result_list1))\n",
    "        result_list1 = []\n",
    "        \n",
    "print(final_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d88e2f",
   "metadata": {},
   "source": [
    "## <span style=\"font-family: Cambria;\">Finding Nash equilibrium</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b51f552",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">Now, in the final step we compare our final lists. the common elements are the nash equilibrium of our question.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a56969",
   "metadata": {},
   "source": [
    "![image](nashfinal.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6e5a0862",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nash equilibrium is:\n",
      "[[('B', 'B'), ('B', 'S')], [('S', 'S'), ('S', 'B')]]\n"
     ]
    }
   ],
   "source": [
    "common_elements = [element for element in final_list if element in final_list2]\n",
    "\n",
    "print(\"Nash equilibrium is:\")\n",
    "print(common_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b8890c2",
   "metadata": {},
   "source": [
    "<span style=\"font-family: Cambria; font-size : 18px\">Kiarash Rahmani</span>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}