Analytical method for calculating fixation times and fixation probabilities in RSP evolutionary game.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "# N is the size of population\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import seaborn as sns\n",
    "import math\n",
    "N=50\n",
    "n=int((N+1)*(N+2)/2)\n",
    "A=np.zeros((n, n))\n",
    "j1=int(1)\n",
    "j2=int(2)\n",
    "II=np.identity(n-3)\n",
    "\n",
    "ta=10\n",
    "def tag(x):\n",
    "    return(round(x,ta))"
   ]
  },
  {
   "attachments": {
    "matrsp.JPG": {
     "image/jpeg": "/9j/4AAQSkZJRgABAQEAYABgAAD/4RDcRXhpZgAATU0AKgAAAAgABAE7AAIAAAAGAAAISodpAAQAAAABAAAIUJydAAEAAAAMAAAQyOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1haGRpAAAFkAMAAgAAABQAABCekAQAAgAAABQAABCykpEAAgAAAAM3MgAAkpIAAgAAAAM3MgAA6hwABwAACAwAAAiSAAAAABzqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjAyMToxMToxMyAxMzoyNDozNwAyMDIxOjExOjEzIDEzOjI0OjM3AAAATQBhAGgAZABpAAAA/+ELGGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSfvu78nIGlkPSdXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQnPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iLz48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyI+PHhtcDpDcmVhdGVEYXRlPjIwMjEtMTEtMTNUMTM6MjQ6MzcuNzE1PC94bXA6Q3JlYXRlRGF0ZT48L3JkZjpEZXNjcmlwdGlvbj48cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyI+PGRjOmNyZWF0b3I+PHJkZjpTZXEgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj48cmRmOmxpPk1haGRpPC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIAL0BcQMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APpGiiigAooooAKKKKACiiigDI1nVZ9O1bw/awJGyalqD2sxcElVFrPNlcHg7olHOeCfqNeub8Uf8jF4M/7DUn/pvvK6SgAooooAKKK5H4leHdG1nwRrFxq2lWd7cWunXDW808Cu8J2E5RiMryAePSplLli2VGPNJR7nXUV5H8GfA/hTUfhHoN9qHhrSLq7liZnuJ7GN5GPmNyWK57DvTvHmrzfCjxFoGqaTNL/Yep3Ysr/THkLxoSPlkiB+4QAcgcHHTvWjjafJ52M4y5oc3zPWqKOtFSUFFFFABRRRQAUUUUAFFFFABRXCver4p+KWpeHbyRxp2iWcMz2isVF1LLuOXx95FUD5ehLc5wKua74RisfDN/8A8IPFDoWorbyeR9ijEcTMVPDRjCnJ74yDyD6qTtHmKSvLlOuorG8HFj4H0MyZLf2fBuJ658ta2auUeWTRnGXNFMKKKKkoKKKKACiiigAooooAKK8R/aL8NaInhay1WPSLJNRn1e3jmu0t1WWVSGBDMBlhgDr6V6TH8OvBSBWj8I6HGwAw6adErD3BC5B96Fqr+dvwT/UHo7eV/wAWv0Olorye21668EfHO08Gi5mudD1y0NxaxTyGRrOUb8qrHJ2HYflJOM8YFesUdE0D0dmFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAHN+KP+Ri8Gf9hqT/ANN95XSVzfij/kYvBn/Yak/9N95XSUAFFFFABWF43/5J/wCIP+wZcf8Aotq3awvG/wDyT/xB/wBgy4/9FtWdX+HL0ZpS/iR9Ucf8Fb+4g+DGgLHpN5OqwPh4mhw37xum6QH9KhurGD4p+OLJNXcafaeG5vtLaLNxdyy/wvIOgj442lg2eorU+Bv/ACRTw7/1wf8A9GNXM+Obw6P+0x4Guk/dLfWstpK448wEsAp9cFlrpn/Ht5v79bHNT/gX8vw6nstFRieI3LW4cGVUDlO4UkgH8wfyqSsjUKKKKACiiigAooooAKKKKAPNPiB8P/EF74mt/GHw81WLTdfhh+zzx3H+pu4gchW4PI+npyMZrnR8V/iF4MZG+J/glV0zzNkup6Y+5YweAxUFh+ZX8+K9C0bxVBP4+8Q+HLmcrc2ssMtur9GR4UJVT6ghjj3zWt4pk0+LwnqjazsNh9lkE4cZDKVIxjuT0+tS24xutVuVZSlZl3T7i0u9NtrjTWje0liV4GjHylCMrj2xViuT+F2lXmifC7QNP1NWS6htF8xH6pnLBT9AQPwrrK0mkpNIzi24psKKKKkoKKKKACiiigAooooA8j/aOOPh7ppALEazbcDvw9ehnW9QWLK+GNVY44AltRn/AMjV57+0b/yT7TP+w1bfyavWl+6PpRH4X6/pEJfEvT9WcJpngi81H4mN458UCGK4t7f7LpthC+8W6c5d3wAXO48DgZ6nrXeUUUdLB1uFFFFABRRRQAUUUUAFFVtQ1Kx0iwkvtVvLextIseZcXMqxxpkgDLMQBkkD6msT/hY/gj/ocvD/AP4NIP8A4qgDpKK5v/hY/gj/AKHLw/8A+DSD/wCKo/4WP4I/6HLw/wD+DSD/AOKoA6Siub/4WP4I/wChy8P/APg0g/8AiqP+Fj+CP+hy8P8A/g0g/wDiqAOkorm/+Fj+CP8AocvD/wD4NIP/AIqj/hY/gj/ocvD/AP4NIP8A4qgA8Uf8jF4M/wCw1J/6b7yukrzvxH4+8Hz694Tkg8WaHIlvq0kkzJqUJEa/YbpdzENwNzKMnuwHeug/4WP4I/6HLw//AODSD/4qgDpKK5v/AIWP4I/6HLw//wCDSD/4qj/hY/gj/ocvD/8A4NIP/iqAOkrG8QeFdL8UQCDWReSQbGRoYNQuLdJFPUOsbqH/AOBZqp/wsfwR/wBDl4f/APBpB/8AFUf8LH8Ef9Dl4f8A/BpB/wDFUbhsP8NeBdB8IqqeH4ry1hRSq27alcywqCcnEbyFAc98Zq1r/hXRfFEduuu2CXRtZPNt5NzJJC/95HUhlP0NUv8AhY/gj/ocvD//AINIP/iqP+Fj+CP+hy8P/wDg0g/+KovfcNjastOt7BW+ziQs+NzzTPK7AdAWck4GTxnuatVzf/Cx/BH/AEOXh/8A8GkH/wAVR/wsfwR/0OXh/wD8GkH/AMVQB0lFc3/wsfwR/wBDl4f/APBpB/8AFUf8LH8Ef9Dl4f8A/BpB/wDFUAdJRXN/8LH8Ef8AQ5eH/wDwaQf/ABVH/Cx/BH/Q5eH/APwaQf8AxVAHSUVzf/Cx/BH/AEOXh/8A8GkH/wAVR/wsfwR/0OXh/wD8GkH/AMVQB0lFc3/wsfwR/wBDl4f/APBpB/8AFUf8LH8Ef9Dl4f8A/BpB/wDFUAas2haXcfavtFjDL9rkWWfeu7e6qFVuehAUYx0xVSLwlo8V0s7wT3LI4kjW7vJrhI2HQokjsqkewFVf+Fj+CP8AocvD/wD4NIP/AIqj/hY/gj/ocvD/AP4NIP8A4qgNzpKK5v8A4WP4I/6HLw//AODSD/4qj/hY/gj/AKHLw/8A+DSD/wCKoA6Siub/AOFj+CP+hy8P/wDg0g/+Ko/4WP4I/wChy8P/APg0g/8AiqAOkorm/wDhY/gj/ocvD/8A4NIP/iqP+Fj+CP8AocvD/wD4NIP/AIqgDpKK5v8A4WP4I/6HLw//AODSD/4qj/hY/gj/AKHLw/8A+DSD/wCKoA6Siub/AOFj+CP+hy8P/wDg0g/+Ko/4WP4I/wChy8P/APg0g/8AiqAIfEfw18MeLZmk8RWt7fAuJBC+qXQiRgMZWMSBF49AK2tH0S00K0a2sHvGiLbsXd9NckcYwDK7EDjoDisv/hY/gj/ocvD/AP4NIP8A4qj/AIWP4I/6HLw//wCDSD/4qhaKyDc6Siub/wCFj+CP+hy8P/8Ag0g/+Ko/4WP4I/6HLw//AODSD/4qgDpKK5v/AIWP4I/6HLw//wCDSD/4qj/hY/gj/ocvD/8A4NIP/iqAOkorm/8AhY/gj/ocvD//AINIP/iqu6V4s8Oa9dNa6Hr+l6lcIhkaKzvY5nVQQCxCknGSBn3FAGvRRRQAUUUUAFcV4z+Jlv4FAl1rw5rb2bzrbxXlsLZ45XYZAAMwcdx8yjpXa15J+0b/AMk/0z/sNW38mo+0l3aX3uw+jfZN/crncReKdRYg3HgzXrePGTIzWb4/4DHcM35CtDQ/EeleI7WSbSLpZvJcxzRspSSFx1V0YBlPsQK0l+6PpXjln9oj/a1v10X/AI9H0hG1UJ93fj5C3+19zHtmmtZcvr+GpP2eb0/yPZKKKKQzm/FH/IxeDP8AsNSf+m+8rpK5vxR/yMXgz/sNSf8ApvvK6SgAooooAKKKbI4jjZ26KCTSbsrgU7rWbG0uxaSzM9zs3mCGNpZAv94qgJA9zxUljqVnqcTvYzrKI32SKMho2/usp5U+xANcJ8Fr19e8Kah4muTvudZ1OeZnPUIrbI0+iquAKbquoHQf2gtEhhO2HxFps0Nwg6NJD8yOffBK59Kqzuovd/5X/wCAJ6Jvt/nb/gno9FFFIYUUUUAFFFFABRRRQAUUUUAFFFMlmjt4WlnkWKNBlndgAo9yaAH0VWh1KxuI1e3vbeVGfywySqwLf3eD19qs0AFFFFABRRRQAUUUUAFFFFAHM2XjuwvfG7eFfsOowaitsbsmeELH5QbbuzuzyeBxXTV5j4QvLW8+K3jfxHe3MENvbyw6PbSSuFA8td0gyf8AaNelxTRzwrLBIssbjKujAhh6gin9lPy/Pb8LA/ia/rz/ABH0UUUgCiiigAooooAKKKKACiiigAryT9o4Z+HumgHH/E6tuR24evW68c+PVzca34dtdG0XRtb1C8tdUhnlFtpFy8YRQSSJNmxuo+6TS+1H1X5of2Zej/JnpF/o2qXOnSRWPiS+tJ2X5JTBA4U/Tyx/MVy3wn1WwuW1/Sv7Mjsdc0y+MeqOsjSm6c52zb2yxBwcAnjpXaaNrNvrVmZ7WG+hCHay3tjNatnGeFlVSR7jI968w8NaVq3g346+K73UdOvZdH15Fmt7y1tnnQOOdrBASp5bqMcD1ql8dn1T/Rkv4L9mj1+iq9jNNcWvm3EPklnbYh4OzJ2kjsSMHHbNWKQzm/FH/IxeDP8AsNSf+m+8rpK5vxR/yMXgz/sNSf8ApvvK6SgAooooAKr6gjSaZdIn3mhcD64NWKKmS5otDTs7nl37OvHwX01T95Z7gMPQ+a1V/HkbTftDfDlU5KR3jt7DZXQ+ENJm8B3GraTLbTy6TcXsl7YT28TS+WJOWhZVBK7WyQcYIPXNSWOg3OsfE1vFt/A9va2NkbLTYZRh3LNuklK9VzwoB5xkkCtea9SM/wCtv8yWrRlH+t/8jtKKKKgYUUUUAFFFFABVPVr99M0ua8isLrUGiAItrNVaWTnHyhmUe/JFXKKAOK/4WHef9E/8Xf8AgNbf/H6P+Fh3n/RP/F3/AIDW3/x+u1ooAw/D3iSfXpJ1n8O6zo4iAIbUookEmey7JG6e+K5PQtQfx78Ttaln+fQ/DMy2lrBnKTXfV5WHcp0XPTOetekVwfgfR5fBMviGxu7S4k+26vNf280ELSLMkuCASBhWBBU7iOmelNW5r+X46fpcH8Pz/DX/AIBm+K7SHWvj14RsYxzp1tPqd0AeoHyQ5HqGZsfU139/qT291FZ2VuLm8mVnVGfYiquMs7YOBkgcAkk9OpHDabp+uWXxM8Ta5qWnOZ7+yt7fSfKUyIijduR3AwpDEE5454zXYHwzp763p+tXPmyajp9s1vHOZmAKsBu3LnDZxnmhfCk/P9f+AmEvib9P0/4JW0rxUt14mufDuqWv2DVoIBcrGsvmRzwk43xvhScHggqCK6GuD02xl8S/FX/hK4lMek6bYvY2cv8Az+O7Zd19YxgAHuckcc13lHRf11/ysHVr+tv8wooopAFFFFABVTVb+LStHvNQuDtitYHmcnsFUk/yq3WT4q0dvEPhHVtHSQRtfWcturnopZSAf1qZ35XYqNuZX2OP+CmgLYeAbbWbtC2pa28moTyMScea24Bc/dGNucdTVLwH4qt7FvHl3cSeXo1hrrx2wyAA7bQyrnAGZDnqBlq6OzvtUs/A9lpmlaTOutRWaWyxTRskMEiqFLNJjaUBGflJJHQVL4b+H2kaJ4FTw1fQRapDITLetcxhhczM25nYH/a6emBWsrc8mttl96/JL8fUzjdxXNve7+5/qye+8WHRNS0u31+0jtYdVn+zW1xDcGVRKQSqPlVxuA4IyM8e9dJXmvjVQfEnhmTxjFBYaDZ6gjWjWkplD3WCIhLlF8tBzjG4E4yQBz6VU6ct/P8Ay/r0sVs7eX+f9feFFFFIAooooAKKKKACiiigAooooAKKKKACiiigDm/FH/IxeDP+w1J/6b7yukrm/FH/ACMXgz/sNSf+m+8rpKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACuS8d2XjPUba2tvBo0MQlibwatLMBKvZAIlzg9/mGemME11tFLcd7HF+F7P4hHWo5PGr+Go9Pt4WEMWifaAxc4A3CTjaBnp3NdpRRVXJCiiikMKKKKACiiigArF8VeHv+El0mOzF7c2ZiuI7gPbTNGX2NnYSvO09P1raooA43xZ4Tv/HFpZabrH2Wx02G7jupxbzNNJPsOQgJRQozjJ5PbHeuyAwMCiijpYOtwooooAKKKKACiiigAooooAKzvEGt2vhvw7fazqG77PZQtM4Xq2B0HuTx+NaNYHjnw3/wl/gfVdCEgie8gKRyHorjlSfbIFTK6WhUbcyuQ2Fh4i1Oztr/AFHXJtNnkXzDY2UELRICMhGaRGdiO5Urk9hVTTvEGuN8Sm8OapBEtvDpZuhcxLhbpjKqggHJXAzlcnlvpXnumfHO98GW9vo3xS8MapY3dtiA6hBEHhnwMbxnGc4/hLf0r0zwt4j8M+Omj8QeG79bxreJ7ZsAq0YYqxDKQCDlBj8etaac11tr+Whnry2ej0/PU6aiiipKOb8Uf8jF4M/7DUn/AKb7yukrm/FH/IxeDP8AsNSf+m+8rpKACiiigArgfi5rWu+HfC8d94a1MWt7NdQ2kELW6SCV5HC/xdMDJ/Cu+ry74k3gvfid4F0AQS3IjupNUliiXJJiQiPPYDcTySBxQtZRXn/w/wCA9k35P/gfienQq6W8azP5kgUBnxjcccnin1hS+JGsNf0/StZtUtn1PetpLFN5iO6DcUbKqQ23JHUHB59d2n5k7aBRRRSGFFFFABRRRQAUUUUAFFFFAGF4h8SrpF9pul2kK3OqarK0dtAz7VCqNzyMeSFUfmSB3qtrviC98J2kWpa2ba50zzUiuZreJomtQxCiQgs25ckZ6EA55rkri6a6/aos7WQ5Sz8Ou8Y/us8nJ/LFdF8W0WT4QeJw4yBp0rD6gZH6ik3ywU/X8G1+g0rz5fT8Vf8AU7EEMoKnIPIIornPh7fSal8NvDt5OS0s2nQM7Hudgya6OrnHlk49iIu8UwoooqSgooooAKKKKACiiigAoorN13XrDw7ppvdTlKIXWONEXc80jHCoi9WYnoKANKiuV8ReM5fCfhi41/XdJeKzhj3MkM4klUn7qsuABk4XIZgCR25ro7G5N7p1vdGJoTPEshjf7yZGcH3GaAJ6KKKACiiigAooooAKKKKACsvxFrKaBo51CYoIknhjkZzgKryqhP4Bs/hWpWR4p8O2vizw7caNqDMLW5aPzQvVlV1Yr+O3GfegatfU1ZI454ikqLIjDlWGQfwry2Pw1aeFP2gtMl8M26Wdtrem3LajawDbHmMqVk2jgElgPz9TXbjRNV0+HydB1lIYAQEhv7U3KxL/AHVIdGx6bi2PpxUuleHksNTuNVvLl77U7lBG9zIoUJGDkRoo+6uST3JPUmmtJX9fysS7uNvT8zYooopDOb8Uf8jF4M/7DUn/AKb7yukrm/FH/IxeDP8AsNSf+m+8rpKACiiigArzrw3E2q/HTxdqs68aVaWumW+ewZfNc/mRXotYp8Pvba9e6tpFzHaz36It0ksJlRygIVwAykNg4POCAOOKFo7/ANf1a6+YPVWOL8YmbXvjd4N0ayyY9IWXVb1h/wAsxjZGCfc5GPernxZjurfQbS7h1O8jR9WsYzbIyrHgzoCDhQxz6FiPaur0Tw5aaLNeXSNJc39+4ku7ybBeUgYUccBQOAo4H1ya5r4wEDwfY54/4nNh/wClCU46OC81+LX/AAwpa8z8n+Cf6neUUUUhhRRRQAUUUUAFFFFABRRRQB5bfWjWH7UOl30gxFqWgSwRtnq8b7iPyIre+MFwlt8H/ErOQN9i8Yyepb5QPzNb2u+HbXXfscsjyW95YTCe0uosb4Xxg9eCpBIIPUH8arah4ak142sfiG8jurS2mWcWsEBiSWRTlTJlmLAHBwMDI5zSa5oKL/pN3/Uadpc3p+Ct+gvgbTJNG+H+g6dONsttp8Mcg9GCDP61vUUVcpc0nLuRFcqSCiiipKCiiigAoPI4496KKAOMfwl4vaRinxI1FFJJC/2XZHA9P9VTf+ER8Yf9FK1H/wAFVl/8artaKAOW0rw14mstThuNQ8dX2pW0Zy9rJp9rGsgx0LJGGHrwa5nV/O1/9ozR9MnDGw0HSn1JUP3WmdjGrEd8Dp+Nen1i3vhxJfE0HiCwmFtqMdu1o7NHvSaIsG2suQchhkEHjJ65pp2kn2v+T/UH8LXf/P8AyOT+MBOqWnh3wqmGbXdXhjlX/phEfMkP/jorqfEv9qXvhm+tvCUlv/aSMsSiaRo0HKll3KMg7CeR0JqnqXgpdR8Q6V4ge/b+19MdzDK8e6La6FWTywwwOc5znPUnpU+san/whmgQzJYXmrSTXaRyC3Vd5eV+XOSAFBP4cCktref+S/QG9b9l/mzmvF8cujeJvB8XhW3it9UudQC3kNquFktNp84yYHKgkEMe5Hc16PXmfxJiHhUaTq3g60htdeutUht/JtYgpv42J3pIAPmAGWyfu4zkV6YOnNNax+b/AE/D9biekvl+r/r7gooopDCiiigAooooAKKK53xL470HwgGfxDNeWsKKGa4XTbmWFQTgZlSMoDntnNFw3Oiorl7f4iaFd28dxaxa5NBKoeOVPD1+UZT0IbycEe9a+leINK1szLpd9FcSQHbNEDtkiPo6HDL+IFOzC5o0UUUgOb8Uf8jF4M/7DUn/AKb7yukrm/FH/IxeDP8AsNSf+m+8rpKACiiigAooooAKytT8L+H9al83WdC03UJOPnurOOU8dOWBrVooAgs7G0063EGn2sNrCDkRwRhFz64HFT0UUAFFFFABRRRQAUUUUAFFFQ3V1DZWslxcsUijGWYKWx+A5oAmorI8P+KtF8UxXMmgXovEtJfImYRuux8ZK/MBzzWvQAUUUUAFFFFABRRRQAUUUUAFFFFABRRVT+19N+1/Zf7QtftG7b5PnLvz6bc5zQBbpHRZEKOoZWGCpGQRS0UAU7XR9MsZvOstOtLaXG3fDAqNj0yBVyiigAooooAKKKKACiiigArz746/8kT8Rf8AXKP/ANGpXoNeffHX/kifiL/rlH/6NSs6vwM0pfxI+p03gv8A5EPQf+wdb/8Aota82+LFxNoPxc8AarogKahfXTWVysfBuICyZVvUDcSM9K7Twjb+IT4H0QwappiKdPg2B9NkYgeWMZInGf0qzZ+CoD4pj8Sa7dtqurQRmK2doxHDaKfveVGM4J7sSx7ZxXTP+Nzdn/SOel/BS7r+v8zp6KKKyNDm/FH/ACMXgz/sNSf+m+8rpK5vxR/yMXgz/sNSf+m+8rpKACiiuf1/xvoXhi8jtdYmu45ZE8xRDp9xOCM4+9GjAdOhOaAOgoriv+FueD/+fvUf/BLe/wDxmj/hbng//n71H/wS3v8A8ZoA7WiqEetWMmg/2ysrLY+QbjzJY2jIQDJJVgCOOxANch4Blm8d6W3izxBFvt76R/7N0+UZjt7cHarFejO2CSx6AgDAos7tdg6XO+orzXwIJ7z4q+M7iO7nfS9NaHTbOBpCY4mA3yBR04Zsew46AV03inxpa+F4Y2msry4eS5htxsgZYwZXCgmQjafvdASfanvbz/XYNm/I6SiiikAUUUUAFFFFABUF7dR2NhcXc5CxQRNI5PYKMn+VT1wnxm1GWx+FupW9pzd6mU0+BQcFmmYJ/Imple1o7/qVG19diD4JWckXw2h1O5Tbc61dT6lN7mRyR/46Fr0KuKuvC2l+G/hlPBdM0rabpjAXzkCWPy4+GRhjZjHG3FL4K8V3+s+AvDtzNb/atX1CxEzqzeWmFwDI7AHaCcdASSemMkays5Pl2Vvu1t+Rmr2TfW/6X/M7Siue0rxUt14mufDuqWv2DVoIBcrGsvmRzwk43xvhScHggqCK6GoKCiiigAooooAKKKKACiiigDhvi34gudD8GxW+mzNBe6xew6bDKpw0fmNhmHuFDYPriunPh/TD4d/sP7JH9g8nyfJxxjHX6989c815x8dw+3wQR9weJbbd+uK9ZoteD9f0X+bG9JL0/V/5I4b4R+IbnXvBbw6jM1xe6TezabPKx+aQxNhWPuVK59813NeTfAUN9n8aE/cPiW62/pmvWap62fdJ/ekStG15v8woooqRhRRRQAUUUUAFFFFABXlnx98RaNa/C3XNHuNVs49TnhjMVk06+c48xTkJndjg847V6nRUyjzKxUZcskzkvhv4j0bW/BWkwaRqtnezWunwLcQwTqzwnYBh1ByvII59K62iitJS5pORnGPLFR7BRRRUlHN+KP8AkYvBn/Yak/8ATfeV0lc34o/5GLwZ/wBhqT/033ldJQAUUUUAFFFFAGF430m517wHrelWBxc3ljLDFzjLFSAP6VmeDdRtNN+H2jWFrGz3trYxQnT1GJlkVAGVl/h+bqTgd812FFHRrvb8L/5h28r/AI2/yPMPhQLqy8LJbzp5Ouahq1zd6pCRloP3jE7h2BCqoPfcCK0/i/8A8ifY/wDYZsP/AEoSu8rjPiHoPiDxNpcFho1vpgjivbe6827vJIyfKkDldqxN1xjOf8Kd/ej5Nfg1+iB6qXnf8b/5nZ0VBZvdvbg6hBDBNnlIJjKuP94qp/Sp6QBRRRQAUUUUAFcV8SNJlv08OXojaW20rW4Ly6RQTiMBl3Y7hSwY+wJrtaKOqfaz+4OjXe6+84Tx603jLQ28LeGZhN/aZEd7fRENFa2+cvluhdh8oUc856DNbtr4N0Wxv9JvoIHjn0ezNnassrKqxEAEFQcHp3Fb1cl47svGeo21tbeDRoYhLE3g1aWYCVeyARLnB7/MM9MYJovbb+v6/Vha+5Q02xl8S/FX/hK4lMek6bYvY2cv/P47tl3X1jGAAe5yRxzXeVxfhez+IR1qOTxq/hqPT7eFhDFon2gMXOANwk42gZ6dzXaU9kl/W4t22FFFFIYUUUUAFFFFABRRRQBx3xQ8LXPirwY0OmqralY3EV9ZqxwGkjbO3PbIyPxrRPjHTf7F+2BnN15W7+ztp+0+Zj/V+V97dnjp79Oa6Cil0aDqmcf8L/C1z4U8FR2+pKq6jeTyX14q8hZZG3Fc98DA/Cuwooqm7iQUUUUhhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGRrOlT6jq3h+6gaNU03UHupg5ILKbWeHC4HJ3SqeccA/Q69FFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB/9k="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some parameters must be specified before the calculation starts. Without losing generality, the payoff matrix of RSP game can be written as \n",
    "![matrsp.JPG](attachment:matrsp.JPG)\n",
    "\n",
    "# So we should determine parameters a_i and b_i.\n",
    "\n",
    "# Also beta parameter in fermi function shuold be assign.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "b1=2\n",
    "b2=300\n",
    "b3=2\n",
    "a1=1\n",
    "a2=300\n",
    "a3=1\n",
    "\n",
    "beta=.001\n",
    "def fermi(x,y):\n",
    "    return(1/(1+math.exp(beta*(x-y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "#r=0\n",
    "#i is number of s, N-i is number of p\n",
    "\n",
    "def PR0(w2):\n",
    "    return((b3*(N-w2)-a2*w2)/N)\n",
    "\n",
    "def PS0(w2):\n",
    "    return(-a3*(N-w2)/N)\n",
    "\n",
    "def PP0(w2):\n",
    "    return(b2*w2/N)\n",
    "\n",
    "\n",
    "for i in range (2,N-1):\n",
    "    \n",
    "    q3=(i*(N-i)*fermi(PS0(N-i),PP0(N-i)))/(N**2-N)\n",
    "    q4=(i*(N-i)*fermi(PP0(N-i),PS0(N-i)))/(N**2-N)\n",
    "    q5=(i*(i-1)+(N-i)*(N-i-1))/(2*(N**2-N))\n",
    "    \n",
    "    \n",
    "    A[int(i*(i+1)/2)+2,int((i+2)*(i+1)/2)+2]= 2*(q3)\n",
    "    A[int(i*(i+1)/2)+2,int((i-1)*(i)/2)+2]=2*(q4)\n",
    "    A[int(i*(i+1)/2)+2,int(i*(i+1)/2)+2]=2*q5\n",
    "\n",
    "        \n",
    "        \n",
    "                                          \n",
    "i=1\n",
    "\n",
    "\n",
    "q3=(i*(N-i)*fermi(PS0(N-i),PP0(N-i)))/(N**2-N)\n",
    "q4=(i*(N-i)*fermi(PP0(N-i),PS0(N-i)))/(N**2-N)\n",
    "q5=(i*(i-1)+(N-i)*(N-i-1))/(2*(N**2-N))\n",
    "\n",
    "\n",
    "A[int(i*(i+1)/2)+2,int((i+2)*(i+1)/2)+2]= 2*(q3)\n",
    "A[int(i*(i+1)/2)+2,0]=2*(q4)\n",
    "A[int(i*(i+1)/2)+2,int(i*(i+1)/2)+2]=2*q5\n",
    "    \n",
    "    \n",
    "\n",
    "i=N-1\n",
    "\n",
    "\n",
    "q3=(i*(N-i)*fermi(PS0(N-i),PP0(N-i)))/(N**2-N)\n",
    "q4=(i*(N-i)*fermi(PP0(N-i),PS0(N-i)))/(N**2-N)\n",
    "q5=(i*(i-1)+(N-i)*(N-i-1))/(2*(N**2-N))\n",
    "\n",
    "\n",
    "A[int(i*(i+1)/2)+2,1]= 2*(q3)\n",
    "A[int(i*(i+1)/2)+2,int((i-1)*(i)/2)+2]=2*(q4)\n",
    "A[int(i*(i+1)/2)+2,int(i*(i+1)/2)+2]=2*q5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "#p=0\n",
    "#i-1 is number of r, N-i+1 is number of s\n",
    "\n",
    "def PR1(w2):\n",
    "    return(-a2*w2/N)\n",
    "\n",
    "def PS1(w1):\n",
    "    return(b1*w1/N)\n",
    "\n",
    "def PP1(w1,w2):\n",
    "    return((-a1*w1+b2*w2)/N)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "for i in range (3,N):\n",
    "    \n",
    "    \n",
    "    Z3=((i-1)*(N-i+1)*fermi(PS1(i-1),PR1(N-i+1)))/(N**2-N)\n",
    "    Z4=((i-1)*(N-i+1)*fermi(PR1(N-i+1),PS1(i-1)))/(N**2-N)\n",
    "    Z5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "    \n",
    "    \n",
    "    A[int((i)*(i+1)/2+1),int((i+1)*(i+2)/2+1)]= 2*Z3\n",
    "    A[int(i*(i+1)/2+1),int((i-1)*(i)/2+1)]=2*Z4\n",
    "    A[int(i*(i+1)/2+1),int((i+1)*(i)/2+1)]=2*Z5\n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "    \n",
    "i=2\n",
    "Z3=((i-1)*(N-i+1)*fermi(PS1(i-1),PR1(N-i+1)))/(N**2-N)\n",
    "Z4=((i-1)*(N-i+1)*fermi(PR1(N-i+1),PS1(i-1)))/(N**2-N)\n",
    "Z5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "\n",
    "\n",
    "A[int((i)*(i+1)/2+1),int((i+1)*(i+2)/2+1)]= 2*Z3\n",
    "A[int(i*(i+1)/2+1),0]=2*Z4\n",
    "A[int(i*(i+1)/2+1),int((i+1)*(i)/2+1)]=2*Z5\n",
    "\n",
    "\n",
    "i=N\n",
    "\n",
    "Z3=((i-1)*(N-i+1)*fermi(PS1(i-1),PR1(N-i+1)))/(N**2-N)\n",
    "Z4=((i-1)*(N-i+1)*fermi(PR1(N-i+1),PS1(i-1)))/(N**2-N)\n",
    "Z5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "\n",
    "\n",
    "A[int((i)*(i+1)/2+1),2]= 2*Z3\n",
    "A[int(i*(i+1)/2+1),int((i-1)*(i)/2+1)]=2*Z4\n",
    "A[int(i*(i+1)/2+1),int((i+1)*(i)/2+1)]=2*Z5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "#s=0\n",
    "#i-1 is number of r, N-i+1 is number of p\n",
    "def PR2(w1):\n",
    "    return(b3*(N-w1)/N)\n",
    "\n",
    "def PS2(w1):\n",
    "    return((b1*w1-a3*(N-w1))/N)\n",
    "\n",
    "def PP2(w1):\n",
    "    return(-a1*w1/N)\n",
    "\n",
    "\n",
    "for i in range (3,N):\n",
    "    \n",
    "\n",
    "    y3=((i-1)*(N-i+1)*fermi(PP2(i-1),PR2(i-1)))/(N**2-N)\n",
    "    y4=((i-1)*(N-i+1)*fermi(PR2(i-1),PP2(i-1)))/(N**2-N)\n",
    "    y5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "    \n",
    "    A[int(N*(N+1)/2+i),int(N*(N+1)/2+i+1)]=2*y3\n",
    "    A[int(N*(N+1)/2+i),int(N*(N+1)/2+i-1)]=2*y4\n",
    "    A[int(N*(N+1)/2+i),int(N*(N+1)/2+i)]=2*y5\n",
    "\n",
    "\n",
    "                                            \n",
    "i=2\n",
    "\n",
    "y3=((i-1)*(N-i+1)*fermi(PP2(i-1),PR2(i-1)))/(N**2-N)\n",
    "y4=((i-1)*(N-i+1)*fermi(PR2(i-1),PP2(i-1)))/(N**2-N)\n",
    "y5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "\n",
    "A[int(N*(N+1)/2+i),int(N*(N+1)/2+i+1)]=2*y3\n",
    "A[int(N*(N+1)/2+i),1]=2*y4\n",
    "A[int(N*(N+1)/2+i),int(N*(N+1)/2+i)]=2*y5\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "i=N\n",
    "\n",
    "\n",
    "y3=((i-1)*(N-i+1)*fermi(PP2(i-1),PR2(i-1)))/(N**2-N)\n",
    "y4=((i-1)*(N-i+1)*fermi(PR2(i-1),PP2(i-1)))/(N**2-N)\n",
    "y5=((i-2)*(i-1)+(N-i+1)*(N-i))/(2*(N**2-N))\n",
    "\n",
    "A[int(N*(N+1)/2+i),2]=2*y3\n",
    "A[int(N*(N+1)/2+i),int(N*(N+1)/2+i-1)]=2*y4\n",
    "A[int(N*(N+1)/2+i),int(N*(N+1)/2+i)]=2*y5\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1128"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#k is the number of r,N-j-1 is the number of s and j-k+1 is the number of p\n",
    "\n",
    "def PR3(w1,w2):\n",
    "    return((-a2*w2+b3*(N-w1-w2))/N)\n",
    "\n",
    "def PS3(w1,w2):\n",
    "    return((b1*w1-a3*(N-w1-w2))/N)\n",
    "\n",
    "def PP3(w1,w2):\n",
    "    return((-a1*w1+b2*w2)/N)\n",
    "\n",
    "\n",
    "\n",
    "ttt=0\n",
    "for j in range (1,N-2):\n",
    "    for k in range(1,j+1):\n",
    "        h1=((j-k+1)*(k)*fermi(PR3(k,N-j-1),PP3(k,N-j-1)))/(N**2-N)\n",
    "        h2=((j-k+1)*(k)*fermi(PP3(k,N-j-1),PR3(k,N-j-1)))/(N**2-N)\n",
    "        h3=((j-k+1)*(N-j-1)*fermi(PS3(k,N-j-1),PP3(k,N-j-1)))/(N**2-N)\n",
    "        h4=((j-k+1)*(N-j-1)*fermi(PP3(k,N-j-1),PS3(k,N-j-1)))/(N**2-N)\n",
    "        h5=((k)*(N-j-1)*fermi(PS3(k,N-j-1),PR3(k,N-j-1)))/(N**2-N)\n",
    "        h6=((k)*(N-j-1)*fermi(PR3(k,N-j-1),PS3(k,N-j-1)))/(N**2-N)\n",
    "        h7=((k)*(k-1)+(N-j-1)*(N-j-2)+(j-k+1)*(j-k))/(2*(N**2-N))\n",
    "        ttt=ttt+1 \n",
    "        \n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+1)]=2*h1\n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+3)]=2*h2\n",
    "        \n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k-j+1)]=2*h4\n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k-j)]= 2*h6\n",
    "        \n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+j+5)]=2*h5\n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+j+4)]=2*h3\n",
    "        \n",
    "        A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+2)]=2*h7\n",
    "        \n",
    "        \n",
    "ttt  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=0\n",
    "j=N-2\n",
    "for k in range(1,j+1):\n",
    "    B=B+1\n",
    "\n",
    "    h1=((j-k+1)*(k)*fermi(PR3(k,N-j-1),PP3(k,N-j-1)))/(N**2-N)\n",
    "    h2=((j-k+1)*(k)*fermi(PP3(k,N-j-1),PR3(k,N-j-1)))/(N**2-N)\n",
    "    h3=((j-k+1)*(N-j-1)*fermi(PS3(k,N-j-1),PP3(k,N-j-1)))/(N**2-N)\n",
    "    h4=((j-k+1)*(N-j-1)*fermi(PP3(k,N-j-1),PS3(k,N-j-1)))/(N**2-N)\n",
    "    h5=((k)*(N-j-1)*fermi(PS3(k,N-j-1),PR3(k,N-j-1)))/(N**2-N)\n",
    "    h6=((k)*(N-j-1)*fermi(PR3(k,N-j-1),PS3(k,N-j-1)))/(N**2-N)\n",
    "    h7=((k)*(k-1)+(N-j-1)*(N-j-2)+(j-k+1)*(j-k))/(2*(N**2-N))\n",
    "    ttt=ttt+1 \n",
    "\n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+1)]=2*h1\n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+3)]=2*h2\n",
    "    \n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+2-N)]=2*h4\n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+2+N)]=2*h6\n",
    "    \n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+3-N)]=2*h5\n",
    "    A[int((N)*(N-1)/2+k+2),int((N)*(N-1)/2+k+N+1)]=2*h3\n",
    "    \n",
    "    A[int((j+1)*(j+2)/2+k+2),int((j+1)*(j+2)/2+k+2)]=2*h7\n",
    "    \n",
    "    \n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[0,0]=1\n",
    "A[j1,j1]=1\n",
    "A[j2,j2]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "HJ= np.delete(A, (0), axis=0)\n",
    "HJ1= np.delete(HJ, (0), axis=0)\n",
    "HJ2= np.delete(HJ1, (0), axis=0)\n",
    "HJ3= np.delete(HJ2, (0), axis=1)\n",
    "HJ4= np.delete(HJ3, (0), axis=1)\n",
    "Q= np.delete(HJ4, (0), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "FA=np.linalg.inv(II-Q)\n",
    "R=np.zeros((n-3,3))\n",
    "\n",
    "R[1,0]=A[4,0]\n",
    "R[0,0]=A[3,0]\n",
    "\n",
    "R[int((N-1)*(N)/2)-1,1]=A[int((N-1)*(N)/2)+2,1]\n",
    "R[int((N+1)*(N)/2)-1,1]=A[int((N+1)*(N)/2)+2,1]\n",
    "\n",
    "\n",
    "R[int((N+1)*(N+2)/2)-4,2]=A[int((N+1)*(N+2)/2)-1,2]\n",
    "R[int((N)*(N+1)/2)-2,2]=A[int((N)*(N+1)/2)+1,2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=np.matmul( FA,R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "ros=[]\n",
    "for x in range (0,n-3):\n",
    "    ros.append((B[x][0]))\n",
    "    \n",
    "rop=[]\n",
    "for x in range (0,n-3):\n",
    "    rop.append((B[x][1]))\n",
    "    \n",
    "ror=[]\n",
    "for x in range (0,n-3):\n",
    "    ror.append((B[x][2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# fixation probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/2869076031.py:41: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.pro3.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation probability of strategy P\n",
    "WW=[0,1,0]\n",
    "JKL=WW+rop\n",
    "PROz=JKL\n",
    "def rey(x):\n",
    "    if x==1:\n",
    "        return([PROz[0]])\n",
    "    if x==N+1:\n",
    "        GH=[PROz[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(PROz)):\n",
    "            GH.append(PROz[s])\n",
    "        GH.append(PROz[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(PROz[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ER=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ER[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(rey(j))):\n",
    "        ER[j-1][N-len(rey(j))+2*k+1]=rey(j)[k]\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ER[x,y])=='nan' and str(ER[x,y-1])!='nan' and str(ER[x,y+1])!='nan':\n",
    "            ER[x,y]=ER[x,y+1]\n",
    "ER[N][2*N-1]=ER[N][2*N]            \n",
    "            \n",
    "\n",
    "ax = sns.heatmap(ER,yticklabels=False,cmap='Spectral')\n",
    "plt.savefig('N=50-An.pro3.pdf',dbi=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/3613243169.py:41: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.pro3.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation probability of strategy S\n",
    "WW=[1,0,0]\n",
    "JKL=WW+ros\n",
    "PROz=JKL\n",
    "def rey(x):\n",
    "    if x==1:\n",
    "        return([PROz[0]])\n",
    "    if x==N+1:\n",
    "        GH=[PROz[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(PROz)):\n",
    "            GH.append(PROz[s])\n",
    "        GH.append(PROz[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(PROz[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ER=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ER[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(rey(j))):\n",
    "        ER[j-1][N-len(rey(j))+2*k+1]=rey(j)[k]\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ER[x,y])=='nan' and str(ER[x,y-1])!='nan' and str(ER[x,y+1])!='nan':\n",
    "            ER[x,y]=ER[x,y+1]\n",
    "ER[N][2*N-1]=ER[N][2*N]            \n",
    "            \n",
    "\n",
    "ax = sns.heatmap(ER,yticklabels=False,cmap='Spectral')\n",
    "plt.savefig('N=50-An.pro3.pdf',dbi=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/3899349712.py:41: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.pro3.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation probability of strategy R\n",
    "WW=[0,0,1]\n",
    "JKL=WW+ror\n",
    "PROz=JKL\n",
    "def rey(x):\n",
    "    if x==1:\n",
    "        return([PROz[0]])\n",
    "    if x==N+1:\n",
    "        GH=[PROz[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(PROz)):\n",
    "            GH.append(PROz[s])\n",
    "        GH.append(PROz[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(PROz[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ER=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ER[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(rey(j))):\n",
    "        ER[j-1][N-len(rey(j))+2*k+1]=rey(j)[k]\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ER[x,y])=='nan' and str(ER[x,y-1])!='nan' and str(ER[x,y+1])!='nan':\n",
    "            ER[x,y]=ER[x,y+1]\n",
    "ER[N][2*N-1]=ER[N][2*N]            \n",
    "            \n",
    "\n",
    "ax = sns.heatmap(ER,yticklabels=False,cmap='Spectral')\n",
    "plt.savefig('N=50-An.pro3.pdf',dbi=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# fixation times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/998218347.py:62: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.time.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation time of strategy P\n",
    "NFP=np.zeros((n-3,n-3))\n",
    "for i in range (0,n-3):\n",
    "    for j in range (0,n-3):\n",
    "        fp=(FA[i,j])*((rop[j]))\n",
    "        if fp==0:\n",
    "            NFP[i,j]=0\n",
    "        else:\n",
    "            NFP[i,j]=(FA[i,j])*((rop[j])/(rop[i]))\n",
    "            \n",
    "def pol(k):\n",
    "    t=0\n",
    "    for x in range (0,n-3):\n",
    "        t=t+NFP[k,x] \n",
    "    return(t)\n",
    "        \n",
    "PRO=[]\n",
    "for x in range (0,n-3):\n",
    "    PRO.append(pol(x))\n",
    "    \n",
    "#time\n",
    "WW=[0,0,0]\n",
    "JKL=WW+PRO\n",
    "def reyt(x):\n",
    "    if x==1:\n",
    "        return([JKL[0]])\n",
    "    if x==N+1:\n",
    "        GH=[JKL[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(JKL)):\n",
    "            GH.append(JKL[s])\n",
    "        GH.append(JKL[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(JKL[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ERt=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ERt[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(reyt(j))):\n",
    "        ERt[j-1][N-len(reyt(j))+2*k+1]=reyt(j)[k]\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ERt[x,y])=='nan' and str(ERt[x,y-1])!='nan' and str(ERt[x,y+1])!='nan':\n",
    "            ERt[x,y]=ERt[x,y+1]            \n",
    "ERt[N][2*N-1]=ERt[N][2*N] \n",
    "\n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N+1):\n",
    "        if ERt[x,y]==0:\n",
    "            ERt[x,y]='nan'\n",
    "ERt[N][0]=0\n",
    "\n",
    "ax = sns.heatmap(ERt,yticklabels=False,cmap='Spectral') \n",
    "plt.savefig('N=50-An.time.pdf',dbi=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/3136111380.py:66: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.time.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVoAAAEBCAYAAAA5GG1CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAApI0lEQVR4nO2de7xkVXXnv+s+u5GH8hCBxkgM6IAJnYEgExODAQERAV+xJaE7xNhiMJLEmShjMjjOMCFO1Og4ou0TUEBIFJDIoyU+JgkIqCjv0DwkDR1whCAj/bq31vxxdlXtqtrn1jlV9/Q9t+7v25/zubv2WXufs29Vr7vrt9dex9wdIYQQ1TG20DcghBCjjhytEEJUjBytEEJUjBytEEJUjBytEEJUzERJe4UoiBafGzu6VT69ccMC3omoKTZM4zWnXFTY31xwxWlDXatqyjpaIYTYITTGau07SyFHK4SoJS5HK4QQ1dIYl6MVS5jrfu5VADxv36lW3TUrXtUqv2rjNTv8nsToMTMxOmv1crRCiFoi6UAIISpG0oEQQlSMog6EEKJiGmPSaMUS49bDT2qVn7NH78dmZns7tvyffvFEAH719qurvzExssynRmtmnwVOBB5395eEui8BLwomzwb+zd1XmtkLgLuBe8O5m9z9jNDmMODzwHLga8BZXiDXrBytEKKWzEzO64z288DHgAubFe7+pmbZzD4IPBXZ3+/uKxP9nA+sBW4ic7THA33DbEZnbi6EGCl8zAofffty/zbwROqcmRnwW8Alc/VhZvsAu7r7jWEWeyFwSpGxyNEKIWpJY8wKH0Py68Bj7n5fVHeAmX3fzL5lZr8e6vYDNkY2G0NdXyQdiDm595iTAdh51/jDnJVnZ9If8MZsJlnd/rKTW3W/+I9XVnODYmQpE95lZmvJvtI3Wefu6wo2fzOds9lNwPPd/SdBk73CzA4hnSSnUOIbOVohRC0pM1MNTrWoY21hZhPA64DDor62AltD+btmdj9wENkMdkXUfAXwaJHrSDoQQtSS+dRo5+AY4B53b0kCZraXmY2H8s8DBwIPuPsm4GkzOzLouquBQl/VNKMVQtSS+cx1YGaXAEcBe5rZRuAcd/8MsIreRbCXA+83sxlgFjjD3ZsLaW+nHd51DQUiDgCs5OPGlfh7CfDwa09slWdnes83Etpso9Fb5410/wetv2rgexOLiqGmmr/259cW9jf/8N+Or/U2Ms1ohRC1REllhBCiYpTrQAghKkaOVowc/3pqO3H3xLRF5exnhy47nUlneRrs7Ozceu2Dr8k04AO+qlwIIp/Z+d2Cu6DI0Qoh6olmtEIIUS1jY6MT5CRHK4SoJWPjcrRiRHjyrccCnbpsTEubnWzXuffaxnkPxplbw/UQc7vxDa9u1a34m78rfM9iaaAZrRBCVIwcrRBCVMzEZM5XokWIHK0QopZoRiuEEBUjRysWNT975zGt8sSkhZ/tD3XHhoOprL4zkUyoi77ZjceLZQUTzMSLao/9TnvDxN5fKJQQSYw4ijoQQoiK0YxWCCEqRo5WCCEqZlJRB2Kxsfm9J7TKtqz9to+Hn759tlU3FuV39+2h3EeD7UwkU2zDQl4e+SfechwAu3/munQHYkmgGa0QQlSMHK0QQlSMog6EEKJixkYnHa0c7aiz9S9OAcCmx1t1cdm3N3LrsvpQiDTcll2jPeOIdV1me2ciyTjahNYL7fjcp854Zatut0+sT9qK0WViYnQWw0bob4YQYpQYG/fCRz/M7LNm9riZ3RHVvc/MHjGz28JxQnTubDPbYGb3mtlxUf1hZnZ7OPdRMyuUnVyOVghRS8bGvPBRgM8DxyfqP+zuK8PxNQAzOxhYBRwS2nzczJpf+c4H1gIHhiPVZ+9YihgJIcSOZj4drbt/G3ii4KVPBi51963u/iCwATjCzPYBdnX3G93dgQuBU4p0KI12BNn2sd9qlW3ZeMdP6NJgl4W6LTPtuuiheC0dNmpPU9eNrukJXZZIw+34fjXbq7116r1Nu3ZdnJ/hWR/9eu+1xMhRJrzLzNaSzTSbrHP3dQWavsPMVgO3Au9y9yeB/YCbIpuNoW57KHfX90UzWiFELSmj0br7Onc/PDqKONnzgRcCK4FNwAdDfUp39Tnq+6IZrRCilkxWHEfr7o81y2b2KeDq8HIjsH9kugJ4NNSvSNT3RTNaIUQtGbPixyAEzbXJa4FmRMJVwCozmzazA8gWvW52903A02Z2ZIg2WA1cWeRamtGOCDMX/E6rHOuxTW3Vt7TjYG0y1ltnQ91Uq6pDw03U0Ww/22sHnXpriw4NN7TP0XD76b3P/Gm20LvTB67ttRMjw/iADjSFmV0CHAXsaWYbgXOAo8xsJdnX/4eAtwG4+51mdhlwFzADnOnuzf9AbyeLYFgOXBOOvsjRCiFqyXw6Wnd/c6L6M3PYnwucm6i/FXhJ2evL0Qohasl8OtqFRo5WCFFLJkdoBUmOdpHTuOItQKcu2xEzu6WpwcZxtFHegqZtIrY2tk3H4UZa72xCb01preRpuAldOGUXsfl9J7bKy9939RyWYjGiGa0QQlSMsncJIUTFaEYrhBAVI0crhBAVM+hGhDoiR7sIaVx/ZvvFREgaMxEtTG3b3io2E8R0JpLpXSwjZ7GslWAmXuyabtrlJGZuJOoTi2Wdi129C2udiWjmXhhrJjgHmD77ijltxeJgSs8ME0KIapF0IIQQFSPpQAghKkYzWrHDafzDu9ovYj22WY502Y7zM2HDQTtnTDkNN6XDbmtugkgkCAdaemuertro1WDTiWRyNOA+eu22D78egKk//ts57US9kaMVQoiKkXQghBAVM6WdYUIIUS2SDsQOw7/7Z1lhInqr4nJTb43rZtoPWmRqstMO+mu4M1EcbStmNkpEM51IRBPfc9/E3826fu3TSWta9Ek6s/38N7XKk2//0py2on5IOhBCiIrRjFYIISpGjlYIISpmQltwRZX4vdGjiqayt8imYl020mAnMw3Wt0cabFOXhfnTcOO6ZnzrND12EOUy6BNH2y9xeG7i7z56b4qZz57aKk/83sVz2op6MEoz2hEKoBBCjBJj5oWPfpjZZ83scTO7I6r7n2Z2j5n90My+YmbPDvUvMLPNZnZbOD4RtTnMzG43sw1m9tHw2PH+Yyk/fCGEqJ4xK34U4PPA8V1164GXuPsvAf8MnB2du9/dV4bjjKj+fGAtcGA4uvtMj6XQLQohxA5m3Lzw0Q93/zbwRFfd9e7e1NFuAlbM1YeZ7QPs6u43ursDFwKnFBmLNNqa4A9/qP0iFTPboaH2xtHm5aNleVbvs1Ec7CAabqTBtohzEcR9NnXdPNtWXZ6G2+hpn86FkJPPNkXUfvbi1VmLUy+cu41YUMrE0ZrZWrKZZpN17r6uxOV+D4iDrQ8ws+8DPwX+zN3/D7AfsDGy2Rjq+iJHK4SoJZMlog6CUy3jWFuY2XuBGeCLoWoT8Hx3/4mZHQZcYWaH0DV3aF66yDXkaIUQtWRH7AwzszXAicDRQQ7A3bcCW0P5u2Z2P3AQ2Qw2lhdWAI8WuY40WiFELZnPqIMUZnY88G7gJHd/Jqrfy8zGQ/nnyRa9HnD3TcDTZnZkiDZYDVxZ5Fqa0Qohasl8xtGa2SXAUcCeZrYROIcsymAaWB+itG4KEQYvB95vZjPALHCGuzcX0t5OFsGwHLgmHP2vH2bLRRmdrRo1wR8PstLMtrTB9i29dfFi11x1kF7ESth2LJZ1tJ9J1PVZGJvLLs82tTCWl/i7zMJawfZjr/tc8faiKEO5yu88/rnCb+pLn3t6rbc3aEYrhKglyt4lhBAVUybqoO7I0Qohasmgi1x1RI52IXjqknZ5LLwFcdKYWK+d3jn7ORvVTUz12qY2IcT1/ZLG0LvhAGglrenQapuJbPJ03aYGmtjEkLTrqS+o15Zpn7Rrt29c3Y51HztxoHBMMc+MUkiUHK0QopYU2Vq7WJCjFULUEi2GCSFExWgxTJRnc7SBZKz9a7fpXQDw2a3t87EG24yjHc/RcJvably3LLJtBG21n4Y7k5N0pqnNdmjIfXTd1rUjDXWybZvUdgdIOtO3Lo8+Gm7j638IwNgx/6t4n2Le0WKYEEJUjKQDIYSoGC2GCSFExYzSjFa5DqqmcUP2c7ZELoNE3gOf2dprl9dvKm9CI5GzIM82pbcWzXkAxfMelNBgc2N2i15/yPwIYy//UH8j0c1QrvJfn/lU4TfoeTu9tdZuWTNaIUQtGbM+T81YRMjRCiFqScEHzC4K5GiFELXERmgTrjTaCphpXNcqT4xN9RrMpvTOHA23oAZbSsNNXT9PQ07aDpGjtoxtqTjaIfPZJkj93xg78i8LtRXAkBrtT7ZcWNjf7LFsda2nv5rRCiFqidnozGjlaIUQtcSGmxDXCjlaIUQtGaWoA2m088TmmXYug3Gb7Dk/PtZbBzCe+ltXNDY2rz4RM5ur4abia1N1KV02Lza3qK5bRoMtlc92/p8plmpvh/334n0uTYaakv5022WF37Rdp36r1tPf0RFBhBAjhZkVPgr09Vkze9zM7ojqdjez9WZ2X/j5nOjc2Wa2wczuNbPjovrDzOz2cO6jVjAGTY5WCFFLjLHCRwE+DxzfVfce4AZ3PxC4IbzGzA4GVgGHhDYfN2vpGOcDa4EDw9HdZxI5WiFELbES//rh7t8GnuiqPhm4IJQvAE6J6i91963u/iCwATjCzPYBdnX3Gz3TXC+M2syJFsOEELWkzGKYma0lm2k2Wefu/R7+tre7bwJw901m9txQvx9wU2S3MdRtD+Xu+r7I0Q7JU9suBToXwGa9vfDT3LDQaLQXc2LbBrOhLnorxtsfsDFCeTza+JB6UGPHolhkGxasLPVARwCmAfBGlAw8bt9cxBrv7TNpF9vGi2Xx9T2x2JRaLIvt4mTkVWxYKNO+eXt3vr9VtkP+y5y2ojxl4miDU52vp2qmpsg+R31f5GiFELVkB2zBfczM9gmz2X2Ax0P9RmD/yG4F8GioX5Go74s0WiFELZlPjTaHq4A1obwGuDKqX2Vm02Z2ANmi181BZnjazI4M0QarozZzohmtEKKWzOcWXDO7BDgK2NPMNgLnAOcBl5nZW4CHgTcCuPudZnYZcBcwA5zp7k3t7+1kEQzLgWvC0f/62rBQnh9v+VyrPGG9SWOSGxYs/TcttZGhTPuWhhuT2kiQt+GhqG1qE8Ts9l47SGuwRTdB5LUvWpfXb55tiiE0XDvw7OLXGX2G2kQw07iusL+ZGDuu1hsWNKMVQtSSUdqCK0crhKglo5SPVo5WCFFLRukJC9JoS/DIzz4JwMRY71ealK6a1ff+LduhGm7q69ewCWKGTDrTXlfo0z5PV00mwimh4RbVe8v0mcCe/yeFbUeU4Tylf6O4v7FX1Nora0YrhKgnZRYwa+1m5WiFEHWljKOtOXK0Qoh6kidnpah5gII02j7c/eSnW+Xp8d7hT4/3/tVdaA03FVubl3g8ZZvcaVM0QTgMp+tCcibTmYuh2eeQGmwZDbeoXpvTp+37jvS1RpvhvtBv/bvi/mb61bUWDzSjFULUE0kHQghRMXK0QghRMSPkaKXRJrjlx+1cBikNdnqsmFab1ffapjTYvO2GRTXcMu3Hkn0Wj8NNXqtMzGlRvXbYXAYlNNhk3oYy/9ELXt/2+v3ifS5+htNNn768uL/Z5Y3SaIUQojQjNKOVoxVC1BM5WiGEqJbkVu0caq0bII22gxseyR6ImdJV8+qr0HBTGmiZONzCumpOv8n2iXjbvD4LXz/v05TScIs+ZyzPtor2Ka03zzmkctfuvjptOzoM5f/8iQsL+xvbfXWtfa1mtEKIeiLpQAghKqbMFtyaI0crhKgnmtEKIUTF5OWyWIQseUd71UNfaJWnxzM9faZhUV1bj2/Wd9aNh7pGjx3ARFgY29poLwbFi2VbZ5vXiT9U7fJksJ2hvcgSJ62Z9SzQvmOxKVpCaC52zXr7a1hs26xPPuSxu9/uOs+xC/UD9Zm9ALofZdI+30p6Mx49GLPMhoXmV9KJqP2QSWOa9R0rMv36fPrydnmXN6b7XcqM0Ix2dB7KI4QYLbxR/OiDmb3IzG6Ljp+a2R+Z2fvM7JGo/oSozdlmtsHM7jWz44YZypKf0Qohakpe+N0AuPu9wEoAMxsHHgG+ApwOfNjd/yq2N7ODgVXAIcC+wNfN7CAvE9wboRmtEKKezOOMtoujgfvd/Udz2JwMXOruW939QWADcMSAI1maM9ov3vfFVnnZeFtV257QW7dHemtTL90626vhbp0d76nL6rOfEwldNr5WPw13sqOuXW7fa7vTcWv//ZwlaLAlNhfEmyBSGvBcdZB+THRSw83RlZPJyK1PnxYXrdkofU9B404mOIfhEofn6sJ9bLd8Nfu57DXp9kuRMg/CNFsLrI2q1rn7uhzzVcAl0et3mNlq4FbgXe7+JLAfcFNkszHUDYRmtEKIetJoFD7cfZ27Hx4dSSdrZlPASUBzJfJ84IVkssIm4INN00TzgXfGLskZrRBiEdCoZMf/q4DvuftjAM2fAGb2KeDq8HIjsH/UbgXw6KAX1YxWCFFPSsxoS/BmItnAzPaJzr0WuCOUrwJWmdm0mR0AHAjcPOhQltSM9hN3Zdrsskja2x69R5Phz86W2fbfn9g2FfPa1HA7NdSUhpsXm5tdoL+GG2nFFtv2to9pX6u9ghvfaz+9NRkzWzDBzMAabqouun5KW00lM8/TYFPX6tCAmxJvh/DbJ7bXEteKHUDTtF8y8pnr2nUTQ0UULX5mBlrgz8XMdgJeCbwtqv6Ama0k+4Q91Dzn7nea2WXAXWT/ec4cNOIAlpijFUIsIuZ5Z5i7PwPs0VV32hz25wLnzse15WiFEPVEW3CFEKJiqlkMWxBG3tF+4AdxzGz2c1v0h3Iqkty2zHbaQaeG26zf3mg3auq6KV01sy2v4XbqteM97Te3L9VuH93nhM0dhxu3b9e3z3fqvY2e9k1y42AH0HU7NNymXto3tjbSRX1bH9voje4Tx5vSkFN6b98+y8T2hnvu1Hq/EZVf0XP9kUczWiGEqBjNaIUQomJmlPhbCCEqpczzDGv9wDBG1NH++S0Xt8rLJuJcBqEuimNNxdFuS+iycX1/XXduDXeyTz7alF4b101G10+2J7b1cO85GnBTQ7a0hpy+ftO2N29uRnZTYzmf/kHy2c7SR8ON9d4QM9yhqyZs+8X2FtVlh+2zo9/ceOEsvnZibAnF1kqjFUKIipGjFUKIitFimBBCVIwWw4QQomI0o60nf3JjtggWLxZta8exsyyMNl4YSi9szb1YtiVa2Cq6CWKyo659/fYmiPZiTmqxLC/pTDsZebp9c3NCKhl53O/WdlXn9cO4xqLFss3NMVnvdbrvNdVnehNE+6ZSi2ipxbLUYlOPLU3bVCKadDL0VJLxVvu8BbiwCJZ3T0UX1votls3MfrVVt2x8xJOES6MVQoiKkaMVQoiKkXQghBAVoxltfXjrt9rPWJtuabDt87Feuj3otR2bC2K9s6W39mqocb9TY70a7mRCl43b595Tsn2vhpyfdGbupDWpB0p2aqjN9u2adNKZNkV13VRyG4DxUD+IrguxhpveMNFPL21vLmivancmqCG3facuG7Xvp8Gm7PolskncU7yJ42eNL7fKz5p8XU/7Rc88J/5eSBa9oxVCjCia0QohRLX4rDRaIYSoFi2GLSynXXt5qzwx0da2ZkI+j6nptrbTL2nM8kSS71ivTGm4qTjYTg22uIY7lYjNTdnGui6JBDP9ks6kYnMhThoTX7+YBpzSigHGE6Gg/TTYOHF5M2Z3c3xPlq8VF7n+WEf7mZ7rd9qm6gomjUnoqrm2/WJ74/ZB750lrQs/te1SAHabWtV784uVEZrR6nHjQoha4g0vfBTBzB4ys9vN7DYzuzXU7W5m683svvDzOZH92Wa2wczuNbOh0qbJ0Qoh6sm22eJHcV7h7ivd/fDw+j3ADe5+IHBDeI2ZHQysAg4Bjgc+bpazlbAAcrRCiFoy3zPaHE4GLgjlC4BTovpL3X2ruz8IbACOGPQii0qjff3ffAWAqelYl22XJyYzoW9mpl03NdX+azfTZQfphy+WiXltariT0d+6YTXc1PVTWnNsm7rP2HZ7I61h9tNbU3G4/WNz868T25bRdeOY3WYcLgmtOSZvFjGZ0KXHEhpwKo63U79t/6LHE+375myIaGq4g8T2ZvWZ7U+2XNiq22PZ6qTtoqGERmtma4G1UdU6d1/XZebA9WbmwCfD+b3dfROAu28ys+cG2/2Am6K2G0PdQCwqRyuEWEKUmKkGp9ntWLt5mbs/GpzpejO7Zw7bVHafgafOcrRCiFoy33G07v5o+Pm4mX2FTAp4zMz2CbPZfYDHg/lGYP+o+Qrg0UGvLY1WCFFPts8WP/pgZs8ys12aZeBY4A7gKmBNMFsDXBnKVwGrzGzazA4ADgRuHnQotZ/RnnBRO//m9HQ2m9+yua1zxXrrzExWPzXVrtuyeaLHtkPDjWJun2nqpSUe3thPQ+2n4abjaD2y7bTrtc2vg3Ys6lTOn9T2mObWcMvE5vbTO1O6cEzz+v3yM3TeZ/HrN8ea9/DIZo6GVH6GmLQGmx5T6oGWKb03dZ28a/WL431s86db5b2X/36y3zoz5CJXN3sDXwm/nwngYne/1sxuAS4zs7cADwNvBHD3O83sMuAusuWdM9194OQLtXe0QoglyjxKB+7+AHBoov4nwNE5bc4Fzp2P68vRCiHqyQjtDJOjFULUknmWDhaUWjra31x3Tas8Nd3WnDYHvXViIoqDjeJop4Pe2qnhtt+spjYb67IdGm7od6a9nb0z5ralt85fHGxKw00906yzfaw3dtp12za1vVR+hbh+MkfDTV2/3Wf62WtNDXUsR0MdJI411mtTeuVkQsPNu37fayXaN8nTUNsacnSf0fnm9ctosKn7TMUbd17fI9t2+ZGffRKA/Z71tnQHdWRWaRKFEKJSfLscrRBCVIukAyGEqBYl/hZCiKoZoRmtuZcaTKUj/9WPrAc6F6ti4kWwJinbycm0tpOynZhIJJTOaZ+6fso2Xixr1fVZbOpnO5mToC3VPrWwMpWzOSB1rdSCS1G7cveUbt9/satpV3xhqUz7oonL+ycYn/ueim6CgM4HXQ7SPnVfB+721rTx/JFzN8V45l3HFvY3O33w+qGuVTWa0QohaonCu4QQomJ8uxytEEJUijdqrQaUYsE12sPPu6FVnpju7T6tq5bRYHttp/M04MmEXltQl827p6SGO6TeWaZ9SttNt0+/tcPorXl6Yco2rXcWb18mwUtxDXY4DTT1ey5zTynbvOsPk/Tml3Z/S7rT4RnKUz51xisL+5vdPrG+1l5ZM1ohRC1xr7XvLIUcrRCilvjobAyToxVC1JPZmdGZ0S6IRvuyc65rlbdPJ0TEqfQvOKnBJjTQMnG4qZjbfL11x2i4ReNYYR5iVhP1w8bmFtVby8TRpvoctn3/BC1z2+4oDTX/+sO1T43zV/Y6Pdl+QIbylD9ec3xhf7PXBdfW2itrRiuEqCWSDoQQomK0GCaEEBUzSjPaHarR/uaf/h0AW5en/XtRvTYvF0HRONoyuQySGm5Sg81JCJ2wHUtoY1VpuMPmLUjF4RbVO1P5Bcq0HzaONm9Mw1w/9/dUMGY2r31RvbeKxOF5v+eX77MmfaI4Q01JH111QmF/s++lX6v19FePGxdC1JLGjBU++mFm+5vZN8zsbjO708zOCvXvM7NHzOy2cJwQtTnbzDaY2b1mdtwwY5F0IISoJfMsHcwA73L375nZLsB3zWx9OPdhd/+r2NjMDgZWAYcA+wJfN7ODBn3kuGa0Qoha4m6Fj/59+SZ3/14oPw3cDew3R5OTgUvdfau7PwhsAI4YdCyVz2iPO+uq9ougwU5vnmlVbYt02alQv30qEgY3t2Wa2WC7bWvUJtJlm/WxrrltW/SgxqCDxu1TtrFeujWybeq1He2bfUYPD4zjbZu2KV02vn7qPvPat397MBZy326PH34YPzyyaRd9FpMPj4z6jHW85mOb+sXBxu2bsbnxQybLxLH2i9lt3lOZ9sNev1/7LbMpu7kfKJmyLXNPVWvA1/3LhQAct//qdKcV0ygxozWztcDaqGqdu6/LsX0B8MvAd4CXAe8ws9XArWSz3ifJnPBNUbONzO2Y50QzWiFELfFGicN9nbsfHh15TnZn4G+BP3L3nwLnAy8EVgKbgA82TVO3NOhYpNEKIWpJkUWuMpjZJJmT/aK7fxnA3R+Lzn8KuDq83AjsHzVfATw66LU1oxVC1JJGwwof/TAzAz4D3O3uH4rq94nMXgvcEcpXAavMbNrMDgAOBG4edCya0Qohask8Rx28DDgNuN3Mbgt1/xl4s5mtJJMFHgLeBuDud5rZZcBdZMsiZw4acQAVbVg4ae2XW+XU5oTkxgQ6F8ZatlO9dbM57Ysmcxn24YtFNzZAzuaERHKafotlffvM2fAwlnhQZKp9mQ0PxTcsFO8zldymzIaDMsH9VWxYqKJ9mc0Fw7Qvk4jmpBf8TvoG0gz13f/eY04u7Jxe9PUra71hQTNaIUQtGaUtuHK0QohaMkrPDJOjFULUkpkRegruvGq0bzztSwBsXT6ZPF9Ur01ptZCj1yaEwNRDHmH4JN0pvbOoXltOg01ce0gNd9j2VeiFZRK0FNV1y1yrTJLuYa6Td60d2T6vftDrAKz6hd/u191QU9If/IfiGu2hN0qjFUKI0sw2RmdGK0crhKgljYGDqeqHHK0QopY0RmhGO7RGe+qbLm6VUxpsSq9Naa1QXK/Na5/Sa8cSf0py42gL6rXp2NjisbnjBWNb8/rdkRpu0rbg/e9IvXHomNeCunC5MRX/v7Wj4mhTDNvn774oV6sdSje96dDXFP4FHvmDr0qjFUKIsszMjM6MVo5WCFFLGrNytEIIUSmzI7QzbGCNds0pFwHQSAg8eQ9fTOq1CQ029+GNBeNo83IpNCYSMbcVxNEW1UXz2u9IDXcYDbaKPmER5Q0okftuIWN7y16raJ8pzjykQ68dSje94YXFH8549P31fjijZrRCiFpS5gkLdUeOVghRS0ZpC64crRCiloxSHO3AjvaCK06bz/sQQogORmkxTDNaIUQtUXiXEEJUjBbDhBCiYjSjFUKIitEWXCGEqJhZpUkUQohqUXiXEEJUjBJ/CyFExYzSjBZ3L3UAa+fbtoo+F/r6GpOurzHpaP1OSjeAW+fbtoo+F/r6GpOurzHpaB4lEr0JIYQYBDlaIYSomEEc7boKbKvoc6GvrzHp+gvV50Jfv0yfS4KyT1gQQghREkkHQghRMXK0QghRMXK0QghRMX0drZm92MzebWYfNbOPhPK/K9Duwpz6KTNbbWbHhNenmtnHzOxMM+t9TG7NMLPnLuC196igzwUbT3QPIzeuURtTFeNZSszpaM3s3cClZI8Nvhm4JZQvMbP3RHZXdR1fBV7XfN3V7eeAVwNnmdlFwBuB7wC/Anx6vgYW7qvnw2Fmu5nZeWZ2j5n9JBx3h7pnd9nu3nXsAdxsZs8xs90ju8PN7Btm9gUz29/M1pvZU2Z2i5n9clefu5rZX5jZRWZ2ate5j0fl88xsz6j/B4DvmNmPzOw3BhlT0fFUNaYy41os79MojqnMZ08UpM8Oj38GJhP1U8B90evvAV8AjgJ+I/zcFMq/0dX2h+HnBPAYMB5eW/NcZLsr8BfARcCpXec+3vX6PGDPUD4ceADYAPwovgfgOuDdwPOiuueFuvVdfTaAB7uO7eHnA5HdzcCrgDcD/wK8IdQfDdzY1effhns9BbgqvJ5u/h4ju9uj8jeAXwnlg+jaeVN0TEXHU9WYyoxrsbxPozimouPp6tuAlwKvA14byjbILqpRPPo52nuAn0vU/xxwb/R6DPhjYD2wMtQ9kNPnHWSO+jnA08DuoX4ZcPcO+LDfO8d47+16/R+Ba4FfjOoeTLT7flR+OO9ceH1b1+v3Av8I7NH1Yb8HmAjlm/LGWmZMRcdT1ZjKjGuxvE+jOKYyn71QdyzZpOYasm+lnw73vgE4Nm/MS+nol73rj4AbzOw+sr+WAM8HfgF4R9PI3RvAh83s8vDzMfIzg30mvJHj4Y2+PHw1OZJMpoh5obu/PpSvMLP3An9vZicl+p00swl3nwGWu/st4d7+2cymI7sfmdmfAhe4+2MAZrY38LvRGJvj+iszuzSM6V+AcwBPXHuLmR0L7Aa4mZ3i7leEr1ndyd6mzWws/M5w93PNbCPwbWDnyO5/A18zs/OAa83sr4Evk81Ubuvqs9CYSoynqjGVGddieZ9GcUxlPnsAHwGOcfeH4kozOwD4GtB3TWfk6eeJyWarRwKvB94QyuN92rwa+B9znN8X2DeUnx36PSJhdzcw1lW3BrgT+FFX/R8C1wO/CbwP+Gvg5cB/BS6K7J4D/CWZs38SeCJc5y8Js+uce34NcBPwr4lzh5J9LbwGeDHZB+/fwn3+apftB8g+lN19HE8kx4S6o4AvAd8Hbif70K6lS85JjOnJMKYP5I0JOClvPOH8ysSYngxjetmgYyo6rh34Ps3XmF5R4Zhy36uqxhS9R9+LxvO27s9esL2PMAPuqp8CNszlK5bKseA3MOfNzd9/4IkuuxcDxwA7d/eb6PPFZH/JdwaWAy9J2ZL91T66YJ9H0JY2Dgb+BDihj90hwLtSdjm/u4sK2CwHLi/xfvTtM9j9WhhT36+NwK+HcR3bVf9SYLdQ3gl4P3B1cEq7JWx3jWw/AHy927arz+V9+nwnsH/B8RayDY5nTfMzDfw22ezxzG4HFmxXR7anAX/fbVumz3D+hWSyxEeADwJndI89svtPwEeBD+XZBduzyf7PvRs4NRzvDnVnF/18jfKxaLfgmtnp7v65srZm9k6yD+HdZLO2s9z9ynDue+7+76N2hWyD3R+QzVT69XkO2eLFBJmm/VLgm2SO/zp3PzfH7gjgW912wbY7sgOymf3fA7j7SWXsBrC92d2PCOW3ht/ZV8i0u6+6+3k5tr8fbK/otjWzO4FD3X3GzNYBPyPT6I8O9a+L+ixkW7LPp8L5+4FLyP4g/TjxO+m2vTjY/t+E3RfJ3s/lwFPAs8Lv6WiyhaM1CdudyL4dJW2L2gXbdwInkkkFJ5DJAE+SLV79gbt/M9idRfatdE67rrEdTDbz3o9sYWwjcJW735X6nS05FtrTD3rQJfwXtSWb6e4cyi8AbiVzjNC7eFDIdoA+x8n+Y/yU9kxsOVHURVG7UFco6qOoXfO+y9hG5VuAvUL5WfQu3BWyJVoYpXfx6bau14VsS/b5fTLZ7FiydYUfky3wrAF2GcSWchE3hWxL9nl7dH4n4Juh/Hx6P8997XQUP2q9M8zMfphz3A7sPaDtuLv/PwDPxPujgFeZ2YfIPpwMYFumzxl3n3X3Z4D73f2nod1mspCesnaQhbN9l2xx8SnPZhyb3f1b7v6tAewADithO2ZZfOceZLOoH4d7/RkwM6DtHWZ2eij/wMwOBzCzg8jCnBjAtkyf7u4Nd7/e3d9Ctq7wcTLZ6oEBbcfMbArYhcyB7Rbqp4HuzTpFbcv0Ce1F6unQBnd/OGFb1K5UfPCSZaE9/VwH2V/olWThZPHxAuDRQWzJvvqu7Go7AVwIzHbVF7It2ed3gJ1CeSyq343OEJtCdl19rwAuBz7GHDP+onZFbYGHyBzKg+Hn80L9zvTOFAvZhnF+nuzr+HfIHOEDZPLJoV19FrIt2ef35/idLB/EliwE8gGy2O53AjcAnyKbQZ7T1a6Qbck+zwJ+SJbG8B7g9FC/F/DtsnaRfV588Hvoig9eqseC38CcN5d9Dfu1nHMXD2IbHMfzcuy6V2kL2ZbsczrHbk86YyYL2eXYzBn1UdaurG3UZifggGFsyWZTh5LNsPfu00ch2yJ2wEElxlnGtlDETRnbkn0eEs6/uM99FrILtoXjg5fqsWgXw4QQ9cDMrieL8kjFB7/S3Y9ZwNurBbXWaIUQi4I3ke0u+5aZPWFmT5BF0uxOlstkyaMZrRCiMsqEYY4ycrRCiMows4fd/fkLfR8LTb9cB0IIMSdm9sO8U3SFYS5V5GiFEMOyN3Ac2e6xGAP+acffTv2QoxVCDMvVZDsjb+s+YWbf3OF3U0Ok0QohRMUovEsIISpGjlYIISpGjlYIISpGjlYIISrm/wPh1KrrpPhYigAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation time of strategy S\n",
    "NFS=np.zeros((n-3,n-3))\n",
    "for i in range (0,n-3):\n",
    "    for j in range (0,n-3):\n",
    "        fp=(FA[i,j])*((ros[j]))\n",
    "        if fp==0:\n",
    "            NFS[i,j]=0\n",
    "        else:\n",
    "            NFS[i,j]=(FA[i,j])*((ros[j])/(ros[i]))\n",
    "            \n",
    "def pol(k):\n",
    "    t=0\n",
    "    for x in range (0,n-3):\n",
    "        t=t+NFS[k,x] \n",
    "    return(t)\n",
    "        \n",
    "PRO=[]\n",
    "for x in range (0,n-3):\n",
    "    PRO.append(pol(x))\n",
    "    \n",
    "#time\n",
    "WW=[0,0,0]\n",
    "JKL=WW+PRO\n",
    "def reyt(x):\n",
    "    if x==1:\n",
    "        return([JKL[0]])\n",
    "    if x==N+1:\n",
    "        GH=[JKL[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(JKL)):\n",
    "            GH.append(JKL[s])\n",
    "        GH.append(JKL[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(JKL[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ERt=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ERt[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(reyt(j))):\n",
    "        ERt[j-1][N-len(reyt(j))+2*k+1]=reyt(j)[k]\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ERt[x,y])=='nan' and str(ERt[x,y-1])!='nan' and str(ERt[x,y+1])!='nan':\n",
    "            ERt[x,y]=ERt[x,y+1]            \n",
    "ERt[N][2*N-1]=ERt[N][2*N] \n",
    "\n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N+1):\n",
    "        if ERt[x,y]==0:\n",
    "            ERt[x,y]='nan'\n",
    "            \n",
    "for x in range (0,2*N+1):\n",
    "    ERt[N][x]=np.nan\n",
    "\n",
    "ERt[0][N]=1\n",
    "\n",
    "ax = sns.heatmap(ERt,yticklabels=False,cmap='Spectral') \n",
    "plt.savefig('N=50-An.time.pdf',dbi=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Mahdi\\AppData\\Local\\Temp/ipykernel_8056/3188151843.py:66: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"dbi\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
      "  plt.savefig('N=50-An.time.pdf',dbi=1000)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fixation time of strategy R\n",
    "NFR=np.zeros((n-3,n-3))\n",
    "for i in range (0,n-3):\n",
    "    for j in range (0,n-3):\n",
    "        fp=(FA[i,j])*((ror[j]))\n",
    "        if fp==0:\n",
    "            NFR[i,j]=0\n",
    "        else:\n",
    "            NFR[i,j]=(FA[i,j])*((ror[j])/(ror[i]))\n",
    "            \n",
    "def pol(k):\n",
    "    t=0\n",
    "    for x in range (0,n-3):\n",
    "        t=t+NFR[k,x] \n",
    "    return(t)\n",
    "        \n",
    "PRO=[]\n",
    "for x in range (0,n-3):\n",
    "    PRO.append(pol(x))\n",
    "    \n",
    "#time\n",
    "WW=[0,0,0]\n",
    "JKL=WW+PRO\n",
    "def reyt(x):\n",
    "    if x==1:\n",
    "        return([JKL[0]])\n",
    "    if x==N+1:\n",
    "        GH=[JKL[1]]\n",
    "        for s in range (int(x*(x-1)//2+2),len(JKL)):\n",
    "            GH.append(JKL[s])\n",
    "        GH.append(JKL[2])\n",
    "        return(GH)\n",
    "        \n",
    "    ui=[]\n",
    "    for j in range (int(x*(x+1)//2-x+2),int(x*(x+1)//2+2)):\n",
    "        ui.append(JKL[j])\n",
    "    return(ui)\n",
    "\n",
    "\n",
    "ERt=np.zeros((N+2,2*N+1))\n",
    "for i in range (0,N+2):\n",
    "    for j in range (0,2*N+1):\n",
    "        ERt[i][j]='nan'\n",
    "for j in range (1,N+2):\n",
    "    for k in range (0, len(reyt(j))):\n",
    "        ERt[j-1][N-len(reyt(j))+2*k+1]=reyt(j)[k]\n",
    "\n",
    "        \n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N-1):\n",
    "        if str(ERt[x,y])=='nan' and str(ERt[x,y-1])!='nan' and str(ERt[x,y+1])!='nan':\n",
    "            ERt[x,y]=ERt[x,y+1]            \n",
    "ERt[N][2*N-1]=ERt[N][2*N] \n",
    "\n",
    "for x in range (0,N+1):\n",
    "    for y in range (0,2*N+1):\n",
    "        if ERt[x,y]==0:\n",
    "            ERt[x,y]='nan'\n",
    "            \n",
    "for x in range (0,N):\n",
    "    ERt[x][N-x]=np.nan\n",
    "ERt[N][2*N-1]=2            \n",
    "ERt[N][2*N]=1\n",
    "\n",
    "ax = sns.heatmap(ERt,yticklabels=False,cmap='Spectral') \n",
    "plt.savefig('N=50-An.time.pdf',dbi=1000)"
   ]
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}