sanity.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/lmoss/onesharp/blob/main/sanity.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tools to help write programs"
      ],
      "metadata": {
        "id": "kG-CqHl2esSx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The main tool here is a Python program called Sanity.\n",
        "This tool makes it easier for someone to organize 1# programs and to write them without having to count lines for all of the forward- and backward-transfer statements.\n",
        "\n",
        "The concept and the name come from Jon Bowman, who once took my class and felt that construction 1# programs by hand was crazy, and that counting all the 1's in a long expression \"made his eyeballs bleed.\"\n",
        "\n",
        "To start, run the next code cell to install the 1# Python package in your Colab environment. Then run the second code cell to import the functions from the 1# package which are used in this notebook."
      ],
      "metadata": {
        "id": "LKMj7KdP0_vi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!python -m pip install -U setuptools\n",
        "!python -m pip install -U git+https://github.com/lmoss/onesharp.git@main"
      ],
      "metadata": {
        "id": "i2pvp3dz9io_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from onesharp.interpreter.interpreter import onesharp\n",
        "from onesharp.tools.sanity import sanity\n",
        "from onesharp.tools.ones import ones\n",
        "from onesharp.programs.clear import clear\n",
        "from onesharp.programs.move import move\n",
        "from onesharp.programs.copy import copy\n",
        "from onesharp.programs.successor import successor\n",
        "from onesharp.programs.compare import compare\n",
        "from onesharp.programs.add import add"
      ],
      "metadata": {
        "id": "SwhANNcC-s2o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As a way to show what the tool does, we'll go through an example.  Let's write a program that takes a word \n",
        "\n",
        "$$ w = w_1 w_2 \\cdots w_n $$\n",
        "\n",
        "in R1 and reverses it.  \n",
        "Here is a *flowchart* for the program which we'll write:\n",
        "<img src=\"https://github.com/lmoss/onesharp/blob/main/more_programs/reverse_idea.jpg?raw=1\" width=\"100%\" height=\"100%\">\n",
        "Our program will work as follows.   It processes the letters in $w$ in order, using the loop shown in the top part of the flowchart. \n",
        "\n",
        "At the end of the $i$th iteration, we'll have $w_{i+1}\\cdots w_n$ in R1, and its prefix will be in R2 *backwards*: $w_{i}\\cdots w_2 w_1$.  \n",
        "Let's now consider what happens when we run the $(i+1)$-st iteration of the loop.  We have cases on the first symbol of R1, and we know that this is $w_{i+1}$.   If that first symbol is a $\\one$, we write it into R3, and then we move R2 onto the end of R3\n",
        "(emptying out R2) and then R3 is moved back go R2.  On the assumption that R2 had  $w_{i}\\cdots w_2 w_1$ before this iteration,\n",
        "it now has  $w_{i+1} w_{i}\\cdots w_2 w_1$.   The same thing happens if the first symbol in R1 was $\\hash$.  Finally, if R1 was empty,\n",
        "we would go to the bottom of the flowchart.  In this case,\n",
        "R2 would have $w_{n}\\cdots w_2 w_1$.  (This is what we want; it is the original input reversed.) And the flowchart indicates that we should move R2 back into R1.  So we are done.\n",
        "\n",
        "\n",
        "\n",
        "With this in mind, have a look at the following Python list called  'reverse_idea'.  It is a list of 8 arrays, and each of them is of a special form."
      ],
      "metadata": {
        "id": "ist0RI8rH78c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "reverse_idea = [\n",
        "    ['top', 'cases', 1, 'move_back', 'found_a_one', 'found_a_sharp'],\n",
        "    ['found_a_one','111#'],\n",
        "    ['goto', 'move_phase'],\n",
        "    ['found_a_sharp',  '111##'],\n",
        "    ['goto', 'move_phase'],\n",
        "    ['move_phase', move(2,3) + move(3,2)],\n",
        "    ['goto', 'top'],\n",
        "    ['move_back', move(2,1)]\n",
        "]"
      ],
      "metadata": {
        "id": "2FAj2rCASO0z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have here 8 *segments*.   A segment is not the same what we called a *line* of a $\\one\\hash$ program.  As the name suggests, a segment corresponds to a sequence of lines.\n",
        "For example, segments 6 and 8 each contain ```move``` programs that are bigger than a single instruction.  Segments 2, 4 5, and 6 each begin with a *label*.  Labels are strings that other parts of the program could point to.  For example, the first segment is a case statement $\\one\\hash^5$, and it also contains the information that if R1 is empty, we should go to whichever segmet has the label \"move_phase\". (That would be the segment named 'move_stuff_around'.) The first segment also tells us that if R1 begins with $\\one$ we should (delete is and) go to the segment containing 'first-is_one'.   Note also that 'goto' is not a label.  \n",
        "\n",
        "Also, note that a segment is not quite the samething as an item in the flowchart.   But this is pretty close.  \n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "EpHIPlFKzxIR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Workflow\n",
        "\n",
        "The workflow in this notebook is that you will need to \n",
        "\n",
        "(a) think about things deeply enough to make a correct flowchart\n",
        "\n",
        "(b) draw that flowchart, either with pencil and paper or with some tool (as I did here)\n",
        "\n",
        "(c) call a Python program called ```sanity``` on ```reverse_idea``` to get a $\\one\\hash$ program which you can then run.\n",
        "\n"
      ],
      "metadata": {
        "id": "58MVrwGbagCK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# example\n",
        "\n",
        "rev = sanity(reverse_idea)\n",
        "\n",
        "# This run 'sanity' on 'reverse_idea', calling the result 'rev'.\n",
        "# We can refer to it in the rest of this notebook by 'rev'.\n",
        "# For example we can display our new program\n",
        "rev"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "x64PWiqbzzv9",
        "outputId": "8ff1e323-826f-47f7-cd54-a0f10b47b366"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1#####1111111111111111111111###11###111###111#111###111##1###11#####11111 1###111###111##1111####111#11111 1####111#####11111 1###111###11##1111####11#11111 1####1111111111111111111111####11#####11111 1###111###1##1111####1#11111 1####'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now the program which we just constructed can be run, as usual:"
      ],
      "metadata": {
        "id": "1FAIHp4R00ni"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(rev,['1####'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "OBRTkqiXxpCC",
        "outputId": "8618a18e-3421-47d9-d710-73df01e142a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'####1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Here is a way to write the program 'clear_1':\n",
        "sanity([\n",
        "    ['top', 'cases',1,'empty', 'one','hash'],\n",
        "    ['empty', 'goto', 'end'],\n",
        "    ['one','goto', 'top'],\n",
        "    ['hash', 'goto', 'top'],\n",
        "])"
      ],
      "metadata": {
        "id": "WUTd0u_iG-A-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "bdb5a36c-eaaa-4f6e-82f5-fe507e4bc11b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1#####111###111###111###111###11111####111111####'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The inputs to ```sanity```\n",
        "\n",
        "```{admonition} What may go into a segment?\n",
        ":class: attention\n",
        "\n",
        "A segment is a Python list: it must be surrounded by square brackects.\n",
        "\n",
        "A segment can be snippet of 1# code surrounded by quotes.  \n",
        "\n",
        "A segment can be a Python expression like \n",
        "```move_3_1 + move_2_1```\n",
        "that denotes a 1# word.  (These expressions must be defined before you run ```sanity```, or you will get an error.)\n",
        "\n",
        "A segment can have 'add1' or 'add#' followed by a number (without quotes).  This number is a register number.\n",
        "\n",
        "A segment may be the word 'cases' followed by a number and then three labels.\n",
        " \n",
        "A segment may optionally begin with a *label* like 'top', or 'moveback', and then it either consists of a snippet of $\\one\\hash$ code surrounded by single quotes, or a Python expression that denotes a snippet of $\\one\\hash$ code\n",
        "```\n",
        "\n",
        "\n",
        "```{admonition} Labels\n",
        ":class: attention\n",
        "\n",
        "A label may be a word of English, and it may have the underscore symbol, but it should not have spaces.  It must be surrounded by quotes.  \n",
        "\n",
        "A label must not begin with '1' or '#, and it must not be one of the strings 'goto', 'end', 'add1', or 'add#'.\n",
        "\n",
        "*Labels are optional*, except a \"cases\" instruction\n",
        "must have a number and then three labels.   The number is for a register.   So \"cases on register 17\" would correspond to \n",
        "a segment with the number 17 as its third entry.\n",
        "\n",
        "Another label which may be used is 'goto'.\n",
        "A use of 'goto' must be followed either by a label or the word 'end'.\n",
        "\n",
        "\n",
        "\n",
        "Every label used inside a 'cases' or 'goto' statement must be the first label in some segment.  Otherwise, ```sanity``` will raise an error.\n",
        "```"
      ],
      "metadata": {
        "id": "45YVqabS_q0y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here is another example"
      ],
      "metadata": {
        "id": "vLnAtJzeDwkJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "diag_idea = [\n",
        "    ['top','cases',1,'empty', 'one','hash'],\n",
        "    ['empty', 'goto', 'moveback'],\n",
        "    ['one', 'add1', 2],\n",
        "    ['111#111##'],\n",
        "    ['goto', 'top'],\n",
        "    ['hash', 'add#', 2],\n",
        "    ['111#111##111##'],\n",
        "    ['goto', 'top'],\n",
        "    ['moveback', move(3,1)+move(2,1)] \n",
        "]\n",
        "diag = sanity(diag_idea)"
      ],
      "metadata": {
        "id": "hh-cJEpjVYQ7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(dg,['11#'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "EMfyqkmNV5hm",
        "outputId": "e9061339-5c94-42fa-8a99-395bf074b80b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1#1#1##11#'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Examples of segments:\n",
        "\n",
        "    ['top','cases',1,'empty', 'one_found','hash_found'],\n",
        "    ['empty', 'goto', 'moveback'],\n",
        "    ['one_found', 'add1', 2],\n",
        "    ['111#111##'],\n",
        "    ['goto', 'top'],\n",
        "    ['hash_found', 'add#', 2],\n",
        "    ['111#111##111##'],\n",
        "    ['goto', 'end'],\n",
        "    ['moveback', move(3,1)+move(2,1)]\n",
        "  \n"
      ],
      "metadata": {
        "id": "ZM8aBsOpbn6x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Further programs and exercises"
      ],
      "metadata": {
        "id": "CHiDS-cteu2Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This code cell contains a Sane program which multiplies the contents of\n",
        "#   registers one and two and stores the product back into register one\n",
        "\n",
        "sane_multiply = [\n",
        "  [move(1,4)],\n",
        "  ['1##'],\n",
        "  [copy(2,5,10)],\n",
        "  ['111##'],\n",
        "  [copy(3,6,10)],\n",
        "  [compare(2,3)],\n",
        "  ['multiply_loop', 'cases', 2, 'empty', 'one', 'sharp'],\n",
        "    ['empty', copy(4,7,10)],\n",
        "      [add(1,4,10)],\n",
        "      [move(7,4)],\n",
        "      [copy(5,2,10)],\n",
        "      [successor(6,10)],\n",
        "      [copy(6,3,10)],\n",
        "      [compare(2,3)],\n",
        "      ['goto', 'multiply_loop'],\n",
        "    ['one', 'goto', 'epilogue'],\n",
        "    ['sharp', 'goto', 'end'], # We shouldn't reach here because cmp shold never\n",
        "                              #   write sharp into register two\n",
        "  ['epilogue', clear(4)],\n",
        "    [clear(5)],\n",
        "    [clear(6)]\n",
        "]\n",
        "onesharp_multiply = sanity(sane_multiply)\n",
        "onesharp(onesharp_multiply, ['11', '1#1']) # 11*1#1 = 1111 <==> 3*5 = 15"
      ],
      "metadata": {
        "id": "l_A-morkdi8R",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "aab663f3-79f8-4f3c-d93f-142be6c384c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1111'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This code cell contains a Sane program which exponentiates the contents of\n",
        "#   register one to the power of the contents of register two and stores the\n",
        "#   result back into register one\n",
        "\n",
        "sane_exponentiate = [\n",
        "  [move(1,14)],\n",
        "  [ones(11)+'#'],\n",
        "  [move(2,12)],\n",
        "  [copy(12,15,20)],\n",
        "  [ones(13)+'##'],\n",
        "  [copy(13,16,20)],\n",
        "  [compare(12,13)],\n",
        "  ['exponentiate_loop', 'cases', 12, 'empty', 'one', 'sharp'],\n",
        "    ['empty', move(11,1)],\n",
        "      [copy(14,2,20)],\n",
        "      [onesharp_multiply],\n",
        "      [move(1,11)],\n",
        "      [copy(15,12,20)],\n",
        "      [successor(16,20)],\n",
        "      [copy(16,13,20)],\n",
        "      [compare(12,13)],\n",
        "      ['goto', 'exponentiate_loop'],\n",
        "    ['one', 'goto', 'epilogue'],\n",
        "    ['sharp', 'goto', 'end'], # We shouldn't reach here because cmp shold never\n",
        "                              #   write sharp into register two\n",
        "  ['epilogue', move(11,1)],\n",
        "    [clear(14)],\n",
        "    [clear(15)],\n",
        "    [clear(16)]\n",
        "]\n",
        "onesharp_exponentiate = sanity(sane_exponentiate)\n",
        "onesharp(onesharp_exponentiate, ['11', '1#1']) # 11^1#1 = 11##1111 <==> 3^5 = 243"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "gPm5rsTUdjfy",
        "outputId": "c804299f-8c27-4a58-f305-44267848a8eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'11##1111'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(onesharp_exponentiate, ['11', '###1']) # 11^###1 = 1####1#11##11 <==> 3^8 = 6561\n",
        "# 6561 base 2 is 1100110100001"
      ],
      "metadata": {
        "id": "a4H1SZi7XaTY",
        "outputId": "1d6afb43-19ec-485b-a4cc-884dae2c9bb5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1####1#11##11'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pre_pred = [\n",
        "   ['top', 'cases', 1, 'first_end', 'first_one', 'first_hash'],\n",
        "   ['first_one', 'cases', 1, 'hash_is_it', 'returnA','returnB'],\n",
        "   ['hash_is_it', '1##'],\n",
        "   ['goto', 'second_end'],\n",
        "   ['returnA', '11#11#'],\n",
        "   [move(1,2) + move(2,1)],\n",
        "   ['goto', 'end'], \n",
        "   ['returnB', '11#11##'],\n",
        "   [move(1,2) + move(2,1)],\n",
        "   ['goto', 'end'], \n",
        "   ['first_hash', 'cases', 1, 'first_end', 'hash_one', 'hash_hash'],\n",
        "   ['hash_one','11##'],\n",
        "   ['hash_hash','1###'],\n",
        "   ['second_end', '1111#'],\n",
        "   ['goto', 'end'],\n",
        "   ['first_end', '111#']\n",
        " ]"
      ],
      "metadata": {
        "id": "HCI5EAOgYAjt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(sanity(pre_pred), ['#1'])"
      ],
      "metadata": {
        "id": "6rACbr-pbKGK",
        "outputId": "dd044cf6-3a4d-4337-b3bc-71ff558a78e9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 210
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is undefined.\n",
            "The register contents at the end are shown below.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<pandas.io.formats.style.Styler at 0x7f59f79ee4d0>"
            ],
            "text/html": [
              "<style type=\"text/css\">\n",
              "#T_6135c_row0_col0, #T_6135c_row1_col0, #T_6135c_row2_col0, #T_6135c_row3_col0 {\n",
              "  background-color: #FFFFCC;\n",
              "  text-align: left;\n",
              "}\n",
              "</style>\n",
              "<table id=\"T_6135c_\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr>\n",
              "      <th class=\"blank level0\" >&nbsp;</th>\n",
              "      <th class=\"col_heading level0 col0\" >contents</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th id=\"T_6135c_level0_row0\" class=\"row_heading level0 row0\" >1</th>\n",
              "      <td id=\"T_6135c_row0_col0\" class=\"data row0 col0\" ></td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_6135c_level0_row1\" class=\"row_heading level0 row1\" >2</th>\n",
              "      <td id=\"T_6135c_row1_col0\" class=\"data row1 col0\" >#</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_6135c_level0_row2\" class=\"row_heading level0 row2\" >3</th>\n",
              "      <td id=\"T_6135c_row2_col0\" class=\"data row2 col0\" ></td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th id=\"T_6135c_level0_row3\" class=\"row_heading level0 row3\" >4</th>\n",
              "      <td id=\"T_6135c_row3_col0\" class=\"data row3 col0\" >1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pred = [\n",
        "     ['top','cases', 1, 'a', 'b','c'],   \n",
        "     ['a', 'goto', 'end'],\n",
        "     ['b', 'cases', 1, 'oe', 'oo', 'oh'],\n",
        "     ['oe', '1##'],\n",
        "     ['goto', 'end'],\n",
        "     ['oo', '11#11#'+move(1,2)+move(2,1)],\n",
        "     ['goto', 'main'],\n",
        "     ['oh', '11#11##'+move(1,2)+move(2,1)],\n",
        "     ['goto', 'main'],\n",
        "     ['c', 'cases', 1, 'he', 'ho', 'hh'],\n",
        "     ['he', '1##'],\n",
        "     ['goto', 'end'],\n",
        "     ['ho', '11##11#'+move(1,2)+move(2,1)],\n",
        "     ['goto', 'main'],\n",
        "     ['hh', '11##11##'+move(1,2)+move(2,1)],\n",
        "     ['goto', 'main'],    \n",
        "     ['main', 'cases', 1, 'empty', 'one','hash'],\n",
        "     ['empty', move(2,1)],\n",
        "     ['goto', 'end'],\n",
        "     ['one', '11##'],\n",
        "     [move(1,2) + move(2,1)],\n",
        "     ['goto', 'end'],\n",
        "     ['hash', '11#'],\n",
        "     ['borrowing', 'cases', 1, 'borrowing_empty', 'borrowing_one', 'borrowing_hash'],\n",
        "     ['borrowing_empty', move(2,1)],\n",
        "     ['goto', 'end'],\n",
        "     ['borrowing_one', '11##'],\n",
        "     [move(1,2) + move(2,1)],\n",
        "     ['goto', 'end'],\n",
        "     ['borrowing_hash', '11#'],\n",
        "     ['goto','borrowing']\n",
        "]"
      ],
      "metadata": {
        "id": "0RI_oHqycIE5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "p1 = sanity(pred)\n"
      ],
      "metadata": {
        "id": "It_-TCiJhyHx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(p1,['1#'])"
      ],
      "metadata": {
        "id": "wxlu8HIUhzxG",
        "outputId": "3553fa9e-9783-4f7c-e82b-7c29d9f9cca2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'##'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id = [ ['all_h', 'cases', 1, 'a', 'b', 'c'],\n",
        "       ['a', '1##'+clear(2)],\n",
        "       ['goto', 'end'],\n",
        "       ['b', '11#'],\n",
        "       [move(1,2)+move(2,1)],\n",
        "       ['goto', 'end'],\n",
        "       ['c', '11##'],\n",
        "       ['goto', 'all_h']\n",
        "      ]\n",
        "\n",
        "rectify=sanity(id)"
      ],
      "metadata": {
        "id": "EZZsDX8Lh2yp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(rectify,['##1'])"
      ],
      "metadata": {
        "id": "Sl3nbpituNZw",
        "outputId": "06b99d99-7aad-4516-d935-aab1dcaac826",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'##1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pr = p1 + rectify"
      ],
      "metadata": {
        "id": "cjLmQjgfubNV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "onesharp(pr,['1##'])"
      ],
      "metadata": {
        "id": "Ud4Qoo91uvd1",
        "outputId": "bf984a22-8bd9-43ab-db71-e7cdb725502f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'#'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pr"
      ],
      "metadata": {
        "id": "qAuTowHCux8r",
        "outputId": "ed06ddeb-a1f7-4a49-bd61-ed435b9b1f99",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1#####111###111###111111111111111111111111111111111111111111###11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111###1#####111###1111###11111111111111111111###1##11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111###11#11#1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####1111111111111111111111111111111111111111111111111111111111###11#11##1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####11111111111111111111111111111111111111111###1#####111###1111###11111111111111111111###1##1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111###11##11#1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####111111111111111111###11##11##1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####1###1#####111###1111111111###1111111111111111111111111###11#####11111 1###111###1##1111####1#11111 1####111111111111111111111111111111111111111111111111###11##1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####11111111111111111111111111111111###11#1#####111###1111111111###1111111111111111111111111###11#####11111 1###111###1##1111####1#11111 1####1111111111111111111###11##1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####111###11#11111111111111111111111111111####1#####111###11111111###11111111111111111111111###1##11#####111###11####111####1111111111111111111###11#1#####11111 1###111###11##1111####11#11111 1####11#####11111 1###111###1##1111####1#11111 1####111###11##111111111111111111111111111####'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    }
  ]
}