baseline-1-permutations-dos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "eb93e276",
   "metadata": {
    "papermill": {
     "duration": 0.00615,
     "end_time": "2024-07-20T15:07:28.921465",
     "exception": false,
     "start_time": "2024-07-20T15:07:28.915315",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# What is about ?\n",
    "\n",
    "Preliminary draft\n",
    "\n",
    "Baseline to decompose element into product of generators by ML methods. Permutation groups. \n",
    "\n",
    "    - Generate train set by random walks , i.e. pairs (g, k) \n",
    "    - Train model to preduct k from g\n",
    "    - Use it as heuristics in any algorithm which finds global minima of distnace, e.g. Metpropolis\n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba2cd3a4",
   "metadata": {
    "papermill": {
     "duration": 0.005357,
     "end_time": "2024-07-20T15:07:28.932624",
     "exception": false,
     "start_time": "2024-07-20T15:07:28.927267",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Preliminaries Install/Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "37fed004",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:28.945593Z",
     "iopub.status.busy": "2024-07-20T15:07:28.945202Z",
     "iopub.status.idle": "2024-07-20T15:07:31.152583Z",
     "shell.execute_reply": "2024-07-20T15:07:31.151234Z"
    },
    "papermill": {
     "duration": 2.21678,
     "end_time": "2024-07-20T15:07:31.155084",
     "exception": false,
     "start_time": "2024-07-20T15:07:28.938304",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/kaggle/input/growth-in-finite-groups/HeisenbergComputations.sage\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load\n",
    "\n",
    "import time\n",
    "t0start = time.time() \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "\n",
    "# Input data files are available in the read-only \"../input/\" directory\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "\n",
    "import os\n",
    "i = 0\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "#     if dirname == '/kaggle/input/growth-in-finite-groups/UT4_growth':\n",
    "    for filename in filenames:\n",
    "        i+=1\n",
    "        if i<= 1:\n",
    "            print(os.path.join(dirname, filename))\n",
    "\n",
    "# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "76a5257f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:31.168924Z",
     "iopub.status.busy": "2024-07-20T15:07:31.168317Z",
     "iopub.status.idle": "2024-07-20T15:07:34.566183Z",
     "shell.execute_reply": "2024-07-20T15:07:34.565025Z"
    },
    "papermill": {
     "duration": 3.407386,
     "end_time": "2024-07-20T15:07:34.568617",
     "exception": false,
     "start_time": "2024-07-20T15:07:31.161231",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.int16\n",
      "cpu\n"
     ]
    }
   ],
   "source": [
    "import torch \n",
    "import math\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "    dtype = torch.float\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    dtype = torch.float#int16  \n",
    "    dtype = torch.int16  \n",
    "    \n",
    "print(dtype)    \n",
    "print(device)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd3b9fa",
   "metadata": {
    "papermill": {
     "duration": 0.005978,
     "end_time": "2024-07-20T15:07:34.581071",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.575093",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Preliminaries Groups data "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0296e0",
   "metadata": {
    "papermill": {
     "duration": 0.005591,
     "end_time": "2024-07-20T15:07:34.592593",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.587002",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Load moves data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1accd92b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:34.606912Z",
     "iopub.status.busy": "2024-07-20T15:07:34.605776Z",
     "iopub.status.idle": "2024-07-20T15:07:34.935449Z",
     "shell.execute_reply": "2024-07-20T15:07:34.934368Z"
    },
    "papermill": {
     "duration": 0.339412,
     "end_time": "2024-07-20T15:07:34.938002",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.598590",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>puzzle_type</th>\n",
       "      <th>allowed_moves</th>\n",
       "      <th>n_generators</th>\n",
       "      <th>vector_len</th>\n",
       "      <th>puzzle_type_brief</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cube_2/2/2</td>\n",
       "      <td>{'f0': [0, 1, 19, 17, 6, 4, 7, 5, 2, 9, 3, 11,...</td>\n",
       "      <td>6</td>\n",
       "      <td>24</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cube_3/3/3</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 44, 41, 38, 15, 12, ...</td>\n",
       "      <td>9</td>\n",
       "      <td>54</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>cube_4/4/4</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>12</td>\n",
       "      <td>96</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>cube_5/5/5</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>15</td>\n",
       "      <td>150</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>cube_6/6/6</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>18</td>\n",
       "      <td>216</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>cube_7/7/7</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>21</td>\n",
       "      <td>294</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>cube_8/8/8</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>24</td>\n",
       "      <td>384</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>cube_9/9/9</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>27</td>\n",
       "      <td>486</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>cube_10/10/10</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>30</td>\n",
       "      <td>600</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>cube_19/19/19</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>57</td>\n",
       "      <td>2166</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>cube_33/33/33</td>\n",
       "      <td>{'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...</td>\n",
       "      <td>99</td>\n",
       "      <td>6534</td>\n",
       "      <td>cube</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>wreath_6/6</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 0, 6, 7, 8, 9], 'r': [6,...</td>\n",
       "      <td>2</td>\n",
       "      <td>10</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>wreath_7/7</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 6, 0, 7, 8, 9, 10, 11], ...</td>\n",
       "      <td>2</td>\n",
       "      <td>12</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>wreath_12/12</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1...</td>\n",
       "      <td>2</td>\n",
       "      <td>22</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>wreath_21/21</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...</td>\n",
       "      <td>2</td>\n",
       "      <td>40</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>wreath_33/33</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...</td>\n",
       "      <td>2</td>\n",
       "      <td>64</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>wreath_100/100</td>\n",
       "      <td>{'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...</td>\n",
       "      <td>2</td>\n",
       "      <td>198</td>\n",
       "      <td>wreath</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>globe_1/8</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>18</td>\n",
       "      <td>32</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>globe_1/16</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>34</td>\n",
       "      <td>64</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>globe_2/6</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, ...</td>\n",
       "      <td>15</td>\n",
       "      <td>36</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>globe_3/4</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 0, 8, 9, 10, 11, ...</td>\n",
       "      <td>12</td>\n",
       "      <td>32</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>globe_6/4</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 0, 8, 9, 10, 11, ...</td>\n",
       "      <td>15</td>\n",
       "      <td>56</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>globe_6/8</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>23</td>\n",
       "      <td>112</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>globe_6/10</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>27</td>\n",
       "      <td>140</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>globe_3/33</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>70</td>\n",
       "      <td>264</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>globe_8/25</td>\n",
       "      <td>{'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...</td>\n",
       "      <td>59</td>\n",
       "      <td>450</td>\n",
       "      <td>globe</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       puzzle_type                                      allowed_moves  \\\n",
       "0       cube_2/2/2  {'f0': [0, 1, 19, 17, 6, 4, 7, 5, 2, 9, 3, 11,...   \n",
       "1       cube_3/3/3  {'f0': [0, 1, 2, 3, 4, 5, 44, 41, 38, 15, 12, ...   \n",
       "2       cube_4/4/4  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "3       cube_5/5/5  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "4       cube_6/6/6  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "5       cube_7/7/7  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "6       cube_8/8/8  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "7       cube_9/9/9  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "8    cube_10/10/10  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "9    cube_19/19/19  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "10   cube_33/33/33  {'f0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...   \n",
       "11      wreath_6/6  {'l': [1, 2, 3, 4, 5, 0, 6, 7, 8, 9], 'r': [6,...   \n",
       "12      wreath_7/7  {'l': [1, 2, 3, 4, 5, 6, 0, 7, 8, 9, 10, 11], ...   \n",
       "13    wreath_12/12  {'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1...   \n",
       "14    wreath_21/21  {'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...   \n",
       "15    wreath_33/33  {'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...   \n",
       "16  wreath_100/100  {'l': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ...   \n",
       "17       globe_1/8  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "18      globe_1/16  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "19       globe_2/6  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, ...   \n",
       "20       globe_3/4  {'r0': [1, 2, 3, 4, 5, 6, 7, 0, 8, 9, 10, 11, ...   \n",
       "21       globe_6/4  {'r0': [1, 2, 3, 4, 5, 6, 7, 0, 8, 9, 10, 11, ...   \n",
       "22       globe_6/8  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "23      globe_6/10  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "24      globe_3/33  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "25      globe_8/25  {'r0': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,...   \n",
       "\n",
       "    n_generators  vector_len puzzle_type_brief  \n",
       "0              6          24              cube  \n",
       "1              9          54              cube  \n",
       "2             12          96              cube  \n",
       "3             15         150              cube  \n",
       "4             18         216              cube  \n",
       "5             21         294              cube  \n",
       "6             24         384              cube  \n",
       "7             27         486              cube  \n",
       "8             30         600              cube  \n",
       "9             57        2166              cube  \n",
       "10            99        6534              cube  \n",
       "11             2          10            wreath  \n",
       "12             2          12            wreath  \n",
       "13             2          22            wreath  \n",
       "14             2          40            wreath  \n",
       "15             2          64            wreath  \n",
       "16             2         198            wreath  \n",
       "17            18          32             globe  \n",
       "18            34          64             globe  \n",
       "19            15          36             globe  \n",
       "20            12          32             globe  \n",
       "21            15          56             globe  \n",
       "22            23         112             globe  \n",
       "23            27         140             globe  \n",
       "24            70         264             globe  \n",
       "25            59         450             globe  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd \n",
    "# fn = '/kaggle/input/santa-2023/puzzle_info.csv'\n",
    "fn = '/kaggle/input/growth-in-finite-groups/puzzle_info.csv'\n",
    "di = pd.read_csv(fn)\n",
    "di['n_generators'] = di['allowed_moves'].apply(lambda x: len(x.split(':'))-1)\n",
    "di['vector_len'] = di['allowed_moves'].apply(lambda x: len(x.split(']')[0].split('[')[1].split(',')))\n",
    "di['puzzle_type_brief'] = di['puzzle_type'].apply(lambda x: x.split('_')[0])\n",
    "\n",
    "display(di)\n",
    "di.to_csv('moves.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfae9017",
   "metadata": {
    "papermill": {
     "duration": 0.006263,
     "end_time": "2024-07-20T15:07:34.950938",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.944675",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Choose example (e.g. 2x2x2 or 3x3x3 cube or etc )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7b16f9db",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:34.965650Z",
     "iopub.status.busy": "2024-07-20T15:07:34.964727Z",
     "iopub.status.idle": "2024-07-20T15:07:34.974226Z",
     "shell.execute_reply": "2024-07-20T15:07:34.973235Z"
    },
    "papermill": {
     "duration": 0.019065,
     "end_time": "2024-07-20T15:07:34.976354",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.957289",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'f0': [0, 1, 2, 3, 4, 5, 44, 41, 38, 15, 12, 9, 16, 13, 10, 17, 14, 11, 6, 19, 20, 7, 22, 23, 8, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 45, 39, 40, 46, 42, 43, 47, 24, 21, 18, 48, 49, 50, 51, 52, 53], 'f1': [0, 1, 2, 43, 40, 37, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3, 20, 21, 4, 23, 24, 5, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 48, 38, 39, 49, 41, 42, 50, 44, 45, 46, 47, 25, 22, 19, 51, 52, 53], 'f2': [42, 39, 36, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
      "\n",
      "[[0, 1, 2, 3, 4, 5, 44, 41, 38, 15, 12, 9, 16, 13, 10, 17, 14, 11, 6, 19, 20, 7, 22, 23, 8, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 45, 39, 40, 46, 42, 43, 47, 24, 21, 18, 48, 49, 50, 51, 52, 53], [0, 1, 2, 43, 40, 37, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3, 20, 21, 4, 23, 24, 5, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 48, 38, 39, 49, 41, 42, 50, 44, 45, 46, 47, 25, 22, 19, 51, 52, 53], [42, 39, 36, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 21, 22\n",
      "number of generators: 9\n"
     ]
    }
   ],
   "source": [
    "group_gens_id ='cube_2/2/2'\n",
    "group_gens_id ='cube_3/3/3'\n",
    "\n",
    "m = di['puzzle_type'] == group_gens_id\n",
    "allowed_moves = di['allowed_moves'][m].iat[0]\n",
    "allowed_moves = str( allowed_moves ).replace(\"'\", '\"')\n",
    "import json\n",
    "dict_allowed_moves = json.loads(allowed_moves)\n",
    "print(str(dict_allowed_moves)[:500] )\n",
    "vec_len = len( dict_allowed_moves[list(dict_allowed_moves.keys())[0]])\n",
    "array_allowed_moves = np.zeros(  (len(dict_allowed_moves),  vec_len), dtype = int )\n",
    "for i in range(len(dict_allowed_moves)):\n",
    "    array_allowed_moves[i,:] = dict_allowed_moves[list(dict_allowed_moves.keys())[i]]\n",
    "array_allowed_moves    \n",
    "\n",
    "list_generators = list(dict_allowed_moves.values())\n",
    "print()\n",
    "print(str(list_generators)[:500])\n",
    "\n",
    "n_gens = len(list_generators)\n",
    "print('number of generators:', n_gens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a0d3011f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:34.995954Z",
     "iopub.status.busy": "2024-07-20T15:07:34.995303Z",
     "iopub.status.idle": "2024-07-20T15:07:35.006768Z",
     "shell.execute_reply": "2024-07-20T15:07:35.005441Z"
    },
    "papermill": {
     "duration": 0.022992,
     "end_time": "2024-07-20T15:07:35.009033",
     "exception": false,
     "start_time": "2024-07-20T15:07:34.986041",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List updated with inverses:\n",
      "[[0, 1, 2, 3, 4, 5, 44, 41, 38, 15, 12, 9, 16, 13, 10, 17, 14, 11, 6, 19, 20, 7, 22, 23, 8, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 45, 39, 40, 46, 42, 43, 47, 24, 21, 18, 48, 49, 50, 51, 52, 53], [0, 1, 2, 3, 4, 5, 18, 21, 24, 11, 14, 17, 10, 13, 16, 9, 12, 15, 47, 19, 20, 46, 22, 23, 45, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 8, 39, 40, 7, 42, 43, 6, 38, 41, 44, 48, 49, 50, 51, 52, 53], [0, 1, 2, 43, 40, 37, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 3, 20, 21, 4,\n",
      "number of generators: 18\n"
     ]
    }
   ],
   "source": [
    "def inverse_permutation(perm):\n",
    "    # Create an empty list to hold the inverse permutation\n",
    "    inverse = [0] * len(perm)\n",
    "    \n",
    "    # Iterate over the original permutation\n",
    "    for i, p in enumerate(perm):\n",
    "        # Place the index at the correct position in the inverse permutation\n",
    "        inverse[p] = i\n",
    "    \n",
    "    return inverse\n",
    "\n",
    "list_generators_add_inverses = []\n",
    "for perm in list_generators:\n",
    "    perm_inv = inverse_permutation(perm)\n",
    "    list_generators_add_inverses.append(perm)\n",
    "    if perm_inv != perm:\n",
    "        list_generators_add_inverses.append(perm_inv)\n",
    "    else:\n",
    "        print('perm == perm_inv - skipped')\n",
    "        print(perm)        \n",
    "        print(perm_inv)\n",
    "        \n",
    "list_generators =   list_generators_add_inverses     \n",
    "print('List updated with inverses:')\n",
    "print(str(list_generators)[:500])\n",
    "\n",
    "list_generators_clean_duplicates = []\n",
    "for p1 in list_generators:\n",
    "    flag_already_in = False\n",
    "    for p in list_generators_clean_duplicates:\n",
    "        if p1 == p : \n",
    "            flag_already_in = True\n",
    "            break\n",
    "    if not flag_already_in :\n",
    "        list_generators_clean_duplicates.append(p1)\n",
    "        \n",
    "list_generators = list_generators_clean_duplicates\n",
    "\n",
    "n_gens = len(list_generators)       \n",
    "print('number of generators:', n_gens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "39fa1ade",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:35.031147Z",
     "iopub.status.busy": "2024-07-20T15:07:35.029942Z",
     "iopub.status.idle": "2024-07-20T15:07:35.097139Z",
     "shell.execute_reply": "2024-07-20T15:07:35.095944Z"
    },
    "papermill": {
     "duration": 0.08071,
     "end_time": "2024-07-20T15:07:35.099483",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.018773",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state_size: 54\n",
      "CPU times: user 3.55 ms, sys: 2.4 ms, total: 5.95 ms\n",
      "Wall time: 42 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  1,  2,  3,  4,  5, 44, 41, 38, 15, 12,  9, 16, 13, 10, 17, 14, 11,\n",
       "          6, 19, 20,  7, 22, 23,  8, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
       "         36, 37, 45, 39, 40, 46, 42, 43, 47, 24, 21, 18, 48, 49, 50, 51, 52, 53],\n",
       "        [ 0,  1,  2,  3,  4,  5, 18, 21, 24, 11, 14, 17, 10, 13, 16,  9, 12, 15,\n",
       "         47, 19, 20, 46, 22, 23, 45, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
       "         36, 37,  8, 39, 40,  7, 42, 43,  6, 38, 41, 44, 48, 49, 50, 51, 52, 53],\n",
       "        [ 0,  1,  2, 43, 40, 37,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "         18,  3, 20, 21,  4, 23, 24,  5, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
       "         36, 48, 38, 39, 49, 41, 42, 50, 44, 45, 46, 47, 25, 22, 19, 51, 52, 53],\n",
       "        [ 0,  1,  2, 19, 22, 25,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "         18, 50, 20, 21, 49, 23, 24, 48, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
       "         36,  5, 38, 39,  4, 41, 42,  3, 44, 45, 46, 47, 37, 40, 43, 51, 52, 53],\n",
       "        [42, 39, 36,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "         18, 19,  0, 21, 22,  1, 24, 25,  2, 29, 32, 35, 28, 31, 34, 27, 30, 33,\n",
       "         51, 37, 38, 52, 40, 41, 53, 43, 44, 45, 46, 47, 48, 49, 50, 26, 23, 20],\n",
       "        [20, 23, 26,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
       "         18, 19, 53, 21, 22, 52, 24, 25, 51, 33, 30, 27, 34, 31, 28, 35, 32, 29,\n",
       "          2, 37, 38,  1, 40, 41,  0, 43, 44, 45, 46, 47, 48, 49, 50, 36, 39, 42],\n",
       "        [ 0,  1, 11,  3,  4, 14,  6,  7, 17,  9, 10, 47, 12, 13, 50, 15, 16, 53,\n",
       "         24, 21, 18, 25, 22, 19, 26, 23, 20,  8, 28, 29,  5, 31, 32,  2, 34, 35,\n",
       "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 33, 48, 49, 30, 51, 52, 27],\n",
       "        [ 0,  1, 33,  3,  4, 30,  6,  7, 27,  9, 10,  2, 12, 13,  5, 15, 16,  8,\n",
       "         20, 23, 26, 19, 22, 25, 18, 21, 24, 53, 28, 29, 50, 31, 32, 47, 34, 35,\n",
       "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 11, 48, 49, 14, 51, 52, 17],\n",
       "        [ 0, 10,  2,  3, 13,  5,  6, 16,  8,  9, 46, 11, 12, 49, 14, 15, 52, 17,\n",
       "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27,  7, 29, 30,  4, 32, 33,  1, 35,\n",
       "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 34, 47, 48, 31, 50, 51, 28, 53],\n",
       "        [ 0, 34,  2,  3, 31,  5,  6, 28,  8,  9,  1, 11, 12,  4, 14, 15,  7, 17,\n",
       "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 52, 29, 30, 49, 32, 33, 46, 35,\n",
       "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 10, 47, 48, 13, 50, 51, 16, 53],\n",
       "        [ 9,  1,  2, 12,  4,  5, 15,  7,  8, 45, 10, 11, 48, 13, 14, 51, 16, 17,\n",
       "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,  6, 30, 31,  3, 33, 34,  0,\n",
       "         38, 41, 44, 37, 40, 43, 36, 39, 42, 35, 46, 47, 32, 49, 50, 29, 52, 53],\n",
       "        [35,  1,  2, 32,  4,  5, 29,  7,  8,  0, 10, 11,  3, 13, 14,  6, 16, 17,\n",
       "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 51, 30, 31, 48, 33, 34, 45,\n",
       "         42, 39, 36, 43, 40, 37, 44, 41, 38,  9, 46, 47, 12, 49, 50, 15, 52, 53],\n",
       "        [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 42, 43, 44,\n",
       "         18, 19, 20, 21, 22, 23, 15, 16, 17, 27, 28, 29, 30, 31, 32, 24, 25, 26,\n",
       "         36, 37, 38, 39, 40, 41, 33, 34, 35, 51, 48, 45, 52, 49, 46, 53, 50, 47],\n",
       "        [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 24, 25, 26,\n",
       "         18, 19, 20, 21, 22, 23, 33, 34, 35, 27, 28, 29, 30, 31, 32, 42, 43, 44,\n",
       "         36, 37, 38, 39, 40, 41, 15, 16, 17, 47, 50, 53, 46, 49, 52, 45, 48, 51],\n",
       "        [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 39, 40, 41, 15, 16, 17,\n",
       "         18, 19, 20, 12, 13, 14, 24, 25, 26, 27, 28, 29, 21, 22, 23, 33, 34, 35,\n",
       "         36, 37, 38, 30, 31, 32, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
       "        [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 21, 22, 23, 15, 16, 17,\n",
       "         18, 19, 20, 30, 31, 32, 24, 25, 26, 27, 28, 29, 39, 40, 41, 33, 34, 35,\n",
       "         36, 37, 38, 12, 13, 14, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
       "        [ 2,  5,  8,  1,  4,  7,  0,  3,  6, 36, 37, 38, 12, 13, 14, 15, 16, 17,\n",
       "          9, 10, 11, 21, 22, 23, 24, 25, 26, 18, 19, 20, 30, 31, 32, 33, 34, 35,\n",
       "         27, 28, 29, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
       "        [ 6,  3,  0,  7,  4,  1,  8,  5,  2, 18, 19, 20, 12, 13, 14, 15, 16, 17,\n",
       "         27, 28, 29, 21, 22, 23, 24, 25, 26, 36, 37, 38, 30, 31, 32, 33, 34, 35,\n",
       "          9, 10, 11, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53]],\n",
       "       dtype=torch.int32)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "state_size = len(list_generators[0])\n",
    "print('state_size:',state_size)\n",
    "all_moves = torch.zeros( n_gens, state_size ,  device=device, dtype = torch.int32)\n",
    "for k in range(n_gens):\n",
    "    all_moves[k,:] = torch.tensor( list_generators[k],  device=device, dtype = torch.int32)\n",
    "all_moves"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694c8e88",
   "metadata": {
    "papermill": {
     "duration": 0.006852,
     "end_time": "2024-07-20T15:07:35.113538",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.106686",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Train set generation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8e4fd6f",
   "metadata": {
    "papermill": {
     "duration": 0.006834,
     "end_time": "2024-07-20T15:07:35.127437",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.120603",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Function to generate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5ed28ad5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:35.143708Z",
     "iopub.status.busy": "2024-07-20T15:07:35.142810Z",
     "iopub.status.idle": "2024-07-20T15:07:35.185340Z",
     "shell.execute_reply": "2024-07-20T15:07:35.184184Z"
    },
    "papermill": {
     "duration": 0.05308,
     "end_time": "2024-07-20T15:07:35.187576",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.134496",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:\n",
      "X.shape torch.Size([6, 54])\n",
      "tensor([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
      "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
      "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
      "        [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
      "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
      "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53],\n",
      "        [ 9,  1,  2, 12,  4,  5, 15,  7,  8, 45, 10, 11, 48, 13, 14, 51, 16, 17,\n",
      "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,  6, 30, 31,  3, 33, 34,  0,\n",
      "         38, 41, 44, 37, 40, 43, 36, 39, 42, 35, 46, 47, 32, 49, 50, 29, 52, 53],\n",
      "        [20, 23, 26,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
      "         18, 19, 53, 21, 22, 52, 24, 25, 51, 33, 30, 27, 34, 31, 28, 35, 32, 29,\n",
      "          2, 37, 38,  1, 40, 41,  0, 43, 44, 45, 46, 47, 48, 49, 50, 36, 39, 42],\n",
      "        [ 9,  1,  2, 12,  4,  5, 15,  7,  8, 45, 10, 11, 37, 40, 43, 51, 16, 17,\n",
      "         18, 19, 20, 48, 13, 14, 24, 25, 26, 27, 28,  6, 21, 22, 23, 33, 34,  0,\n",
      "         38, 41, 44, 30, 31,  3, 36, 39, 42, 35, 46, 47, 32, 49, 50, 29, 52, 53],\n",
      "        [20, 32, 26,  3, 31,  5,  6, 30,  8,  9, 23, 11, 12,  4, 14, 15,  7, 17,\n",
      "         18, 19, 53, 21, 22, 52, 24, 25, 51, 33, 39, 27, 34, 49, 28, 35, 46, 29,\n",
      "          2, 37, 38,  1, 40, 41,  0, 43, 44, 45, 10, 47, 48, 13, 50, 36, 16, 42]],\n",
      "       dtype=torch.int16)\n",
      "y\n",
      "y.shape torch.Size([6])\n",
      "tensor([0, 0, 1, 1, 2, 2], dtype=torch.int16)\n",
      "CPU times: user 4.72 ms, sys: 1.57 ms, total: 6.29 ms\n",
      "Wall time: 26.5 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "def random_walks(generators , n_random_walk_length,  n_random_walks_to_generate,    rw_start = None, \n",
    "                 device=device, dtype = dtype , verbose = 0   ):\n",
    "    '''\n",
    "    Output:\n",
    "    returns X,y: X - array of states, y - number of steps rw achieves it\n",
    "    \n",
    "    Input: \n",
    "    generators - generators (moves) to make random walks  (permutations), \n",
    "        can be list of vectors or array with vstacked vectors\n",
    "    n_random_walk_length - number of visited nodes, i.e. number of steps + 1 \n",
    "    n_random_walks_to_generate - how many random walks will run in parrallel\n",
    "    rw_start - initial states for random walks - by default we will use 0,1,2,3 ...\n",
    "        Can be vector or array\n",
    "        If it is vector it will be broadcasted n_random_walks_to_generate times, \n",
    "        If it is array n_random_walks_to_generate - input n_random_walks_to_generate will be ignored\n",
    "            and will be assigned: n_random_walks_to_generate = rw_start.shape[0]\n",
    "    \n",
    "    '''\n",
    "\n",
    "    # Prepare generators in tensor format:\n",
    "    if isinstance(generators, list):\n",
    "        state_size = len(generators[0])\n",
    "        all_moves = torch.zeros( n_gens, state_size ,  device=device, dtype = torch.int32) # Cannot use signed types \n",
    "        for k in range(n_gens):\n",
    "            all_moves[k,:] = torch.tensor( generators[k],  device=device, dtype = torch.int32) \n",
    "    else:\n",
    "        all_moves = generators\n",
    "        state_size = generators.shape[1]\n",
    "    n_generators = all_moves.shape[0] \n",
    "    \n",
    "    if verbose >= 100:\n",
    "        print('state_size', state_size )\n",
    "        \n",
    "\n",
    "    # Initialize current array of steps with  state_rw_start - expanding (broadcasting) it into array: \n",
    "    if rw_start is None:        \n",
    "        # Starting state for random walks (for train data it is our destination state - \"solved puzzle state\")  \n",
    "        state_rw_start = torch.arange( state_size, device=device, dtype = dtype)\n",
    "        array_of_states = state_rw_start.view(1, state_size  ).expand(n_random_walks_to_generate, state_size )\n",
    "    else:\n",
    "        if len(rw_start.shape) == 1:\n",
    "            array_of_states = rw_start.view(1, state_size  ).expand(n_random_walks_to_generate, state_size )\n",
    "        else :\n",
    "            array_of_states = rw_start\n",
    "    if verbose >= 100:\n",
    "        print('state_rw_start.shape:', state_rw_start.shape)\n",
    "        print('state_rw_start:',state_rw_start)\n",
    "        print(array_of_states.shape)\n",
    "        print( array_of_states[:3,:] )\n",
    "\n",
    "    # Output: X,y - states, y - how many steps we achieve them \n",
    "    # Allocate memory: \n",
    "    X = torch.zeros( (n_random_walks_to_generate)*n_random_walk_length , state_size,    device=device, dtype = dtype )\n",
    "    y = torch.zeros( (n_random_walks_to_generate)*n_random_walk_length ,    device=device, dtype = dtype )\n",
    "    if verbose >= 100:\n",
    "        print('X.shape',X.shape)\n",
    "\n",
    "    # First portion of data  - just our state_rw_start state  multiplexed many times\n",
    "    X[:n_random_walks_to_generate,:] = array_of_states\n",
    "    y[:n_random_walks_to_generate] = 0\n",
    "\n",
    "    # Technical to make array[ IX_array] we need  actually to write array[ range(N), IX_array  ]\n",
    "    row_indices = torch.arange( array_of_states.shape[0] , device=device, dtype = dtype )\n",
    "    row_indices = np.arange( array_of_states.shape[0] )[:, np.newaxis]\n",
    "\n",
    "    # Main loop \n",
    "    for i_step in range(1,n_random_walk_length):\n",
    "        y[ (i_step)*n_random_walks_to_generate : (i_step+1)*n_random_walks_to_generate  ] = i_step\n",
    "        IX_moves = np.random.randint(0, n_generators, size=n_random_walks_to_generate, dtype = int) # random moves indixes\n",
    "        new_array_of_states = array_of_states[ row_indices , all_moves[IX_moves,:]] # all_moves[IX_moves,:] ] \n",
    "        array_of_states = new_array_of_states\n",
    "        X[ (i_step)*n_random_walks_to_generate : (i_step+1)*n_random_walks_to_generate , : ] = new_array_of_states\n",
    "\n",
    "    if verbose >= 100:\n",
    "        print(array_of_states.shape, 'array_of_states.shape')\n",
    "        print(n_random_walk_length, 'n_random_walk_length', state_size,'state_size', '' )    \n",
    "        print('Finished')\n",
    "        print(str(X)[:500] )\n",
    "        print(str(y)[:500] )\n",
    "        \n",
    "    return X,y\n",
    "\n",
    "X_tmp, y_tmp = random_walks(list_generators , n_random_walk_length = 3,  n_random_walks_to_generate =  2) #,    rw_start = None, \n",
    "                 #device=device, dtype = dtype , verbose = 0   )\n",
    "\n",
    "print('X:')\n",
    "print('X.shape', X_tmp.shape)\n",
    "print(X_tmp)\n",
    "\n",
    "print('y')\n",
    "print('y.shape', y_tmp.shape)\n",
    "print(y_tmp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3eb0a2b",
   "metadata": {
    "papermill": {
     "duration": 0.006989,
     "end_time": "2024-07-20T15:07:35.201492",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.194503",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Genration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "efd45a1e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:35.217513Z",
     "iopub.status.busy": "2024-07-20T15:07:35.217137Z",
     "iopub.status.idle": "2024-07-20T15:07:35.499348Z",
     "shell.execute_reply": "2024-07-20T15:07:35.498258Z"
    },
    "papermill": {
     "duration": 0.293448,
     "end_time": "2024-07-20T15:07:35.502471",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.209023",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "X_train, y_train = random_walks(list_generators ,n_random_walk_length = 30 ,  n_random_walks_to_generate = 10_000 ) #,    rw_start = None, \n",
    "                 #device=device, dtype = dtype , verbose = 0   )\n",
    "\n",
    "X_test, y_test = random_walks(list_generators ,n_random_walk_length = 30 ,  n_random_walks_to_generate = 10_000 ) #,    rw_start = None, \n",
    "                 #device=device, dtype = dtype , verbose = 0   )\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1d5000f",
   "metadata": {
    "papermill": {
     "duration": 0.00663,
     "end_time": "2024-07-20T15:07:35.516477",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.509847",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a86d882d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:35.532404Z",
     "iopub.status.busy": "2024-07-20T15:07:35.531638Z",
     "iopub.status.idle": "2024-07-20T15:07:36.280814Z",
     "shell.execute_reply": "2024-07-20T15:07:36.279511Z"
    },
    "papermill": {
     "duration": 0.759643,
     "end_time": "2024-07-20T15:07:36.283131",
     "exception": false,
     "start_time": "2024-07-20T15:07:35.523488",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 235 ms, sys: 58 ms, total: 293 ms\n",
      "Wall time: 742 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from xgboost import XGBRegressor\n",
    "from catboost import CatBoostRegressor\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "\n",
    "model = CatBoostRegressor(depth=4, verbose=False)\n",
    "str_model = 'CatBoost'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d3b8066",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:36.299251Z",
     "iopub.status.busy": "2024-07-20T15:07:36.298880Z",
     "iopub.status.idle": "2024-07-20T15:07:36.303462Z",
     "shell.execute_reply": "2024-07-20T15:07:36.302442Z"
    },
    "papermill": {
     "duration": 0.015536,
     "end_time": "2024-07-20T15:07:36.305941",
     "exception": false,
     "start_time": "2024-07-20T15:07:36.290405",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "#changed parameter depth and tried several options like 4, 6, 8, 10. The most suitable one was 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ee073a15",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:36.322122Z",
     "iopub.status.busy": "2024-07-20T15:07:36.321769Z",
     "iopub.status.idle": "2024-07-20T15:07:36.327959Z",
     "shell.execute_reply": "2024-07-20T15:07:36.326939Z"
    },
    "papermill": {
     "duration": 0.016879,
     "end_time": "2024-07-20T15:07:36.330173",
     "exception": false,
     "start_time": "2024-07-20T15:07:36.313294",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "X_train, y_train = X_train.numpy(), y_train.numpy()\n",
    "X_test, y_test = X_test.numpy(), y_test.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "08b8622c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:07:36.346542Z",
     "iopub.status.busy": "2024-07-20T15:07:36.346134Z",
     "iopub.status.idle": "2024-07-20T15:08:52.654797Z",
     "shell.execute_reply": "2024-07-20T15:08:52.653674Z"
    },
    "papermill": {
     "duration": 76.326231,
     "end_time": "2024-07-20T15:08:52.663668",
     "exception": false,
     "start_time": "2024-07-20T15:07:36.337437",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3min 40s, sys: 3.35 s, total: 3min 43s\n",
      "Wall time: 1min 16s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Model</th>\n",
       "      <th>r2 Test</th>\n",
       "      <th>r2 Train</th>\n",
       "      <th>rmse Test</th>\n",
       "      <th>rmse Train</th>\n",
       "      <th>FitTime</th>\n",
       "      <th>PredictTime</th>\n",
       "      <th>Train</th>\n",
       "      <th>Test</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CatBoost</td>\n",
       "      <td>0.697</td>\n",
       "      <td>0.715</td>\n",
       "      <td>4.764</td>\n",
       "      <td>4.62</td>\n",
       "      <td>57.409</td>\n",
       "      <td>6.352</td>\n",
       "      <td>(300000, 54)</td>\n",
       "      <td>(300000, 54)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Model  r2 Test  r2 Train  rmse Test  rmse Train  FitTime  PredictTime  \\\n",
       "1  CatBoost    0.697     0.715      4.764        4.62   57.409        6.352   \n",
       "\n",
       "          Train          Test  \n",
       "1  (300000, 54)  (300000, 54)  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "df_stat = pd.DataFrame()\n",
    "\n",
    "t0 = time.time()\n",
    "model.fit(X_train, y_train)\n",
    "fit_time = time.time() - t0\n",
    "\n",
    "t0 = time.time()\n",
    "y_pred = model.predict(X_test)\n",
    "predict_time = time.time() - t0\n",
    "\n",
    "t0 = time.time()\n",
    "y_pred = model.predict(X_test)\n",
    "predict_time = time.time() - t0\n",
    "y_pred_train = model.predict(X_train)\n",
    "r2_test = r2_score(y_test, y_pred)\n",
    "rmse_test = mean_squared_error(y_test, y_pred,  squared=False)\n",
    "\n",
    "r2_train = r2_score(y_train, y_pred_train)\n",
    "rmse_train = mean_squared_error(y_train, y_pred_train, squared=False)\n",
    "\n",
    "\n",
    "IX = len(df_stat)+1\n",
    "\n",
    "df_stat.loc[IX,'Model'] = str_model\n",
    "df_stat.loc[IX,'r2 Test'] = r2_test\n",
    "df_stat.loc[IX,'r2 Train'] = r2_train\n",
    "df_stat.loc[IX,'rmse Test'] = rmse_test\n",
    "df_stat.loc[IX,'rmse Train'] = rmse_train\n",
    "df_stat.loc[IX,'FitTime'] = np.round(fit_time,3)\n",
    "df_stat.loc[IX,'PredictTime'] = np.round(predict_time,3)\n",
    "df_stat.loc[IX,'Train'] = str(X_train.shape)\n",
    "df_stat.loc[IX,'Test'] = str(X_test.shape)\n",
    "\n",
    "\n",
    "\n",
    "df_stat.round(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0732e35",
   "metadata": {
    "papermill": {
     "duration": 0.007007,
     "end_time": "2024-07-20T15:08:52.678049",
     "exception": false,
     "start_time": "2024-07-20T15:08:52.671042",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Pathfinder by Metropolis + ML model\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d6660049",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:08:52.694346Z",
     "iopub.status.busy": "2024-07-20T15:08:52.693987Z",
     "iopub.status.idle": "2024-07-20T15:08:53.718151Z",
     "shell.execute_reply": "2024-07-20T15:08:53.716710Z"
    },
    "papermill": {
     "duration": 1.035299,
     "end_time": "2024-07-20T15:08:53.720518",
     "exception": false,
     "start_time": "2024-07-20T15:08:52.685219",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state_size 54\n",
      "n_scrambles_starting_state: 2 beta: -0.5 n_walks_to_generate 1000 n_walk_length 20 n_trials 10\n",
      "Found destination state.  i_step: 2  n_ways: 9\n",
      "Found destination state.  i_step: 2  n_ways: 8\n",
      "Found destination state.  i_step: 2  n_ways: 8\n",
      "Found destination state.  i_step: 2  n_ways: 10\n",
      "Found destination state.  i_step: 2  n_ways: 7\n",
      "Found destination state.  i_step: 2  n_ways: 11\n",
      "Found destination state.  i_step: 2  n_ways: 7\n",
      "Found destination state.  i_step: 2  n_ways: 9\n",
      "Found destination state.  i_step: 2  n_ways: 5\n",
      "Found destination state.  i_step: 2  n_ways: 8\n",
      "Finished\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>trial</th>\n",
       "      <th>Path Len</th>\n",
       "      <th>n_paths</th>\n",
       "      <th>Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>0.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>5.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>6.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>7.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>8.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>9.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    trial  Path Len  n_paths  Time\n",
       "1     0.0       2.0      9.0  0.10\n",
       "2     1.0       2.0      8.0  0.10\n",
       "3     2.0       2.0      8.0  0.10\n",
       "4     3.0       2.0     10.0  0.09\n",
       "5     4.0       2.0      7.0  0.10\n",
       "6     5.0       2.0     11.0  0.10\n",
       "7     6.0       2.0      7.0  0.10\n",
       "8     7.0       2.0      9.0  0.10\n",
       "9     8.0       2.0      5.0  0.10\n",
       "10    9.0       2.0      8.0  0.10"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>trial</th>\n",
       "      <th>Path Len</th>\n",
       "      <th>n_paths</th>\n",
       "      <th>Time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>10.00000</td>\n",
       "      <td>10.0</td>\n",
       "      <td>10.000000</td>\n",
       "      <td>10.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>4.50000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>8.200000</td>\n",
       "      <td>0.099000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.02765</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.686548</td>\n",
       "      <td>0.003162</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.00000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>0.090000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>2.25000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>7.250000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>4.50000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>6.75000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>9.000000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>9.00000</td>\n",
       "      <td>2.0</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          trial  Path Len    n_paths       Time\n",
       "count  10.00000      10.0  10.000000  10.000000\n",
       "mean    4.50000       2.0   8.200000   0.099000\n",
       "std     3.02765       0.0   1.686548   0.003162\n",
       "min     0.00000       2.0   5.000000   0.090000\n",
       "25%     2.25000       2.0   7.250000   0.100000\n",
       "50%     4.50000       2.0   8.000000   0.100000\n",
       "75%     6.75000       2.0   9.000000   0.100000\n",
       "max     9.00000       2.0  11.000000   0.100000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_scrambles_starting_state: 2 beta: -0.5 n_walks_to_generate 1000 n_walk_length 20 n_trials 10\n",
      "CPU times: user 1.26 s, sys: 38.9 ms, total: 1.3 s\n",
      "Wall time: 1.01 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "n_generators = len(list_generators)\n",
    "\n",
    "print('state_size', state_size )\n",
    "\n",
    "# Params:\n",
    "n_walks_to_generate = 1_000\n",
    "n_walk_length = 20 # _000#\n",
    "n_trials = 10\n",
    "beta = -0.5 # Inverse to temperature - when zero it will be pure random walk\n",
    "n_scrambles_starting_state = 2\n",
    "print('n_scrambles_starting_state:',n_scrambles_starting_state, 'beta:',beta, 'n_walks_to_generate', n_walks_to_generate, 'n_walk_length',n_walk_length , 'n_trials', n_trials)\n",
    "\n",
    "\n",
    "# destination state - \"solved puzzle state\"   \n",
    "state_destination = torch.arange( state_size, device=device, dtype = dtype)\n",
    "\n",
    "\n",
    "# Scramble - generate state which will be start of Metropolis   \n",
    "state_start = state_destination\n",
    "for k in range(n_scrambles_starting_state):\n",
    "    IX_move = np.random.randint(0, n_gens, dtype = int) # random moves indixes\n",
    "    state_start = state_start[ list_generators[IX_move]] # all_moves[IX_moves,:] ] \n",
    "    \n",
    "\n",
    "\n",
    "# Technical to make array[ IX_array] we need  actually to write array[ range(N), IX_array  ]\n",
    "row_indices = torch.arange( n_walks_to_generate , device=device, dtype = dtype )\n",
    "row_indices = np.arange( n_walks_to_generate )[:, np.newaxis]\n",
    "\n",
    "\n",
    "# Collect simulation statistics here \n",
    "df_stat = pd.DataFrame()\n",
    "\n",
    "# Main loop \n",
    "for i_trial in range(n_trials):\n",
    "\n",
    "\n",
    "    # Initialize current array of steps with  state_rw_start - expanding (broadcasting) it into array: \n",
    "    array_of_states = state_start.view(1, state_size  ).expand(n_walks_to_generate, state_size ).clone()\n",
    "    #array_of_states = array_of_states.numpy()\n",
    "\n",
    "\n",
    "    # storage for all moves , we will need them to restore path to destination if find it \n",
    "    all_IX_moves = torch.zeros( n_walks_to_generate, n_walk_length, device=device, dtype = int)\n",
    "    \n",
    "    t01 = time.time()\n",
    "    flag_found_destination = False\n",
    "    for i_step in range(1,n_walk_length):\n",
    "        # Generate and make random moves: \n",
    "        #IX_moves = torch.randint(0, n_generators,  size= (n_walks_to_generate,),  device=device, dtype = int) # random moves indices\n",
    "        IX_moves = np.random.randint(0, n_generators,  size= (n_walks_to_generate,))# ,  device=device, dtype = int) # random moves indices\n",
    "        new_array_of_states = array_of_states[ row_indices , all_moves[IX_moves,:]] # all_moves[IX_moves,:] ] \n",
    "\n",
    "        # Energy for old states:\n",
    "        # hamming_distance =  ((array_of_states - state_destination).to(torch.bool)).sum(axis = 1)\n",
    "        # initial_energy = hamming_distance.clone()\n",
    "        initial_energy = model.predict(array_of_states.numpy())\n",
    "        initial_energy[initial_energy<=0]=0\n",
    "\n",
    "        # Energy for new states \n",
    "        # hamming_distance =  ((new_array_of_states - state_destination).to(torch.bool)).sum(axis = 1)\n",
    "        # proposed_energy = hamming_distance\n",
    "        proposed_energy = model.predict(new_array_of_states.numpy())\n",
    "        proposed_energy[proposed_energy<=0]=0\n",
    "\n",
    "        # Calculate the probability of acceptance  # For beta = 0 it will be all 1\n",
    "        #acceptance_prob = torch.exp(beta * (initial_energy - proposed_energy))\n",
    "        acceptance_prob = np.exp(beta * (initial_energy - proposed_energy))\n",
    "\n",
    "        # Generate random numbers for decision making\n",
    "        #random_numbers = torch.rand(n_walks_to_generate, device=device, dtype=torch.float32)\n",
    "        random_numbers = np.random.rand(n_walks_to_generate)#, device=device, dtype=torch.float32)\n",
    "\n",
    "        # Accept or reject proposed states\n",
    "        accept = random_numbers < acceptance_prob\n",
    "        # For beta = 0 , acceptance_prob = 1 , so always accepted - so just random walk \n",
    "\n",
    "        # Change states and save steps\n",
    "        all_IX_moves[accept,i_step] = torch.tensor(IX_moves[accept])\n",
    "        array_of_states[accept,:] = new_array_of_states[accept,:]    \n",
    "\n",
    "        # Check destination state found \n",
    "        sm = (proposed_energy == 0).sum().item()\n",
    "        if  sm > 0:\n",
    "            flag_found_destination = True\n",
    "            print('Found destination state. ', 'i_step:', i_step, ' n_ways:', sm)\n",
    "            # Statistics: \n",
    "            IX_tmp = len(df_stat)+1\n",
    "            df_stat.loc[IX_tmp,'trial'] = i_trial\n",
    "            df_stat.loc[IX_tmp,'Path Len'] = i_step\n",
    "            df_stat.loc[IX_tmp,'n_paths'] = sm\n",
    "            df_stat.loc[IX_tmp,'Time'] = np.round( time.time() - t01 , 2)\n",
    "            break\n",
    "    \n",
    "print('Finished')\n",
    "display(df_stat)\n",
    "df_stat.to_csv('df_stat.csv')\n",
    "if len(df_stat)>0:\n",
    "    display(df_stat.describe() )\n",
    "print('n_scrambles_starting_state:',n_scrambles_starting_state, 'beta:',beta, 'n_walks_to_generate', n_walks_to_generate, 'n_walk_length',n_walk_length , 'n_trials', n_trials)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4eee7a3",
   "metadata": {
    "papermill": {
     "duration": 0.00821,
     "end_time": "2024-07-20T15:08:53.737307",
     "exception": false,
     "start_time": "2024-07-20T15:08:53.729097",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Final timing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6de58875",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-20T15:08:53.755357Z",
     "iopub.status.busy": "2024-07-20T15:08:53.755007Z",
     "iopub.status.idle": "2024-07-20T15:08:53.761134Z",
     "shell.execute_reply": "2024-07-20T15:08:53.760174Z"
    },
    "papermill": {
     "duration": 0.017799,
     "end_time": "2024-07-20T15:08:53.763400",
     "exception": false,
     "start_time": "2024-07-20T15:08:53.745601",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84.8 seconds passed total \n",
      "1.4 minutes passed total \n",
      "0.02 hours passed total \n"
     ]
    }
   ],
   "source": [
    "print('%.1f seconds passed total '%(time.time()-t0start) )\n",
    "print('%.1f minutes passed total '%( (time.time()-t0start)/60)  )\n",
    "print('%.2f hours passed total '%( (time.time()-t0start)/3600)  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa09e534",
   "metadata": {
    "papermill": {
     "duration": 0.008235,
     "end_time": "2024-07-20T15:08:53.780084",
     "exception": false,
     "start_time": "2024-07-20T15:08:53.771849",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "none",
   "dataSources": [
    {
     "datasetId": 4441442,
     "sourceId": 8629066,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30732,
   "isGpuEnabled": false,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 88.771733,
   "end_time": "2024-07-20T15:08:54.911985",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2024-07-20T15:07:26.140252",
   "version": "2.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}